Let’s use the following classes for demonstration: class A(object): def m(self): print(‘m’) class B(A): pass Unbound super object doesn’t dispatch attribute access to class, you have to use descriptor protocol: >>> super(B).m Traceback (most recent call last): File “<stdin>”, line 1, in <module> AttributeError: ‘super’ object has no attribute ‘m’ >>> super(B).__get__(B(), B) <super: <class … Read more
In Python-3.x you generally don’t need the arguments for super anymore. That’s because they are inserted magically (see PEP 3135 — New Super). The two argument call and the no-argument call are identical if: The first argument is the class in which the method is defined that uses super. In your case it’s Ball so … Read more
Categories extend the original class, but they don’t subclass it, therefore a call to super doesn’t find the method. What you want is called Method Swizzling. But be aware that your code could break something. There’s an article on Theocacao written by Scot Stevenson about Method Swizzling in the old Objective-C runtime, Cocoa with Love … Read more
I was trying to find the correct language to back up why this behavior is the way it is, so as not to give you a “because it just is” answer… But it seems this question has been asked more than once, and that it boils down to the behavior of super(). You can see … Read more
There isn’t and shouldn’t be anything to do that. The closest thing I can think of off hand if something like having this in the base class: public virtual void BeforeFoo(){} public void Foo() { this.BeforeFoo(); //do some stuff this.AfterFoo(); } public virtual void AfterFoo(){} And allow the inheriting class override BeforeFoo and/or AfterFoo
The two-argument form is only needed in Python 2. The reason is that self.__class__ always refers to the “leaf” class in the inheritance tree — that is, the most specific class of the object — but when you call super you need to tell it which implementation is currently being invoked, so it can invoke … Read more
[*] TL;DR: This “empty __class__ cell” error will happen when the metaclass tries to call a method in the defined class (or instantiate it) before it is done with its __new__ and __init__,and the called method uses super. The error will also happen if one writes a call to super() in a function defined outside … Read more
super() is not broken — it just should not be considered the standard way of calling a method of the base class. This did not change with Python 3.x. The only thing that changed is that you don’t need to pass the arguments self, cls in the standard case that self is the first parameter … Read more
Consider the following situation: class A(object): def __init__(self): print(‘Running A.__init__’) super(A,self).__init__() class B(A): def __init__(self): print(‘Running B.__init__’) # super(B,self).__init__() A.__init__(self) class C(A): def __init__(self): print(‘Running C.__init__’) super(C,self).__init__() class D(B,C): def __init__(self): print(‘Running D.__init__’) super(D,self).__init__() foo=D() So the classes form a so-called inheritance diamond: A / \ B C \ / D Running the code yields … Read more
Python function objects are descriptors, and Python uses the descriptor protocol to bind functions to an instance. This process produces a bound method. Binding is what makes the ‘magic’ self argument appear when you call a method, and what makes a property object automatically call methods when you try to use the property as an … Read more