__getattr__ para variables estáticas/de clase en python

class-method

Question

Tengo una clase como:

class MyClass:
     Foo = 1
     Bar = 2

Siempre que se invoca MyClass.Foo o MyClass.Bar , necesito que se invoque un método personalizado antes de que se devuelva el valor. ¿Es posible en Python? Sé que es posible si creo una instancia de la clase y puedo definir mi propio método __getattr__ . Pero mi scnenario implica usar esta clase como tal sin crear ninguna instancia de ella.

También necesito que se invoque un método __str__ personalizado cuando se invoca str(MyClass.Foo) . ¿Python proporciona tal opción?

Answer 1

(Sé que esta es una pregunta antigua, pero como todas las demás respuestas usan una metaclase ...)

Puede usar el siguiente descriptor de classproperty simple:

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

Utilízalo como:

class MyClass(object):

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

     @classproperty
     def Bar(cls):
        do_something_else()
        return 2

Answer 2

Dependiendo del caso utilizo este patrón.

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

LooksLikeAClass = _TheRealClass()

Luego lo importas y lo usas.

from foo import LooksLikeAClass
LooksLikeAClass.some_attribute

Esto evita el uso de metaclase, y maneja algunos casos de uso.

Answer 3

Nadie sorprendido señaló este:

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

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

class MyClass(metaclass=FooType):
    pass

Trabajos:

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

(para Python 2.x, cambie la definición de MyClass a:

class MyClass(object):
    __metaclass__ = FooType

)

Lo que dicen las otras respuestas sobre str es cierto para esta solución: debe implementarse en el tipo que se devuelve.

Answer 4

Para el primero, deberá crear una metaclase y definir __getattr__() en eso.

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

class MyClass(object):
  __metaclass__ = MyMetaclass

print MyClass.Foo

Para el segundo, no. Al llamar a str(MyClass.Foo) invoca MyClass.Foo.__str__() , por lo que deberá devolver un tipo apropiado para MyClass.Foo .

Answer 5

__getattr__() y __str__() para un objeto se encuentran en su clase, por lo que si desea personalizar esas cosas para una clase, necesita la clase de una clase. Una metaclase.

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)

impresión:

foo!
bar!
custom str for MyClass

Y no, un objeto no puede interceptar una solicitud para una cadena de uno de sus atributos. El objeto devuelto para el atributo debe definir su propio __str__() .