Underscoring (or dunder-scoring) the importance of native type methods in Python 

All information in Python resides in objects. And all Python objects have a sort with related attributes and strategies. However as a result of Python makes use of dynamic typing to permit flexibility, it doesn’t at all times know the kind of a given object. So capabilities you suppose ought to exist as members of an object while you instantiate could very nicely not. 

Thankfully, you’ll be able to guarantee that you’ve got the appropriate capabilities to your courses and objects while you outline them utilizing one thing referred to as dunder strategies or magic strategies. You possibly can shortly acknowledge these operations by the double underscore or “dunder” format: __methodname__()

Each Python programmer ought to know methods to use dunder strategies to provide native information kind functionalities to your user-defined objects. Dunder strategies will let you present your personal courses with enriched performance, streamlining your code and avoiding sophisticated, messy makes an attempt to manually replicate the capabilities accessible for built-in Python information sorts.

Understanding the Python native information sorts

To totally perceive dunder strategies, you first want to grasp the essential built-in Python information sorts and among the capabilities related to them which you can replicate to your personal courses.

Python object sorts have a number of traits. First, they could be single worth object sorts (e.g., numbers or characters) or container/assortment object sorts (e.g., lists and arrays).

Second, Python sorts can be mutable or immutable. Mutable object sorts have contents that may be modified. However, immutable object sorts stay mounted and can’t be altered.

Every built-in information kind in Python has its personal set of dunder strategies. You possibly can shortly see an inventory of all dunder strategies for a knowledge kind utilizing the dir() operate. More often than not, you’ll not name these strategies instantly or override their definition, as they’re related to sure particular capabilities. Till, in fact, it’s essential use them along with your objects.

Whereas it might sound overly easy to return over frequent information sorts, it’s simply as vital to know the fundamentals as it’s to know extra superior info like how to identify vulnerabilities in your code for safety functions.


Whereas numeric sorts are pretty self-explanatory, you have to be conscious of three subsets: 

Sort Description Instance Constructor
Integer Optimistic or adverse complete numbers 1, 2, 3, -1 int()
Floating-point Rational numbers, i.e. decimals and fractions 1.5, 2.75, 3.5 float()
Advanced Numbers with an actual and imaginary half, every of which itself is a floating-point quantity. 10 + 5j comlex()

Numeric sorts permit for a variety of mathematical operations related to dunder strategies. For instance, the addition operator + corresponds to the dunder methodology __add__(). Further mathematical dunders embody __sub__, __mul__, __divmod__, __abs__, __lt__, __gt__, __le__, and so on. (which even have related operator symbols, for instance, -, *, / <, >).

Sometimes, you simply use customary operators as an alternative of those capabilities. For instance, if you wish to add 10 to a quantity, you’d use the usual operator num + 10 reasonably than num.__add__(10). Nonetheless, if you wish to make these standard operators work with user-defined objects, it’s essential implement dunder strategies within the information kind.   


Python has a number of native information sorts that take care of sequences, whether or not of alphanumeric characters, binary numbers, or gadgets. Sequence sorts have a variety of makes use of, together with sorting, storage, and looping.

Sort Description Instance Constructor
Listing The broadest class of sequence information sorts contains a number of subtypes: 
Lists are mutable (i.e. modifiable) sequences, usually of comparable or homogeneous gadgets
Tuples are immutable (i.e. they can’t change state or content material) sequences, significantly helpful for various or heterogeneous gadgets
Ranges are immutable sequences of numbers, most frequently used for managing loops
Listing: a, b, c, d, e
Tuple: 3, pink, [corvettes, porsches]
Vary: 0 (begin worth), 100 (cease worth), 10 (iterative step) 
record() tuple() vary()
Textual content A text-specific sequence kind, this kind encompasses sequences of Unicode characters. Hey world str()
Binary Python has three totally different binary-specific sequence information sorts: 
Bytes are immutable sequences of single bytes. 
Byte arrays are the mutable model of bytes. 
memoryview objects permit Python to entry and manipulate the content material of a byte-type object with out first copying it. These sorts permit the manipulation of binary objects and the conversion of string information to binary for machine storage.
Byte: 244
Bytearray: [2, 4, 6, 8]
Memoryview: 64 or [10, 20, 30]

Sequence dunders embody __contains__, __getitem__, __delitem__ and extra. 

One of many extra extensively used capabilities for sequence information is len(), which returns the size of an merchandise. Trying to make use of the built-in len() operate on a customized class returns an attribute error. Nonetheless, by implementing the __len__ dunder in your class, you’ll be able to replicate built-in performance. The identical is true for different frequent, helpful sequence capabilities like get_item(), set_item(), and extra. You possibly can then use these objects wherever you’d a local sequence kind with out altering code. 


Half native information kind, half operator, Booleans are single worth sorts that consider the reality or falsity of an announcement. The Boolean information kind makes use of the bool() constructor and has only two possible values: true and false. The corresponding Boolean dunder is __bool__().

You need to use __bool__() to redefine when an object will return true versus false. In reality worth testing, the default state of an object is at all times true except the coder features a particular set of situations for reality within the class definition. Nonetheless, in the event you solely need the item to be true if a sure state of the item is inside a given vary, you’d use __bool__() to set the situations for a real end result.

Let’s take a look at a really simplified instance of utilizing __bool__. Say you could have a category for automobiles that incorporates sure attributes just like the yr, make, mannequin, and coloration. You understand that whereas you will retailer information about a variety of automobiles, most of your operations will contain solely pink or black automobiles. You need to use __bool__ in defining the category to return true just for pink or blue automobiles:

