¿Cómo hacer que super() funcione rellenando manualmente la celda __class__?

Question

En Python 3 se puede usar super() en lugar de super(MyClass, self), pero esto solo funciona en métodos que se definieron dentro de la clase. Como se describe en el siguiente ejemplo Michele Simionato's article no funciona:

def __init__(self): 
    print('calling __init__') 
    super().__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

falla porque super() busca una __class__cell, que no se define en este caso.

¿Es posible configurar esta celda manualmente después de que se haya definido la función, o es imposible?

Desafortunadamente, no entiendo cómo funcionan las células en este contexto (no encontré mucha documentación para eso). Estoy esperando por algo así como

__init__.__class_cell_thingy__ = C 

Por supuesto, sólo lo usaría esto en una situación en la asignación de clase no es ambigua/único (todo el proceso de añadir métodos a una clase en la que se automatizado en mi caso, por lo sería simple agregar tal línea).

Answer 1

En serio: realmente no quiere hacer esto.

Pero, es útil para los usuarios avanzados de Python entender esto, así que lo explicaré.

Las celdas y los freevars son los valores asignados cuando se crea un cierre. Por ejemplo,

def f(): 
    a = 1 
    def func(): 
     print(a) 
    return func 

f devuelve un cierre basado en func, almacenar una referencia a a. Esa referencia se almacena en una celda (en realidad en una versión libre, pero cuál corresponde a la implementación). Puede examinar esto:...

myfunc = f() 
# ('a',) 
print(myfunc.__code__.co_freevars) 
# (<cell at 0xb7abce84: int object at 0x82b1de0>,) 
print(myfunc.__closure__) 

("células" y "freevars" son muy similares Freevars tienen nombres, donde las células tienen índices Los dos son almacenados en func.__closure__, con células procedentes primera sólo nos interesan freevars aquí, ya que eso es lo que __class__ es.)

Una vez que comprenda eso, podrá ver cómo funciona super(). Cualquier función que contiene una llamada a super es en realidad un cierre, con un freevar llamado __class__ (que también se añade si se refiere a __class__ mismo):

class foo: 
    def bar(self): 
     print(__class__) 

(Advertencia:. Aquí es donde las cosas se ponen mal)

Estas celdas son visibles en func.__closure__, pero es de solo lectura; no puedes cambiarlo La única forma de cambiarlo es crear una nueva función, que se realiza con el constructor types.FunctionType. Sin embargo, su función __init__ no tiene ningún __class__ freevar, por lo que debemos agregar una. Eso significa que tenemos que crear un nuevo objeto de código también.

El siguiente código hace esto. Agregué una clase base B con fines demostrativos. Este código hace algunas suposiciones, ej. que __init__ aún no tiene una variable gratuita llamada __class__.

Hay otro truco aquí: no parece haber un constructor para el tipo de celda. Para solucionarlo, se crea una función ficticia C.dummy que tiene la variable de celda que necesitamos.

import types 

class B(object): 
    def __init__(self): 
     print("base") 

class C(B): 
    def dummy(self): __class__ 

def __init__(self): 
    print('calling __init__') 
    super().__init__() 

def MakeCodeObjectWithClass(c): 
    """ 
    Return a copy of the code object c, with __class__ added to the end 
    of co_freevars. 
    """ 
    return types.CodeType(c.co_argcount, c.co_kwonlyargcount, c.co_nlocals, 
      c.co_stacksize, c.co_flags, c.co_code, c.co_consts, c.co_names, 
      c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno, 
      c.co_lnotab, c.co_freevars + ('__class__',), c.co_cellvars) 

new_code = MakeCodeObjectWithClass(__init__.__code__) 
old_closure = __init__.__closure__ or() 
C.__init__ = types.FunctionType(new_code, globals(), __init__.__name__, 
    __init__.__defaults__, old_closure + (C.dummy.__closure__[0],)) 

if __name__ == '__main__': 
    c = C() 

Answer 2

Quizás, pero ¿por qué no? En ambos casos, debe de alguna manera ser explícito de qué clase es, porque la forma implícita no funcionó. Tal vez puedas establecer la celda explícitamente de alguna manera, pero no hay ninguna razón para hacer eso. Solo pasa los parámetros de forma explícita.

def __init__(self): 
    print('calling __init__') 
    super(self.__class__, self).__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

(Es mejor si se puede pasar en la clase real directamente, así:

def __init__(self): 
    print('calling __init__') 
    super(C, self).__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

Pero si puede que usted podría poner la __init__ en C directamente, por lo que asumirá puede' t.

Answer 3

puede utilizar el diccionario de la función.

def f(self): 
    super(f.owner_cls, self).f() 
    print("B") 

def add_to_class(cls, member, name=None): 
    if hasattr(member, 'owner_cls'): 
     raise ValueError("%r already added to class %r" % (member, member.owner_cls)) 
    member.owner_cls = cls 
    if name is None: 
     name = member.__name__ 
    setattr(cls, name, member) 

class A: 
    def f(self): 
     print("A") 

class B(A): 
    pass 

add_to_class(B, f) 

B().f() 

Incluso puede agregar otro atributo member_name si no desea codificar el nombre del miembro dentro de la función.