otra - ¿Cómo puedo crear dinámicamente métodos de clase para una clase en python

metodo init python

Question

Esta pregunta ya tiene una respuesta aquí:

• Agregar un método a una instancia de objeto existente 17 respuestas

Si defino un pequeño programa de Python como

class a():
def _func(self):
return "asdf"
# Not sure what to resplace __init__ with so that a.func will return asdf
def __init__(self, *args, **kwargs):
setattr(self, ''func'', classmethod(self._func))
if __name__ == "__main__":
a.func

Recibo el error de rastreo

Traceback (most recent call last):
File "setattr_static.py", line 9, in <module>
a.func
AttributeError: class a has no attribute ''func''

Lo que estoy tratando de averiguar es, ¿cómo puedo establecer dinámicamente un método de clase para una clase sin instanciar un objeto?

Editar:

La respuesta para este problema es

class a():
pass
def func(cls, some_other_argument):
return some_other_argument
setattr(a, ''func'', classmethod(func))
if __name__ == "__main__":
print(a.func)
print(a.func("asdf"))

devuelve la siguiente salida

<bound method type.func of <class ''__main__.a''>>
asdf

Answer 1

1. La idea básica: utilizar una clase extra para mantener los métodos

Encontré una forma significativa de hacer el trabajo:

Primero, definimos una BaseClass así:

class MethodPatcher:
@classmethod
def patch(cls, target):
for k in cls.__dict__:
obj = getattr(cls, k)
if not k.startswith(''_'') and callable(obj):
setattr(target, k, obj)

Ahora que tenemos una clase original:

class MyClass(object):
def a(self):
print(''a'')

Luego definimos el nuevo método que queremos agregar en una nueva clase Patcher :

(No haga que el nombre del método comience con un _ en este caso)

class MyPatcher(MethodPatcher):
def b(self):
print(''b'')

Luego llame:

MyPatcher.patch(MyClass)

Entonces, encontrará que el nuevo método b(self) se agrega al MyClass original:

obj = MyClass()
obj.a() # which prints an ''a''
obj.b() # which prints a ''b''

2. Haz que la sintaxis sea menos detallada, usamos el decorador de clases

Ahora, si tenemos MethodPatcher decalred, tenemos que hacer dos cosas:

• define una clase infantil ChildClass de ModelPatcher que contiene los métodos adicionales para agregar
• llame a ChildClass.patch(TargetClass)

Así que pronto descubrimos que el segundo paso se puede simplificar mediante el uso de un decorador:

Definimos un decorador:

def patch_methods(model_class):
def do_patch(cls):
cls.patch(model_class)
return do_patch

Y podemos usarlo como:

@patch_methods(MyClass)
class MyClassPatcher(MethodPatcher):
def extra_method_a(self):
print(''a'', self)
@classmethod
def extra_class_method_b(cls):
print(''c'', cls)
# !!ATTENTION!! the effect on declaring staticmethod here may not work as expected:
# calling this method on an instance will take the self into the first argument.
# @staticmethod
# def extra_static_method_c():
# print(''c'')

3. Envolver juntos

Entonces, ahora podemos poner la definición de MethodPatcher y patch_method en un solo módulo:

# method_patcher.py
class MethodPatcher:
@classmethod
def patch(cls, target):
for k in cls.__dict__:
obj = getattr(cls, k)
if not k.startswith(''_'') and callable(obj):
setattr(target, k, obj)
def patch_methods(model_class):
def do_patch(cls):
cls.patch(model_class)
return do_patch

Entonces podemos usarlo libremente:

from method_patcher import ModelPatcher, patch_model

4. Solución final: declaración más simple

Pronto descubrí que la clase MethodPatcher no es necesaria, mientras que el decorador @patch_method puede hacer el trabajo, por lo que solo necesitamos un patch_method :

