71

我有一个像这样的课程：

class MyClass:
     Foo = 1
     Bar = 2

无论何时调用MyClass.Fooor MyClass.Bar，我都需要在返回值之前调用自定义方法。在 Python 中可能吗？我知道如果我创建一个类的实例并且我可以定义我自己的__getattr__方法是可能的。但是我的场景涉及使用此类而不创建它的任何实例。

我还需要在调用时调用自定义__str__方法str(MyClass.Foo)。Python 是否提供这样的选项？

4

5 回答 5

86

__getattr__()并且__str__()对于一个对象在其类中找到，所以如果你想为一个类定制这些东西，你需要类的类。一个元类。

class FooType(type):
    def _foo_func(cls):
        return 'foo!'

    def _bar_func(cls):
        return 'bar!'

    def __getattr__(cls, key):
        if key == 'Foo':
            return cls._foo_func()
        elif key == 'Bar':
            return cls._bar_func()
        raise AttributeError(key)

    def __str__(cls):
        return 'custom str for %s' % (cls.__name__,)

class MyClass:
    __metaclass__ = FooType

# in python 3:
# class MyClass(metaclass=FooType):
#    pass


print MyClass.Foo
print MyClass.Bar
print str(MyClass)

印刷：

foo!
bar!
custom str for MyClass

不，一个对象不能拦截对其属性之一进行字符串化的请求。为属性返回的对象必须定义自己的__str__()行为。

于 2010-07-01T06:24:20.020 回答
19

（我知道这是一个老问题，但由于所有其他答案都使用元类......）

您可以使用以下简单classproperty描述符：

class classproperty(object):
    """ @classmethod+@property """
    def __init__(self, f):
        self.f = classmethod(f)
    def __get__(self, *a):
        return self.f.__get__(*a)()

像这样使用它：

class MyClass(object):

     @classproperty
     def Foo(cls):
        do_something()
        return 1

     @classproperty
     def Bar(cls):
        do_something_else()
        return 2
于 2014-03-29T09:43:06.280 回答
12

首先，您需要创建一个元类，并__getattr__()对其进行定义。

class MyMetaclass(type):
  def __getattr__(self, name):
    return '%s result' % name

class MyClass(object):
  __metaclass__ = MyMetaclass

print MyClass.Foo

对于第二个，没有。调用str(MyClass.Foo)invokes MyClass.Foo.__str__()，因此您需要为MyClass.Foo.

于 2010-07-01T06:26:07.007 回答
9

很惊讶没有人指出这一点：

class FooType(type):
    @property
    def Foo(cls):
        return "foo!"

    @property
    def Bar(cls):
        return "bar!"

class MyClass(metaclass=FooType):
    pass

作品：

>>> MyClass.Foo
'foo!'
>>> MyClass.Bar
'bar!'

（对于 Python 2.x，将定义更改MyClass为：

class MyClass(object):
    __metaclass__ = FooType

)

其他答案所说的内容str适用于该解决方案：它必须在实际返回的类型上实现。

于 2014-01-28T20:26:09.197 回答
1

根据我使用这种模式的情况

class _TheRealClass:
    def __getattr__(self, attr):
       pass

LooksLikeAClass = _TheRealClass()

然后你导入并使用它。

from foo import LooksLikeAClass
LooksLikeAClass.some_attribute

这避免了使用元类，并处理一些用例。

于 2018-09-21T14:37:00.710 回答