Come decorare una classe?

In Python 2.5, c'è un modo per creare un decoratore che decora una classe? In particolare, desidero utilizzare un decoratore per aggiungere un membro a una classe e modificare il costruttore per ottenere un valore per quel membro.

Cerchi qualcosa di simile al seguente (che presenta un errore di sintassi su 'class 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()

Immagino che quello che sto veramente cercando sia un modo per fare qualcosa come un'interfaccia C # in Python. Devo cambiare il mio paradigma suppongo.

Vorrei secondare l'idea che potresti voler considerare una sottoclasse invece dell'approccio che hai delineato. Tuttavia, non conoscendo il tuo scenario specifico, YMMV :-)

Quello a cui stai pensando è una metaclasse. Alla __new__funzione in una metaclasse viene passata la definizione proposta completa della classe, che può quindi riscrivere prima della creazione della classe. È possibile, in quel momento, sostituire il costruttore per uno nuovo.

Esempio:

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

Sostituire il costruttore è forse un po 'drammatico, ma il linguaggio fornisce supporto per questo tipo di profonda introspezione e modifica dinamica.

A parte la domanda se i decoratori di classe siano la giusta soluzione al tuo problema:

In Python 2.6 e versioni successive, ci sono decoratori di classe con @ -syntax, quindi puoi scrivere:

@addID
class Foo:
    pass

Nelle versioni precedenti, puoi farlo in un altro modo:

class Foo:
    pass

Foo = addID(Foo)

Si noti tuttavia che questo funziona come per i decoratori di funzioni e che il decoratore dovrebbe restituire la nuova classe (o originale modificato), che non è ciò che si sta facendo nell'esempio. Il decoratore addID sarebbe simile al seguente:

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

È quindi possibile utilizzare la sintassi appropriata per la versione di Python come descritto sopra.

Ma sono d'accordo con gli altri sul fatto che l'ereditarietà sia più adatta se si desidera scavalcare __init__.

Nessuno ha spiegato che puoi definire dinamicamente le classi. Quindi puoi avere un decoratore che definisce (e restituisce) una sottoclasse:

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

Che può essere usato in Python 2 (il commento di Blckknght che spiega perché dovresti continuare a farlo in 2.6+) in questo modo:

class Foo:
    pass

FooId = addId(Foo)

E in Python 3 in questo modo (ma fai attenzione a usare super()nelle tue classi):

@addId
class Foo:
    pass

Quindi puoi avere la tua torta e mangiarla - eredità e decoratori!

Questa non è una buona pratica e non esiste alcun meccanismo per farlo a causa di ciò. Il modo giusto per ottenere ciò che vuoi è l'eredità.

Dai un'occhiata alla documentazione della lezione .

Un piccolo esempio:

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)

In questo modo Boss ha tutto ciò che Employeeha, con il suo __init__metodo e i suoi membri.

Concordo che l'eredità si adatta meglio al problema posto.

Ho trovato questa domanda molto utile anche se sui corsi di decorazione, grazie a tutti.

Ecco un altro paio di esempi, basati su altre risposte, incluso il modo in cui l'ereditarietà influisce sulle cose in Python 2.7, (e @wraps , che mantiene il dotstring della funzione originale, ecc.):

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...

Spesso vuoi aggiungere parametri al tuo decoratore:

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

Uscite:

@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

Ho usato un decoratore di funzioni, poiché li trovo più concisi. Ecco una lezione per decorare una lezione:

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

Una versione più robusta che controlla quelle parentesi e funziona se i metodi non esistono sulla classe decorata:

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

I assertcontrolli che il decoratore non è stata usata senza parentesi. In tal caso, la classe che viene decorata viene passata al msgparametro del decoratore, che genera un AssertionError.

@decorate_ifapplica solo decoratorse conditionvaluta a True.

I getattr, callabletest, e @decorate_ifvengono utilizzati in modo che il decoratore non si rompa se il foo()metodo non esiste sulla classe che viene decorata.

In realtà c'è un'implementazione abbastanza buona di un decoratore di classe qui:

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

In realtà penso che questa sia un'implementazione piuttosto interessante. Poiché subclasse la classe che decora, si comporterà esattamente come questa classe in cose come i isinstancecontrolli.

Ha un ulteriore vantaggio: non è insolito che l' __init__istruzione in un modulo django personalizzato apporti modifiche o aggiunte, self.fieldsquindi è meglio che le modifiche self.fieldsavvengano dopo che tutto __init__è stato eseguito per la classe in questione.

Molto intelligente.

Tuttavia, nella tua classe vuoi davvero che la decorazione cambi il costruttore, che non credo sia un buon caso per un decoratore di classe.

Ecco un esempio che risponde alla domanda di restituzione dei parametri di una classe. Inoltre, rispetta ancora la catena dell'ereditarietà, ovvero vengono restituiti solo i parametri della classe stessa. La funzione get_paramsviene aggiunta come semplice esempio, ma è possibile aggiungere altre funzionalità grazie al modulo inspect.

import inspect 

class Parent:
    @classmethod
    def get_params(my_class):
        return list(inspect.signature(my_class).parameters.keys())

class OtherParent:
    def __init__(self, a, b, c):
        pass

class Child(Parent, OtherParent):
    def __init__(self, x, y, z):
        pass

print(Child.get_params())
>>['x', 'y', 'z']

Django ha method_decoratorun decoratore che trasforma qualsiasi decoratore in un decoratore di metodi, puoi vedere come è implementato in django.utils.decorators:

https://github.com/django/django/blob/50cf183d219face91822c75fa0a15fe2fe3cb32d/django/utils/decorators.py#L53

https://docs.djangoproject.com/en/3.0/topics/class-based-views/intro/#decorating-the-class