Декоратор класса Python

Question

В Python 2.5 есть ли способ создать декоратор, который украшает класс? В частности, я хочу использовать декоратор для добавления члена в класс и изменения конструктора, чтобы принять значение для этого элемента.

Ищете что-то вроде следующего (который имеет синтаксическую ошибку 'класса Foo:':

def getId(self): return self.__id 

class addID(original_class): 
    def __init__(self, id, *args, **kws): 
     self.__id = id 
     self.getId = getId 
     original_class.__init__(self, *args, **kws) 

@addID 
class Foo: 
    def __init__(self, value1): 
     self.value1 = value1 

if __name__ == '__main__': 
    foo1 = Foo(5,1) 
    print foo1.value1, foo1.getId() 
    foo2 = Foo(15,2) 
    print foo2.value1, foo2.getId() 

Спасибо, Роб

Edit: Перечитывая этот вопрос, я думаю, что Я действительно хочу сделать что-то вроде интерфейса C# в Python. Мне нужно переключить мою парадигму, я полагаю.

Answer 1

Я бы предпочел, чтобы вы могли рассмотреть подкласс вместо подхода, который вы наметили. Однако, не зная вашего конкретного сценария, YMMV :-)

Что вы думаете о метаклассе. Функция __new__ в метаклассе передает полное предложенное определение класса, которое затем может быть переписано до создания класса. Вы можете в это время добавить конструктор для нового.

Пример:

def substitute_init(self, id, *args, **kwargs): 
    pass 

class FooMeta(type): 

    def __new__(cls, name, bases, attrs): 
     attrs['__init__'] = substitute_init 
     return super(FooMeta, cls).__new__(cls, name, bases, attrs) 

class Foo(object): 

    __metaclass__ = FooMeta 

    def __init__(self, value1): 
     pass 

Замена конструктора, возможно, немного драматично, но язык не предусматривает поддержку для такого рода глубокого самоанализа и динамической модификации.

Answer 2

Это нехорошая практика, и нет никакой механики из-за этого. Правильный способ выполнить то, что вы хотите, - это наследование.

Взгляните на class documentation.

Небольшой пример:

class Employee(object): 

    def __init__(self, age, sex, siblings=0): 
     self.age = age 
     self.sex = sex  
     self.siblings = siblings 

    def born_on(self):  
     today = datetime.date.today() 

     return today - datetime.timedelta(days=self.age*365) 


class Boss(Employee):  
    def __init__(self, age, sex, siblings=0, bonus=0): 
     self.bonus = bonus 
     Employee.__init__(self, age, sex, siblings) 

Таким образом Boss имеет все Employee имеет, с также своими __init__ метод и собственных членов.

Answer 3

Помимо вопроса класса декораторов, являются ли правильное решение вашей проблемы:

в Python 2.6 и выше, есть класс декораторов с @ -syntax, так что вы можете написать:

@addID 
class Foo: 
    pass 

в более ранних версиях, вы можете сделать это по-другому:

class Foo: 
    pass 

Foo = addID(Foo) 

Заметим, однако, что это работает так же, как для функции декораторы, и что декоратор должен RETU rn нового (или измененного оригинала) класса, который не является тем, что вы делаете в примере. ADDID декоратор будет выглядеть следующим образом:

def addID(original_class): 
    orig_init = original_class.__init__ 
    # make copy of original __init__, so we can call it without recursion 

    def __init__(self, id, *args, **kws): 
     self.__id = id 
     self.getId = getId 
     orig_init(self, *args, **kws) # call the original __init__ 

    original_class.__init__ = __init__ # set the class' __init__ to the new one 
    return original_class 

Вы можете затем использовать соответствующий синтаксис для питона версии, как описано выше.

Но я согласен с другими, что наследование лучше подходит, если вы хотите переопределить __init__.

Answer 4

Там на самом деле очень хорошая реализация класса декоратора здесь:

https://github.com/agiliq/Django-parsley/blob/master/parsley/decorators.py

Я на самом деле думаю, что это довольно интересная реализация. Поскольку он подклассифицирует класс, который он украшает, он будет вести себя точно так же, как этот класс, в таких вещах, как isinstance.

Он имеет дополнительное преимущество: это не редкость для __init__ заявления в пользовательских Джанго форме вносить изменения или дополнения в self.fields так что лучше для изменений в self.fields, чтобы случиться после все из __init__ поработает класс в вопрос.

Очень умный.

Тем не менее, в вашем классе вы действительно хотите, чтобы украшение изменяло конструктор, который, как я считаю, не является хорошим вариантом для декоратора класса.

