Écrire une classe qui accepte un rappel en Python?

J'ai besoin d'écrire une classe qui permet à une sous-classe pour définir un attribut avec le nom d'une fonction. Cette fonction doit alors être appelées à partir d'instances de la classe.

Par exemple, je dis que j'ai besoin d'écrire un Fruit de la classe où la sous-classe peut transmettre un message de bienvenue. Le Fruit de la classe doit exposer un attribut print_callback qui peut être réglé.

class Fruit(object):
    print_callback = None

    def __init__(self, *args, **kwargs):
        super(Fruit, self).__init__(*args, **kwargs)
        self.print_callback("Message from Fruit: ")

J'ai besoin d'exposer une API qui peut être consommé par ce code (pour être clair, ce code ne peut pas changer, dire que c'est la 3ème partie du code):

def apple_print(f):
    print "%sI am an Apple!" % f

class Apple(Fruit):
    print_callback = apple_print

Si je lance:

mac = Apple()

Je veux obtenir:

Message de Fruit: je suis une Pomme!

Au lieu de cela j'obtiens:

TypeError: apple_print() prend exactement 1 argument (2)

Je pense que c'est parce que le moi est passé comme premier argument.

Alors, comment dois-je écrire le Fruit de la classe? Merci!

J'apprécie les problèmes que vous avez eu avec cette approche et les excellentes solutions ci-dessous. Cependant cela me semble que vous devriez être la définition de print_callback comme une méthode (peut-être juste appelé print_me, et d'obtenir des sous-classes pour le remplacer. Ce serait simple et pythonic. Pour chaque type différent de print_me méthode, une autre sous-classe.
Ma motivation pour poser la question que je voulais sous-classe de Google App Engine de google.appengine.ext.db.djangoforms (par exemple DF2) pour permettre de remplacer un attribut formfield_callback de la même manière que Django ModelForm (django.les formulaires.ModelForm). L'idée est que "la classe f(DF2)" pourrait ensuite être utilisé par les standards de Django, simplement en changeant la super-classe de django.les formulaires.ModelForm. Je ne sais pas pourquoi le Django auteurs ont défini formfield_callback comme un attribut.

InformationsquelleAutor Charles Dietrich | 2009-10-14

callback python

8

Python suppose que toutes les fonctions liées à l'intérieur d'une étendue de classe sont des méthodes. Si vous souhaitez les traiter comme des fonctions, vous avez à creuser autour de leurs attributs à récupérer la fonction d'origine de l'objet:
```
def __init__(self, *args, **kwargs):
    super(Fruit, self).__init__(*args, **kwargs)

    # The attribute name was changed in Python 3; pick whichever line matches
    # your Python version.
    callback = self.print_callback.im_func  # Python 2
    callback = self.print_callback.__func__ # Python 3

    callback("Message from Fruit: ")
```
- Ou, mieux encore, il suffit d'ajouter un self argument de la fonction de sorte qu'il peut agir comme une méthode normale.
- Selon la question, le rappel de la définition ne peut pas être modifié.
- BTW, il faut également noter que la im_func attribut de méthodes ai renommé __func__ en Python 3.x.
InformationsquelleAutor John Millikin
3

Vous pouvez utiliser directement:
```
class Apple(Fruit):
    print_callback = staticmethod(apple_print)
```
ou:
```
class Apple(Fruit):
    print_callback = classmethod(apple_print)
```
Dans le premier cas, vous obtiendrez un seul paramètre (la version originale). Dans la deuxième, vous allez recevoir deux paramètres, où le premier sera la classe sur laquelle il a été appelé.

Espère que cette aide, et est plus court et moins complexe.
- "pour être clair, ce code ne peut pas changer, dire que c'est la 3ème partie du code"
InformationsquelleAutor user190071

Mis à jour: l'intégration de abourget la suggestion de à utiliser staticmethod:

Essayez ceci:

def __init__(self, *args, **kwargs):
    super(Fruit, self).__init__(*args, **kwargs)

    # Wrap function back into a proper static method
    self.print_callback = staticmethod(self.print_callback)

    # And now you can do:
    self.print_callback("Message from Fruit: ")

InformationsquelleAutor Daniel Pryden

Je cherchais quelque chose de plus de ce genre quand j'ai trouvé cette question:

class Something:
    def my_callback(self, arg_a):
        print arg_a

class SomethingElse:
    def __init__(self, callback):
        self.callback = callback

something = Something()
something_else = SomethingElse(something.my_callback)
something_else.callback("It works...")

InformationsquelleAutor RobotHumans

Il y a aussi un peu dirtyer solution avec les metaclasses:

def apple_print(f):
    print "Apple " + f

class FruitMeta(type):
    def __new__(cls, name, bases, dct):
        func = dct["print_callback"]
        dct["print_callback"]=lambda x,f,func=func: func(f)
        return type.__new__(cls,name,bases,dct)

class Fruit(object):
    __metaclass__ = FruitMeta
    print_callback = None
    def __init__(self):
        super(Fruit,self).__init__()
        self.print_callback("Msg ")

class Apple(Fruit):
    print_callback = apple_print

mac = Apple()here

Elle manipule la classe avant sa création!

InformationsquelleAutor pygabriel

Vous devez vous connecter pour publier un commentaire.