Magic methods (dunder methods) in Python are special methods used to customize object behavior. They start and end with a double underscore, such as __init__ or __str__, and are automatically triggered when a specific syntax or built-in function is used. 1. __init__ is used to initialize the object; 2. __str__ and __repr__ define the readable string representation and reconstructible expression of the object respectively; 3. __add__, __sub__, etc. define the addition and subtraction behaviors; 4. __eq__, __lt__ and other control comparison operations. Implementing these methods, such as adding __add__ to custom class Point to support operations, makes the class behave more naturally and in line with expectations. When using it, you should pay attention to the reasonable return type, avoid modifying the original object, dealing with error types, and maintaining intuitive design.

In Python, magic methods—also known as dunder methods (short for "double underscore")—are special methods that let you customize how your objects behave in various operations. These aren't meant to be called directly like regular methods; instead, they're triggered automatically when certain syntax is used or built-in functions are applied.

What makes dunder methods special?

They're surrounded by double underscores, like __init__ or __str__ , and they let you define behaviors for your objects that integrate with Python's core features. For example, when you use the operator on two custom objects, a specific dunder method ( __add__ ) is what determines how that addition works.

Commonly Used Dunder Methods

Here are some of the most frequently used ones:

• Object Initialization :
  __init__ – This is the constructor method, called after the object is created. It's where you usually set up your instance attributes.

• String Representation :
  __str__ – Called by the str() function and print() . It should return a readable string representation of the object.
  __repr__ – Called by repr() . Should be a valid Python expression that could recreate the object.

  

• Arithmetic Operations :
  __add__ – Defines behavior for the operator.
  __sub__ – Defines behavior for the - operator.
  There are also __mul__ , __truediv__ , and more.

• Comparison Operators :
  __eq__ – Equal ( == ).
  __lt__ – Less than ( ).<br> And others like <code>__gt__ , __le__ , etc.

These are just a few examples. Each one gives you control over how your class interacts with standard operators and functions.

How to Use Dunder Methods Effectively

Let's say you have a simple class like this:

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

If you create two instances and try to add them using , you'll get an error. That's because Python doesn't know how to handle it unless you define __add__ .

You can fix that by adding:

 def __add__(self, other):
    return Point(self.x other.x, self.y other.y)

Now when you do something like p1 p2 , it will work as expected and return a new Point .

A few tips:

• Make sure the return type makes sense for your use case.
• Don't modify the original objects unless that's intentional.
• Consider handling incorrect types gracefully, maybe by returning NotImplemented .

Also, don't overdo it. Just because you can override behavior doesn't mean you always should. Keep things intuitive.

When Are Dunder Methods Called?

Most of the time, you won't call them directly like obj.__str__() . Instead, Python calls them behind the scenes.

For example:

• len(obj) triggers __len__
• str(obj) triggers __str__
• obj[key] triggers __getitem__

Some are required if you want to support certain interfaces. Like if you want your class to work in a for loop, you'll need to implement __iter__ and __next__ (or delegate to another iterable).

One thing to note: some dunder methods are optional. If you don't define them and someone tries to use them, Python will raise an error.

Dunder methods give you fine-grained control over how your objects interact with Python's syntax and built-in functions. They make classes feel more natural to use and help avoid clunky APIs.

Once you understand a few key ones, it becomes easier to write classes that “just work” the way users expect.

And honestly, once you've defined __repr__ or __add__ for a class, you start wondering how you ever lived without them.

Basically that's it.

The above is the detailed content of What are magic methods (dunder methods) in Python?. For more information, please follow other related articles on the PHP Chinese website!