Answer 5

Никто не объяснил, что вы можете динамически определять классы. так что вы можете иметь декоратора, который определяет (и возвращает) подкласс:

def addId(cls): 

    class AddId(cls): 

     def __init__(self, id, *args, **kargs): 
      super(AddId, self).__init__(*args, **kargs) 
      self.__id = id 

     def getId(self): 
      return self.__id 

    return AddId 

, который может быть использован в питоне 2 (комментарий от Blckknght, который объясняет, почему вы должны продолжать делать это в 2.6+), как это:

class Foo: 
    pass 

FooId = addId(Foo) 

и в Python 3, как это (но будьте осторожны, чтобы использовать super() в классах):

@addId 
class Foo: 
    pass 

так что вы можете иметь свой кусок пирога в nd eat it - наследование и декораторы!

Answer 6

Я бы согласился, что наследование лучше подходит для поставленной проблемы.

Я нашел этот вопрос действительно удобным, хотя и украшал классы, спасибо всем. Вот еще несколько примеров, на основе других ответов, в том числе, как наследование влияет на вещи в Python 2.7, (и @wraps, который поддерживает строку документации исходной функции, и т.д):

def dec(klass): 
    old_foo = klass.foo 
    @wraps(klass.foo) 
    def decorated_foo(self, *args ,**kwargs): 
     print('@decorator pre %s' % msg) 
     old_foo(self, *args, **kwargs) 
     print('@decorator post %s' % msg) 
    klass.foo = decorated_foo 
    return klass 

@dec # no parentheses 
class Foo... 

Часто вы хотите добавить параметры вашего декоратора:

from functools import wraps 

def dec(msg='default'): 
    def decorator(klass): 
     old_foo = klass.foo 
     @wraps(klass.foo) 
     def decorated_foo(self, *args ,**kwargs): 
      print('@decorator pre %s' % msg) 
      old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 
     klass.foo = decorated_foo 
     return klass 
    return decorator 

@dec('foo decorator') # you must add parentheses now, even if they're empty 
class Foo(object): 
    def foo(self, *args, **kwargs): 
     print('foo.foo()') 

@dec('subfoo decorator') 
class SubFoo(Foo): 
    def foo(self, *args, **kwargs): 
     print('subfoo.foo() pre') 
     super(SubFoo, self).foo(*args, **kwargs) 
     print('subfoo.foo() post') 

@dec('subsubfoo decorator') 
class SubSubFoo(SubFoo): 
    def foo(self, *args, **kwargs): 
     print('subsubfoo.foo() pre') 
     super(SubSubFoo, self).foo(*args, **kwargs) 
     print('subsubfoo.foo() post') 

SubSubFoo().foo() 

Выходы:

@decorator pre subsubfoo decorator 
subsubfoo.foo() pre 
@decorator pre subfoo decorator 
subfoo.foo() pre 
@decorator pre foo decorator 
foo.foo() 
@decorator post foo decorator 
subfoo.foo() post 
@decorator post subfoo decorator 
subsubfoo.foo() post 
@decorator post subsubfoo decorator 

Я использовал функцию декоратора, как я нахожу их более кратким. Вот класс для украшения класса:

class Dec(object): 

    def __init__(self, msg): 
     self.msg = msg 

    def __call__(self, klass): 
     old_foo = klass.foo 
     msg = self.msg 
     def decorated_foo(self, *args, **kwargs): 
      print('@decorator pre %s' % msg) 
      old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 
     klass.foo = decorated_foo 
     return klass 

Более надежная версия, которая проверяет эти скобки, и работает, если методы не существуют на украшенном классе:

from inspect import isclass 

def decorate_if(condition, decorator): 
    return decorator if condition else lambda x: x 

def dec(msg): 
    # Only use if your decorator's first parameter is never a class 
    assert not isclass(msg) 

    def decorator(klass): 
     old_foo = getattr(klass, 'foo', None) 

     @decorate_if(old_foo, wraps(klass.foo)) 
     def decorated_foo(self, *args ,**kwargs): 
      print('@decorator pre %s' % msg) 
      if callable(old_foo): 
       old_foo(self, *args, **kwargs) 
      print('@decorator post %s' % msg) 

     klass.foo = decorated_foo 
     return klass 

    return decorator 

The assert проверки, декоратор не использовался без круглых скобок.Если это так, то класс, который оформляется, передается в параметр msg декоратора, который поднимает AssertionError.

@decorate_if применяется только к decorator, если condition - True.

getattr, callable тест, и @decorate_if используются так, что декоратор не ломается, если метод foo() не существует на класс украшаются.