Auto-enregistrer les méthodes de classe en utilisant un décorateur

Je veux être en mesure de créer un python décorateur automatiquement des "registres" les méthodes de la classe dans un référentiel global (avec certaines propriétés).

Exemple de code:

class my_class(object):

    @register(prop1,prop2)
    def my_method( arg1,arg2 ):
       # method code here...

    @register(prop3,prop4)
    def my_other_method( arg1,arg2 ):
       # method code here...

Je veux que quand le chargement est terminé, quelque part, il y aura un dict contenant:

{ "my_class.my_method"       : ( prop1, prop2 )
  "my_class.my_other_method" : ( prop3, prop4 ) }

Est-ce possible?

source d'informationauteur adamk

  1. 15

    Pas avec juste un décorateur, pas. Mais une métaclasse peut automatiquement de travail avec une classe après son été créé. Si votre register décorateur juste fait des notes sur ce que la métaclasse devrait le faire, vous pouvez effectuer les opérations suivantes:

    registry = {}

class RegisteringType(type):
    def __init__(cls, name, bases, attrs):
        for key, val in attrs.iteritems():
            properties = getattr(val, 'register', None)
            if properties is not None:
                registry['%s.%s' % (name, key)] = properties

def register(*args):
    def decorator(f):
        f.register = tuple(args)
        return f
    return decorator

class MyClass(object):
    __metaclass__ = RegisteringType
    @register('prop1','prop2')
    def my_method( arg1,arg2 ):
        pass

    @register('prop3','prop4')
    def my_other_method( arg1,arg2 ):
        pass

print registry

    impression

    {'MyClass.my_other_method': ('prop3', 'prop4'), 'MyClass.my_method': ('prop1', 'prop2')}
  2. 12

    Voici un peu d'amour pour la classe des décorateurs. Je pense que la syntaxe est légèrement plus simple que pour les metaclasses.

    def class_register(cls):
    cls._propdict = {}
    for methodname in dir(cls):
        method = getattr(cls, methodname)
        if hasattr(method, '_prop'):
            cls._propdict.update(
                {cls.__name__ + '.' + methodname: method._prop})
    return cls


def register(*args):
    def wrapper(func):
        func._prop = args
        return func
    return wrapper


@class_register
class MyClass(object):

    @register('prop1', 'prop2')
    def my_method(self, arg1, arg2):
        pass

    @register('prop3', 'prop4')
    def my_other_method(self, arg1, arg2):
        pass

myclass = MyClass()
print(myclass._propdict)
# {'MyClass.my_other_method': ('prop3', 'prop4'), 'MyClass.my_method': ('prop1', 'prop2')}
  3. 5

    Si vous avez besoin d'classes nom, l'utilisation de Matt solution. Toutefois, si vous êtes ok avec le fait d'avoir ces méthodes nom ou une référence à la méthode -- dans le registre, cela pourrait être un moyen plus simple de le faire:

    class Registry:
    r = {}

    @classmethod
    def register(cls, *args):
        def decorator(fn):
            cls.r[fn.__name__] = args
            return fn
        return decorator

class MyClass(object):

    @Registry.register("prop1","prop2")
    def my_method( arg1,arg2 ):
        pass

    @Registry.register("prop3","prop4")
    def my_other_method( arg1,arg2 ):
        pass

print Registry.r

    impression 

    {'my_other_method': ('prop3', 'prop4'), 'my_method': ('prop1', 'prop2')}
  4. 2

    Pas aussi beau ou élégant, mais sans doute la façon la plus simple si vous avez uniquement besoin de ce dans une seule classe:

    _registry = {}
class MyClass(object):
    def register(*prop):
        def decorator(meth):
            _registry[MyClass.__name__ + '.' + meth.__name__] = prop
        return decorator

    @register('prop1', 'prop2')
    def my_method(self, arg1, arg2):
        pass
    @register('prop3', 'prop4')
    def my_other_method(self, arg1, arg2):
        pass

    del register
  5. 2

    Pas facile, mais si vous utilisez Python 3, cela devrait fonctionner:

    registry = {}
class MetaRegistry(type):
    @classmethod
    def __prepare__(mcl, name, bases):
        def register(*props):
            def deco(f):
                registry[name + "." + f.__name__] = props
                return f
            return deco
        d = dict()
        d['register'] = register
        return d
    def __new__(mcl, name, bases, dct):
        del dct['register']
        cls = super().__new__(mcl, name, bases, dct)
        return cls

class my_class(object, metaclass=MetaRegistry):
    @register('prop1','prop2')
    def my_method( arg1,arg2 ):
       pass # method code here...

    @register('prop3','prop4')
    def my_other_method( arg1,arg2 ):
       pass # method code here...

print(registry)

    Notez que vous ne pouvez pas avoir de la méthode de noms égal au décorateur nom dans la méta-tapé classe, parce qu'ils sont automatiquement supprimés par le del commande dans la métaclasse est __new__ méthode.

    Pour la version 2.6 de Python, je pense que vous devez indiquer explicitement le décorateur le nom de la classe à utiliser.

  6. 1

    Pas. Le décorateur reçoit la fonction avant il est devenu une méthode, donc vous ne savez pas dans quelle classe il est.