Exploring 10 Magic Methods in Python Every Programmer Should Know

Exploring 10 Magic Methods in Python Every Programmer Should

Last updated on January 24th, 2024

What are magic methods in Python?

Magic methods (also known as dunders or special methods) in Python are distinguished by a double underscore prefix and suffix (e.g __init__, __len__, __eq__).

They give instructions to the Python interpreter to augment behavior of built-in types and classes for more intuitive syntax.

For example overloading the + operator for clean string concatenation:

class Combiner:

  def __init__(self, word):  
    self.word = word

  def __add__(self, other):
    return self.word + other.word

c1 = Combiner('Hello')
c2 = Combiner('World')

print(c1 + c2) # HelloWorld

The __add__ method enables the + operator merging two Combiner objects intuitively through overloading.

In this guide, we will explore the top 10 most useful magic methods in Python with simple examples illustrating their behaviors and applications. Let’s get started!


The __init__ method gets invoked automatically whenever a new object gets created from a class blueprint:

class Point:
  def __init__(self, x, y):
    self.x = x
    self.y = y

p = Point(1, 2) # Initializes new Point
print(p.x, p.y) # 1 2

It constructs the object setting any properties during creation. Parameters like x and y get passed supplying initial values.

Think of this like an automatic constructor method. Common applications:

  • Initialize object with default values
  • Set instance properties
  • Validate or transform input parameters
  • Attach decorated functionality

The self parameter grants access for assigning values.


__str__ controls string representation of classes enabling readable printing:

class Post:
  def __init__(self, title):
    self.title = title
  def __str__(self):
    return f'Post: {self.title}'

post = Post('Magic Methods')

print(str(post)) # neatly prints Post: Magic Methods

Omitting this displays the class name and memory address which is messy:

<__main__.Post object at 0x7fae7c8d42e0>

Leveraging __str__ makes debugging and logging output user friendly.


__len__ returns the length aka size of containers when passed to Python’s globally accessible len() function:

class ShoppingCart:

  def __init__(self):
    self.items = []
  def add(self, item):
  def __len__(self):
    return len(self.items)

cart = ShoppingCart()  

print(len(cart)) # 2 items

Defining length functionality allows integrating cleanly with built-ins like len() and practical customization like limiting cart sizes.


__eq__ handles equality comparisons with the == operator instead of default object identity:

class Account:

  def __init__(self, balance):
    self.balance = balance
  def __eq__(self, other):
    return self.balance == other.balance

a1 = Account(500)  
a2 = Account(500)

print(a1 == a2) # True, same balance

Now comparisons match logically based on attribute state instead of comparing object instances.


__getitem__ enables sequence container indexing for intuitive access:

class Membership:

  def __init__(self):
    self.members = ['John', 'Mary', 'Bob']
  def __getitem__(self, i):
    return self.members[i]

m = Membership()
print(m[1]) # Mary

This translates index lookups into returned member names supporting iteration:

for member in m: 
   print(member) # Prints members


__setitem__ hooks into assignment allowing intuitive value setting behavior:

class Metrics:

  def __init__(self):
    self.data = {}
  def __setitem__(self, key, value):
    self.data[key] = value

metrics = Metrics()  
metrics['users'] = 100 

print(metrics.data) # {'users': 100}

Enables nicer metrics[‘users’] = 100 syntax for assignment instead of messy metrics.data[‘users’]. Useful for managing internal state.


Making objects callable via __call__ overrides direct invocation on the instance:

class Transformer:
  def __init__(self, func):
    self.func = func  

  def __call__(self, *args, **kwargs):
    print(f'Transforming input: {args}, {kwargs}') 
    return self.func(*args, **kwargs)

def multiply(a, b):
  return a * b

multiply_wrapper = Transformer(multiply)
res = multiply_wrapper(2, 3)  

# Transforming input: (2, 3), {}  
# 6

The wrapped function gets invoked when multiply_wrapper gets called directly. Useful for transparently extending callables with extra logging, validators or timers.


__iter__ delivers iterator protocol allowing containers to be looped over directly in clean loops:

class Odds:

  def __init__(self, max):
    self.max = max - 1
  def __iter__(self):
    self.num = 1
    return self

  def __next__(self):
    num = self.num
    self.num += 2  
    if self.num > self.max:
       raise StopIteration
    return num

odds = Odds(10)
for n in odds:
  print(n) # Prints 1..9

The iterator handles Python’s next() logic while iter() prepares state. Together they construct the mutable traversal mechanism.


__add__ overloads the + operator to amalgamate objects cleanly:

class Concat:

  def __init__(self, word):  
    self.word = word

  def __add__(self, other):
    return self.word + other.word

c1 = Concat('Hello')  
c2 = Concat('World')

print(c1 + c2)
# HelloWorld

This enables intuitive concatenation syntax specifically for custom types through operator overloading.


__repr__ returns the low-level string representation of objects matching default print behavior:

class Student:
  students_list = []
  def __init__(self, name):
    self.name = name
  def __repr__(self):
    return f'<Student {self.name}>'

john = Student('John')  
# <Student John>

Ideal for encoding objects as string debug information in console printouts and REPL inspection.


Python’s abundance of magic methods unlock expressive syntax and behaviors for user-defined classes that come naturally to built-ins. Mastering them helps fully leverage Python’s object oriented domain capabilities for clean, production-grade applications.

They grant the flexibility to override mechanics ranging from function invocation to sequence iteration allowing rich customization aligned with end goals.

Here are additional parting notes:

  • Review Python’s data model and ABC hierarchies before applying magic methods
  • Utilize dir() and help() when needing to introspect capabilities
  • Optimize selectively based on evidenced bottlenecks vs premature usage
  • Discover even more special methods as needs arise in practice over time

Adopting these magic methods empowers building abstractions that delight other developers leveraging your Python packages and modules.

Frequently Asked Questions

Are magic methods slow compared to regular functions?

They can incur slightly more overhead when invoked but modern Python implementations mean this is usually negligible for typical workloads. Only optimize based on observed bottlenecks.

When should I make objects callable with __call__?

Use judiciously when it truly conveys more intuitive interfaces. Good examples are factories producing proxy objects or transformers wrapping core logic. Apply only after sufficient analysis.

How do magic methods relate to operator overloading?

Python explicitly disallows C++ style classic operator overloading in favor of implicit magic methods like add() and getitem(). This offers flexibility while avoiding complex precedence remembering for developers.

What are some key magic methods for custom contexts?

__enter__ and __exit__ enable objects for use in with statements while getstate and setstate control serialization with pickle. Look through the full list and keep applicable methods bookmarked.

We hope these answers provide more direction leveraging magic methods appropriately as part of your toolbox. Feel free to explore additional Python communities for guidance applying them in sophisticated applications.

Leave a Reply

Your email address will not be published. Required fields are marked *