You have simply made a category.
You made a __init__ methodology.
Now what?

Python consists of tons of dunder strategies (“double underscore” strategies) which permit us to deeply customise how our customized courses work together with Python’s many options.
What dunder strategies might you add to your class to make it pleasant for different Python programmers who use it?

Let’s check out each dunder methodology in Python, with a give attention to when every methodology is helpful.

Word that the Python documentation refers to those as particular strategies and notes the synonym “magic methodology” however very hardly ever makes use of the time period “dunder methodology”.
Nonetheless, “dunder methodology” is a reasonably frequent Python colloquialism, as famous in my unofficial Python glossary.

You should use the hyperlinks scattered all through this web page for extra particulars on any specific dunder methodology.
For a listing of all of them, see the cheat sheet within the remaining part.

The three important dunder strategies 🔑

There are 3 dunder strategies that most courses ought to have: __init__, __repr__, and __eq__.

The __init__ methodology is the initializer (to not be confused with the constructor), the __repr__ methodology customizes an object’s string illustration, and the __eq__ methodology customizes what it means for objects to be equal to at least one one other.

The __repr__ methodology is especially useful on the the Python REPL and when debugging.

Equality and hashability 🟰

Along with the __eq__ methodology, Python has 2 different dunder strategies for figuring out the “worth” of an object in relation to different objects.

Python’s __eq__ methodology usually returns True, False, or NotImplemented (if objects cannot be in contrast).
The default __eq__ implementation depends on the is operator, which checks for identification.

The default implementation of __ne__ calls __eq__ and negates any boolean return worth given (or returns NotImplemented if __eq__ did).
This default habits is often “ok”, so you may nearly by no means see __ne__ applied.

Hashable objects can be utilized as keys in dictionaries or values in units.
All objects in Python are hashable by default, however in the event you’ve written a customized __eq__ methodology then your objects will not be hashable and not using a customized __hash__ methodology.
However the hash worth of an object must not ever change or unhealthy issues will occur so usually solely immutable objects implement __hash__.

For implementing equality checks, see __eq__ in Python.
For implementing hashability, see making hashable objects in Python.

Orderability ⚖️

Python’s comparability operators (<, >, <=, >=) can all be overloaded with dunder strategies as properly.
The comparability operators additionally energy features that depend on the relative ordering of objects, like sorted, min, and max.

In case you plan to implement all of those operators within the typical method (the place x < y can be the identical as asking y >= x) then the total_ordering decorator from Python’s functools module will turn out to be useful.

Kind conversions and string formatting ⚗️

Python has a variety of dunder strategies for changing objects to a distinct kind.

The __bool__ operate is used for truthiness checks, although __len__ is used as a fallback.

In case you wanted to make an object that acts like a quantity (like decimal.Decimal or fractions.Fraction), you may need to implement __int__, __float__, and __complex__ so your objects could be transformed to different numbers.
In case you wished to make an object that may very well be utilized in a memoryview or might in any other case be transformed to bytes, you may need a __bytes__ methodology.

The __format__ and __repr__ strategies are totally different string conversion flavors.
Most string conversions rely the __str__ methodology, however the default __str__ implementation merely calls __repr__.

The __format__ methodology is utilized by all f-string conversions, by the str class’s format methodology, and by the (hardly ever used) built-in format operate.
This methodology permits datetime objects to assist customized format specifiers.

Context managers 🚪

A context supervisor is an object that can be utilized in a with block.

For extra on context managers see, what’s a context supervisor and making a context supervisor.

Containers and collections 🗃️

Collections (a.okay.a. containers) are basically information constructions or objects that act like information stuctures.
Lists, dictionaries, units, strings, and tuples are all examples of collections.

The __iter__ methodology is utilized by the iter operate and for all types of iteration: for loops, comprehensions, tuple unpacking, and utilizing * for iterable unpacking.

Whereas the __iter__ methodology is critical for making a customized iterable, the __next__ methodology is critical for making a customized iterator (which is way much less frequent).
The __missing__ methodology is barely ever referred to as by the dict class on itself, except one other class decides to implement __missing__.
The __length_hint__ methodology provides a size guess for constructions which don’t assist __len__ in order that lists or different constructions could be pre-sized extra effectively.

Additionally see: the iterator protocol, implementing __len__, and implementing __getitem__.

Callability ☎️

Features, courses, and all different callable objects depend on the __call__ methodology.

When a category is known as, its metaclass‘s __call__ methodology is used.
When a category occasion is known as, the category’s __call__ methodology is used.

For extra on callability, see Callables: Python’s “features” are generally courses.

Arithmetic operators ➗

Python’s dunder strategies are sometimes described as a device for “operator overloading”.
Most of this “operator overloading” comes within the type of Python’s numerous arithmetic operators.

There are two methods to interrupt down the arithmetic operators:

• Mathematical (e.g. +, -, *, /, %) versus bitwise (e.g. &, |, ^, >>, ~)
• Binary (between 2 values, like x + y) versus unary (earlier than 1 worth, like +x)

