Why Does Rebinding `super()` Break Your Python Code?

Why Rebinding super() Can Break Code

In Python 3.x, the super() function can be called without arguments to access the superclass's methods. This behavior is enabled by a compile-time magic trick that establishes a connection between super() and the calling class. However, if the super name is rebound to a different variable (super_ in the example), this connection is broken.

The reason for this is the D.R.Y. (Don't Repeat Yourself) principle. Explicitly naming the calling class in calls to the superclass violates this principle and increases the risk of rebinding issues. Additionally, using class decorators that change the class name also disrupts the reference to the original class object.

By creating an invisible class cell within a closure around the function containing super(), the magic implementation of super() avoids these issues. The cell references the original class object, ensuring that super() can always access the correct superclass, even if the super name is rebound.

While this behavior may seem surprising, it's important to note that super() is often misused. By simplifying the call syntax and avoiding infinite recursion pitfalls, the updated implementation helps prevent errors.

If super is rebound, referencing class in the method restores its functionality. This is because the cell is created when either super or class is used within the method.

The above is the detailed content of Why Does Rebinding `super()` Break Your Python Code?. For more information, please follow other related articles on the PHP Chinese website!