73

如果我将一个小 Python 程序定义为

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

我收到回溯错误

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

我想弄清楚的是，如何在不实例化对象的情况下动态地将类方法设置为类？

编辑：

这个问题的答案是

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"))

返回以下输出

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

6 回答 6

78

您可以通过对类对象的简单赋值或通过在类对象上设置属性来动态地将类方法添加到类中。在这里，我使用类以大写字母开头的 python 约定以减少混淆：

# 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))
于 2013-07-29T17:21:46.560 回答
9

这里有几个问题：

  • __init__仅在您创建实例时运行，例如obj = a(). 这意味着当你这样做时a.func，setattr()呼叫还没有发生
  • _func您不能直接从该类的方法中访问该类的属性，因此__init__您需要使用self._func或self.__class__._func
  • self将是 的实例a，如果您在实例上设置属性，它将仅适用于该实例，而不适用于类。所以即使在调用之后setattr(self, 'func', self._func)，a.func也会引发 AttributeError
  • 使用staticmethod你的方式不会做任何事情，staticmethod将返回一个结果函数，它不会修改参数。所以你会想要类似的东西setattr(self, 'func', staticmethod(self._func))（但考虑到上面的评论，这仍然行不通）

所以现在的问题是，你到底想做什么？如果您真的想在初始化实例时向类添加属性，您可以执行以下操作：

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()

但是，这仍然有点奇怪。现在您可以a.func毫无问题地访问和调用它，但 to 的self参数a.func将始终是最近创建的a. 我真的想不出任何理智的方法来将实例方法_func()转换为类的静态方法或类方法。

由于您正在尝试向类动态添加函数，因此可能类似于以下内容更接近您实际尝试做的事情？

class a():
    pass

def _func():
    return "asdf"

a.func = staticmethod(_func)  # or setattr(a, 'func', staticmethod(_func))

if __name__ == '__main__':
    a.func
    a.func()
于 2013-07-29T16:57:36.463 回答
2

你需要setattr(self, 'func', staticmethod(self._func))

您需要初始化类variable=a()才能调用__init__ 静态类中没有init

于 2013-07-29T16:46:47.333 回答
2

你可以这样做

class a():
    def _func(self):
        return "asdf"

setattr(a, 'func', staticmethod(a._func))

if __name__ == "__main__":
    a.func()
于 2013-07-29T16:56:36.643 回答
2

1.基本思想：使用额外的类来保存方法

我找到了一种有意义的工作方式：

首先，我们定义这样一个BaseClass：

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)

现在我们有了一个原始类：

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

然后我们定义要在新Patcher类上添加的新方法：

_（在这种情况下，不要让方法名称以 an 开头）

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

然后调用：

MyPatcher.patch(MyClass)

因此，您会发现新方法b(self)已添加到原始方法中MyClass：

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

2. 让语法不那么冗长，我们使用类装饰器

现在，如果我们有MethodPatcher贴花，我们需要做两件事：

  • 定义一个子类ChildClass，ModelPatcher其中包含要添加的额外方法
  • 称呼ChildClass.patch(TargetClass)

所以我们很快发现第二步可以通过使用装饰器来简化：

我们定义一个装饰器：

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

我们可以像这样使用它：

@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. 包在一起

因此，我们现在可以将MethodPatcherand的定义patch_method放入单个模块中：

# 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

所以我们可以自由使用它：

from method_patcher import ModelPatcher, patch_model

4.最终解决方案：更简单的声明

很快我发现MethodPatcher类不是必需的，而@patch_method装饰器可以完成工作，所以最后我们只需要一个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

用法变为：

@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')
于 2017-07-13T14:27:19.710 回答
1

我正在使用 Python 2.7.5，但无法让上述解决方案为我工作。这就是我最终的结果：

# 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'
于 2017-11-17T00:45:12.587 回答