The mathematical operators are way more frequent than the bitwise ones and the binary ones are a bit extra frequent than the unary ones.

These are the binary mathematical arithmetic operators:

Every of those operators consists of left-hand and right-hand strategies.
If x.__add__(y) returns NotImplemented, then y.__radd__(x) shall be tried.
See arithmetic dunder strategies for extra.

These are the binary bitwise arithmetic operators:

These are the Python’s unary arithmetic operators:

The unary + operator usually has no impact, although some objects use it for a selected operation.
For instance utilizing + on collections.Counter objects will take away non-positive values.

Python’s arithmetic operators are sometimes used for non-arithmetic ends: sequences use + to concatenate and * to self-concatenate and units use & for intersection, | for union, - for uneven distinction, and ^ for symmetric distinction.
Arithmetic operators are generally overloaded for extra artistic makes use of too.
For instance, pathlib.Path objects use / to create little one paths.

In-place arithmetic operations ♻️

Python consists of many dunder strategies for in-place operations.
In case you’re making a mutable object that helps any of the arithmetic operations, you may need to implement the associated in-place dunder methodology(s) as properly.

All of Python’s binary arithmetic operators work in augmented project statements, which contain utilizing an operator adopted by the = signal to assign to an object whereas performing an operation on it.

Augmented assignments on mutable objects are anticipated to mutate the unique object, because of the mutable object implementing the suitable dunder methodology for in-place arithmetic.

When no dunder methodology is discovered for an in-place operation, Python performs the operation adopted by an project.
Immutable objects usually do not implement dunder strategies for in-place operations, since they need to return a brand new object as a substitute of fixing the unique.

Constructed-in math features 🧮

Python additionally consists of dunder strategies for a lot of math-related features, each built-in features and a few features within the math library.

