Uso de super con un método de clase

Question

Estoy tratando de aprenderme la función super() en Python.

Creo haberlo entendido hasta que encontré este ejemplo (2.6) y me encontré atascado.

http://www.cafepy.com/article/python_attributes_and_methods/python_attributes_and_methods.html#super-with-classmethod-example

Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "test.py", line 9, in do_something 
    do_something = classmethod(do_something) 
TypeError: unbound method do_something() must be called with B instance as first argument (got nothing instead) 
>>> 

No era lo que esperaba cuando leí esta línea justo antes de que el ejemplo:

If we're using a class method, we don't have an instance to call super with. Fortunately for us, super works even with a type as the second argument. --- The type can be passed directly to super as shown below.

¿Qué es exactamente lo que Python me dice que no es posible diciendo que hacer_algo() debe invocarse con una instancia de B.

Gracias de antemano

Answer 1

A veces, los textos tienen que leerse más por el sabor de la idea que por los detalles. Este es uno de esos casos. todo

En el linked page, los Ejemplos 2.5, 2.6 y 2.7 deben utilizar un método, do_your_stuff. (Es decir, do_something debería cambiarse a do_your_stuff.)

Además, como Ned Deily pointed out, A.do_your_stuff tiene que haber un método de clase.

class A(object): 
    @classmethod 
    def do_your_stuff(cls): 
     print 'This is A' 

class B(A): 
    @classmethod 
    def do_your_stuff(cls): 
     super(B, cls).do_your_stuff() 

B.do_your_stuff() 

super(B, cls).do_your_stuff devuelve un atado método (ver footnote 2). Como se pasó el cls como el segundo argumento al super(), es cls que se enlaza al método devuelto. En otras palabras, cls se pasa como el primer argumento del método do_you_stuff().

Así super(B, cls).do_your_stuff() provoca do_your_stuff método A 's para ser llamada con cls pasado como primer argumento. Para que eso funcione, A ' do_your_stuff tiene que ser un método de clase. La página vinculada no menciona eso, pero es verdad.

PS. do_something = classmethod(do_something) es la forma antigua de hacer una clase de método. La nueva forma (er) es usar el decorador @classmethod.

Answer 2

El ejemplo de la página web parece funcionar según lo publicado. ¿Creaste también un método do_something para la superclase, pero no lo convertiste en un método de clase? Algo como esto le dará ese error:

>>> class A(object): 
...  def do_something(cls): 
...   print cls 
... # do_something = classmethod(do_something) 
... 
>>> class B(A): 
...  def do_something(cls): 
...   super(B, cls).do_something() 
...  do_something = classmethod(do_something) 
... 
>>> B().do_something() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 3, in do_something 
TypeError: unbound method do_something() must be called with B instance as first argument (got nothing instead) 

Answer 3

Creo que he entendido el punto ahora gracias a este hermoso sitio y encantadora comunidad.

Si no te importa por favor, corríjanme si me equivoco en classmethods (que ahora estoy tratando de entender por completo):

# EXAMPLE #1 
>>> class A(object): 
...  def foo(cls): 
...    print cls 
...  foo = classmethod(foo) 
... 
>>> a = A() 
>>> a.foo() 
# THIS IS THE CLASS ITSELF (__class__) 
class '__main__.A' 

# EXAMPLE #2 
# SAME AS ABOVE (With new @decorator) 
>>> class A(object): 
...  @classmethod 
...  def foo(cls): 
...    print cls 
... 
>>> a = A() 
>>> a.foo() 
class '__main__.A' 

# EXAMPLE #3 
>>> class B(object): 
...  def foo(self): 
...    print self 
... 
>>> b = B() 
>>> b.foo() 
# THIS IS THE INSTANCE WITH ADDRESS (self) 
__main__.B object at 0xb747a8ec 
>>> 

espero que esta ilustración se muestra ..

Answer 4

He actualizado el artículo para que sea un poco más claro: Python Attributes and Methods # Super

Su ejemplo usando classmethod anterior muestra lo que es un método de clase es - que pasa a la propia clase en lugar de la instancia como primer parámetro. Pero usted ni siquiera necesita una instancia para llamar al método, por ejemplo:

>>> class A(object): 
...  @classmethod 
...  def foo(cls): 
...   print cls 
... 
>>> A.foo() # note this is called directly on the class 
<class '__main__.A'> 

Answer 5

En Python 3, puede omitir argumentos que especifican para super,

class A: 
    @classmethod 
    def f(cls): 
     return "A's f was called." 

class B(A): 
    @classmethod 
    def f(cls): 
     return super().f() 

assert B.f() == "A's f was called."