def patch_methods(model_class):
def do_patch(cls):
for k in cls.__dict__:
obj = getattr(cls, k)
if not k.startswith(''_'') and callable(obj):
setattr(model_class, k, obj)
return do_patch

Y el uso se convierte en:

@patch_methods(MyClass)
class MyClassPatcher:
def extra_method_a(self):
print(''a'', self)
@classmethod
def extra_class_method_b(cls):
print(''c'', cls)
# !!ATTENTION!! the effect on declaring staticmethod here may not work as expected:
# calling this method on an instance will take the self into the first argument.
# @staticmethod
# def extra_static_method_c():
# print(''c'')

Answer 2

Estoy usando Python 2.7.5, y no pude lograr que las soluciones anteriores funcionen para mí. Esto es con lo que terminé:

# define a class object (your class may be more complicated than this...)
class A(object):
pass
def func(self):
print ''I am class {}''.format(self.name)
A.func = func
# using classmethod() here failed with:
# AttributeError: type object ''...'' has no attribute ''name''

Answer 3

Hay un par de problemas aquí:

• __init__ solo se ejecuta cuando creas una instancia, por ejemplo, obj = a() . Esto significa que cuando haces a.func , la llamada a setattr() no ha sucedido
• No puede acceder a los atributos de una clase directamente desde los métodos de esa clase, así que en lugar de usar simplemente _func dentro de __init__ , necesitaría usar self._func o self.__class__._func
• self será una instancia de a , si configuras un atributo en la instancia, solo estará disponible para esa instancia, no para la clase. Entonces, incluso después de llamar a setattr(self, ''func'', self._func) , a.func generará un AttributeError
• El uso de staticmethod la forma en que usted es no hará nada, staticmethod devolverá una función resultante, no modifica el argumento. Entonces, en cambio, querrías algo como setattr(self, ''func'', staticmethod(self._func)) (pero teniendo en cuenta los comentarios anteriores, esto aún no funcionará)

Entonces, ahora la pregunta es, ¿qué estás tratando de hacer? Si realmente desea agregar un atributo a una clase al inicializar una instancia, puede hacer algo como lo siguiente:

class a():
def _func(self):
return "asdf"
def __init__(self, *args, **kwargs):
setattr(self.__class__, ''func'', staticmethod(self._func))
if __name__ == ''__main__'':
obj = a()
a.func
a.func()

Sin embargo, esto todavía es un poco raro. Ahora puede acceder a a.func y llamarlo sin ningún problema, pero el self argumento de a.func siempre será la instancia creada más recientemente de a . Realmente no puedo pensar en ninguna manera _func() convertir un método de instancia como _func() en un método estático o método de clase de la clase.

Ya que intenta agregar dinámicamente una función a la clase, ¿quizás algo como lo siguiente está más cerca de lo que realmente está tratando de hacer?

class a():
pass
def _func():
return "asdf"
a.func = staticmethod(_func) # or setattr(a, ''func'', staticmethod(_func))
if __name__ == ''__main__'':
a.func
a.func()

Answer 4

Necesitas setattr(self, ''func'', staticmethod(self._func))

Necesita inicializar la variable=a() clase variable=a() para llamar a __init__ No hay init en la clase estática

Answer 5

Puede agregar dinámicamente un método de clase a una clase por simple asignación al objeto de clase o por setattr en el objeto de clase. Aquí estoy usando la convención de Python que las clases comienzan con letras mayúsculas para reducir la confusión:

# define a class object (your class may be more complicated than this...)
class A(object):
pass
# a class method takes the class object as its first variable
def func(cls):
print ''I am a class method''
# you can just add it to the class if you already know the name you want to use
A.func = classmethod(func)
# or you can auto-generate the name and set it this way
the_name = ''other_func''
setattr(A, the_name, classmethod(func))

Answer 6

Puedes hacerlo de esta manera

class a():
def _func(self):
return "asdf"
setattr(a, ''func'', staticmethod(a._func))
if __name__ == "__main__":
a.func()