Class Automobile:
	def __init__(self, yr, make, mannequin, coloration)
		self.yr = yr
		self.make = make
		self.mannequin = mannequin
		self.coloration = coloration

	def __bool__(self)
if self.coloration = ‘pink’ or self.coloration = ‘black’ 
	return True
return False

Now, reasonably than utilizing specific conditional statements in later coding, you’ll be able to merely set situations based mostly on the boolean end result for objects of your class.

Units, Mappings, and Dictionaries 

As with different sorts, the native set information sorts (that are containers) embody mutable and immutable variants, utilizing the set() and frozen set() constructors, respectively. Units differ from lists in that units are unordered collections, the place the person parts should be hashable (i.e. they should have a relentless hash worth throughout their lifespan). Be aware, nevertheless, that the set kind itself isn’t hashable, though it incorporates hashable gadgets, as a result of it’s mutable.

Examples of units embody [5, 10, 15, 20] and [5, 10, “Hello”, “World”].

Set sorts are significantly helpful when evaluating teams of things. For instance, you need to use units while you need to decide membership in a bunch, establish frequent parts in teams (i.e. intersection) or parts not in frequent (i.e. distinction and symmetric distinction), or mix teams (i.e. union).

Frozen units, then again, are helpful as dictionary keys. Frozen units can solely have a single worth, however that worth will be nearly something, together with an inventory or a set.

The dictionary kind is a container kind that makes use of the dict() constructor. It creates a number of key:worth pairs between a unique, hashable value (key) and an arbitrary merchandise (worth). For instance, a dictionary kind may need the next key:worth pairs: 1:’Hey’, 2:’world’.

There are lots of extra superior information sorts in Python, together with courses, cases, and exceptions. However as we are going to see, courses and cases don’t essentially come together with the identical dunder strategies as different information sorts.

Units, mappings, and dictionaries, like sequences, can use a wide range of dunders for accessing particular parts of the mapping. Such dunders embody __setitem__, __contains__, ___getitem__, and so on.

There are lots of extra superior information sorts in Python, together with courses, cases, and exceptions. However as we are going to see, courses and cases don’t essentially come together with the identical dunder strategies as different information sorts.

Utilizing dunder strategies in Python

Probably the most well-known dunder strategies in Python are __new__() and  __init__(), which create a category occasion and initialize its state, respectively.  Most python programmers focus overrides on __init__ in order that modifications happen on instantiation of a brand new object, whereas __new__ usually solely creates subclasses of immutable information sorts. The syntax for the init methodology is __init__(self, char1, char 2,...)

So, for instance, you simply bought an e mail promising a great deal of Bitcoin in the event you first simply present a fraction of a Bitcoin to the mail sender, which is a classic example of a phishing rip-off. You need to begin monitoring how a lot bitcoin you could have in your numerous accounts. You could possibly begin by defining a bitcoin pockets object like this:

class btc_wallet(object):

	def __init__(self, wallet_name, quantity):
		self.wallet_name = wallet_name
	 	self.quantity = quantity

You possibly can then initialize an occasion for every of your bitcoin wallets and present us how a lot you could have:

btcwallet1 = btc_wallet('Coinbase', 5)
print("I've", btcwallet1.quantity, "BTC in my", btcwallet1.wallet_name, "pockets (fortunate me!)")

This is able to output “I’ve 5 BTC in my Coinbase pockets (fortunate me!).”

Python doesn’t know what kind the item btc_wallet is. So many customary operations will not be accessible to make use of with it, and if we attempt to take action, we are going to get an error message. However now, let’s take a look at how we’d use dunder strategies so as to add performance to our btc_wallet object kind. 

First, let’s create two extra bitcoin wallets.

btcwallet2 = btc_wallet('Binance', 2)
btcwallet3 = btc_wallet(‘Huobi’, 25)

If you wish to decide how a lot complete bitcoin you could have in your first two wallets it will be tempting to jot down:

total_btc = btcwallet1.quantity + btcwallet2.quantity

However in the event you use the dir() operate on btc_wallet, you’d see that __add__ isn’t current. So we have to modify the category definition with a dunder methodology:

def __add__(self, different):
    return self.quantity + different.quantity

Now we are able to calculate and print our complete:

total_btc = btcwallet1 + btcwallet2
print("I've a complete of", total_btc, "BTC in my wallets (fortunate me!)")

And our output is “I’ve a complete of seven BTC in my wallets (fortunate me!)”

Now, what if we need to complete solely our wallets which have three or extra BTC? We may use a regular if loop, checking the quantity for every pockets and together with solely those the place btcwallet.quantity > 3. However we may additionally return to our dialogue about Booleans above. You possibly can outline btcwallet in order that it is just true if the quantity is bigger than three by including the next to the category definition:

def __bool__(self):
	if self.quantity > 3:
		return True
	return False

Now you’ll be able to arrange the loop to calculate the entire of your wallets:

total_btc = 0

for x in vary (0,3):
loopname = locals()['btcwallet' + (str(x+1))]
if bool(loopname):
    		total_btc = total_btc + loopname.quantity

The output will now be “I’ve a complete of 30 BTC in my wallets (fortunate me!)”. And you’re certainly fortunate as that is approximately $1.2 million.

We are able to use this dunder methodology overloading apply to construct out performance for our courses, whether or not mathematical operations, comparisons, and even constrained Boolean operations.

[Note: code operation was verified using the ExtendsClass Python checker.]


Understanding how native courses and their capabilities work is essential for any Python programmer. And it’s equally vital to dunder-stand methods to prolong these native kind strategies to user-defined courses and objects. 

Tags: dunders, native types, python

More Posts