Python’s divmod operate performs integer division (//) and a modulo operation (%) on the identical time.

The __index__ methodology is for making integer-like objects.
This methodology losslessly converts to an integer, in contrast to __int__ which can carry out a “lossy” integer conversion (e.g. from float to int).
It is utilized by operations that require true integers, corresponding to slicing, indexing, and bin, hex, and oct features (instance).

Attribute entry 📜

Python even consists of dunder strategies for controlling what occurs whenever you entry, delete, or assign any attribute on an object!

The __getattribute__ methodology is known as for each attribute entry, whereas the __getattr__ methodology is barely referred to as after Python fails to discover a given attribute.
All methodology calls and attribute accesses name __getattribute__ so implementing it accurately is difficult (because of unintended recursion).

The __dir__ methodology ought to return an iterable of attribute names (as strings).
When the dir operate calls __dir__, it converts the returned iterable right into a sorted record (like sorted does).

The built-in getattr, setattr, and delattr features correspond to the dunder strategies of the identical identify, however they’re solely supposed for dynamic attribute entry (not all attribute accesses).

Now we’re stepping into the actually uncommon dunder strategies.
Python consists of many dunder strategies for metaprogramming-related options.

The __prepare__ methodology customizes the dictionary that is used for a category’s preliminary namespace.
That is used to pre-populate dictionary values or customise the dictionary kind (foolish instance).

The __instancecheck__ and __subclasscheck__ strategies override the performance of isinstance and issubclass.
Python’s ABCs use these to apply goose typing (duck typing whereas kind checking).

The __init_subclass__ methodology permits courses to hook into subclass initialization (instance).
Lessons additionally have a __subclasses__ methodology (on their metaclass) nevertheless it’s not usually overridden.

Python calls __mro_entries__ throughout class inheritance for any base courses that aren’t truly courses.
The typing.NamedTuple operate makes use of this to fake it is a class (see right here).

The __class_getitem__ methodology permits a category to be subscriptable (with out its metaclass needing a __getitem__ methodology).
That is usually used for enabling fancy kind annotations (e.g. record[int]).

Descriptors 🏷️

Descriptors are objects that, when hooked up to a category, can hook into the entry of the attribute identify they’re hooked up to on that class.

The descriptor protocol is principally a function that exists to make Python’s property decorator work, although it’s also utilized by a variety of third-party libraries.

Buffers 💾

Implementing a low-level reminiscence array?
You want Python’s buffer protocol.

The __release_buffer__ methodology is known as when the buffer that is returned from __buffer__ is deleted.

Python’s buffer protocol is usually applied in C, because it’s meant for low degree objects.

Asynchronous operations 🤹

Wish to implement an asynchronous context supervisor?
You want these dunder strategies:

• __aenter__: identical to __enter__, nevertheless it returns an awaitable object
• __aexit__: identical to __exit__, nevertheless it returns an awaitable object

Want assist asynchronous iteration?
You want these dunder strategies:

• __aiter__: should return an asynchronous iterator
• __anext__: like __next__ or non-async iterators, however this should return an awaitable object and this could increase StopAsyncIteration as a substitute of StopIteration

Have to make your individual awaitable object?
You want this dunder methodology:

• __await__: returns an iterator

I’ve little expertise with customized asynchronous objects, so look elsewhere for extra particulars.

Building and finalizing 🏭

The previous few dunder strategies are associated to object creation and destruction.

Calling a category returns a brand new class occasion because of the __new__ methodology.
The __new__ methodology is Python’s constructor methodology, although in contrast to constructors in lots of programming languages, you need to nearly by no means outline your individual __new__ methodology.
To manage object creation, want the initializer (__init__), not the constructor (__new__).
This is an odd __new__ instance.

You would consider __del__ as a “destructor” methodology, although it is truly referred to as the finalizer methodology.
Simply earlier than an object is deleted, its __del__ methodology is known as (instance).
Recordsdata implement a __del__ methodology that closes the file and any binary file buffer that it might be linked to.

Library-specific dunder strategies 🧰

Some normal library modules outline customized dunder strategies that are not used anyplace else:

• dataclasses assist a __post_init__ methodology
• abc.ABC courses have a __subclasshook__ methodology which abc.ABCMeta calls in its __subclasscheck__ methodology (extra in goose typing)
• Path-like objects have a __fspath__ methodology, which returns the file path as a string
• Python’s copy module will use the __copy__ and __deepcopy__ strategies if current
• Pickling depends on __getnewargs_ex__ or __getargs__, although __getstate__ and __setstate__ can customise additional and __reduce__ or __reduce_ex__ are even lower-level
• sys.getsizeof depends on the __sizeof__ methodology to get an object’s dimension (in bytes)

Dunder attributes 📇

Along with dunder strategies, Python has many non-method dunder attributes.

Listed here are among the extra frequent dunder attributes you may see:

• __name__: identify of a operate, courses, or module
• __module__: module identify for a operate or class
• __doc__: docstring for a operate, class, or module
• __class__: an object’s class (name Python’s kind operate as a substitute)
• __dict__: most objects retailer their attributes right here (see the place are attributes saved?)
• __slots__: courses utilizing this are extra reminiscence environment friendly than courses utilizing __dict__
• __match_args__: courses can outline a tuple noting the importance of positional attributes when the category is utilized in structural sample matching (match–case)
• __mro__: a category’s methodology decision order used when for attribute lookups and tremendous() calls
• __bases__: the direct father or mother courses of a category
• __file__: the file that outlined the module object (although not all the time current!)
• __wrapped__: features adorned with functools.wraps use this to level to the unique operate
• __version__: generally used for noting the model of a bundle
• __all__: modules can use this to customise the habits of from my_module import *
• __debug__: working Python with -O units this to False and disables Python’s assert statements

These are solely the extra generally seen dunder attributes.
Listed here are some extra:

• Features have __defaults__, __kwdefaults__, __code__, __globals__, and __closure__
• Each features and courses have __qualname__, __annotations__, and __type_params__
• Occasion strategies have __func__ and __self__
• Modules can also have __loader__, __package__, __spec__, and __cached__ attributes
• Packages have a __path__ attribute
• Exceptions have __traceback__, __notes__, __context__, __cause__, and __suppress_context__
• Descriptors use __objclass__
• Metaclasses use __classcell__
• Python’s weakref module makes use of __weakref__
• Generic aliases have __origin__, __args__, __parameters__, and __unpacked__
• The sys module has __stdout__ and __stderr__ which level to the unique stdout and stderr variations

Moreover, these dunder attributes are utilized by numerous normal library modules: __covariant__, __contravariant__, __infer_variance__, __bound__, __constraints__.
And Python features a built-in __import__ operate which you are not supposed to make use of (importlib.import_module is most well-liked) and CPython has a __builtins__ variable that factors to the builtins module (however that is an implementation element and builtins needs to be explicitly imported when wanted as a substitute).
Additionally importing from the __future__ module can allow particular Python function flags and Python will search for a __main__ module inside packages to make them runnable as CLI scripts.

And that is simply most of the dunder attribute names you may discover floating round in Python. 😵

Each dunder methodology: a cheat sheet ⭐

That is each Python dunder methodology organized in classes and ordered very roughly by the mostly seen strategies first.
Some caveats are famous beneath.

The above desk has a slight however constant untruth.
Most of those dunder strategies usually are not truly referred to as on an object immediately however are as a substitute referred to as on the kind of that object: kind(x).__add__(x, y) as a substitute of x.__add__(y).
This distinction principally issues with metaclass strategies.

I’ve additionally purposely excluded library-specific dunder strategies (like __post_init__) and dunder strategies you are unlikely to ever outline (like __subclasses__).
See these beneath.

So, Python consists of 103 “regular” dunder strategies, 12 library-specific dunder strategies, and a minimum of 52 different dunder attributes of varied sorts.
That is over 150 distinctive __dunder__ names!
I don’t advocate memorizing these: let Python do its job and lookup the dunder methodology or attribute that it’s essential implement/discover everytime you want it.

Remember that you are not meant to invent your individual dunder strategies.
Generally you may see third-party libraries that do invent their very own dunder methodology, however this is not inspired and it may be fairly complicated for customers who run throughout such strategies and assume they’re “actual” dunder strategies.