rendre une classe appelable dans la même instance

class Foo(object):
    def tick(self):
        print("something")

class Bar(object):
    def __init__(self):
        self.foo = Foo()

    def tick(self):
        #Here's what I do....
        self.foo.tick()

        #here's what my goal would be
        self.foo()

b = Bar()
b.tick()

C'est essentiellement mon objectif. De ce que j'ai recueillis, je pouvais changer la tique fonction de __call__ et qui me permettrait de faire ce que je voulais. Un couple d'autres réponses a dit que cela ferait une nouvelle instance de l'objet, cela signifie qu'il aura recours à l'auto.foo mémoire? ou serait-il un tout nouvel objet nouvellement instancié? ou de faire une copie de soi-même.foo?

Aussi quelques inconvénients à ce qui peut ou peut ne pas se manifester eux-mêmes viennent à l'esprit. Pour un particulier le cadre de mon programme, je vérifie pour voir si l'objet a un __call__ pour déterminer si l'argument je suis de passage est une fonction ou une variable, et je ne pense pas vraiment que j'ai envie de permettre que, pour être appelé (même si, je suppose que la classe techniquement serait une fonction à ce point.) Est-il possible de distinguer entre une fonction et une rachetables de classe?

Est-il autre chose qui ferait de faire ce souhaitable (et est-il un pythonic façon de travailler?)? Ma prochaine pensée a été que, étant donné que d'autres variables préfixées avec __ ne peut pas être utilisé en dehors de leur classe, mais qui ne semble pas être le cas ici.

La mise en œuvre de __call__ serait pas créer de nouvelles instances de l'objet. Faire TheClass() crée une nouvelle instance mais some_instance() appelle simplement __call__.
Je suis le seul fait de mentionner cela dans le cas où vous n'avez pas pensé à elle -- Mais, avec le très simple code que vous avez ci-dessus, faisant Bar hériter de Foo semble être un bon choix -- bien sûr votre cas d'utilisation peuvent faire qu'il est pas un bon pari ...

OriginalL'auteur DanielCardin | 2013-01-29

  1. 21

    Changer tick(self) à __call__(self) est la bonne solution.

    Cela n'a rien à voir avec l'allocation de la mémoire. Tous les __call__ signifie est une fonction Python appels lorsque vous utilisez (pour un objet foo), la syntaxe foo().

    Pour votre dernière question: pour vérifier si quelque chose est un objet, utilisez isinstance ou issubclass (éventuellement avec l' object classe). Et dans mon esprit cette réponse est mieux que la accepté un pour le "Comment puis-je déterminer si quelque chose est une fonction?", vous avez probablement vu.

    OriginalL'auteur Borealid

  2. 13

    Pour faire une instance de la classe appelable, tout ce que vous devez faire est de mettre en œuvre un __call__ méthode. Puis, à l'appel de la __call__ méthode, vous venez de le faire: instance(arg1,arg2,...) -- en d'autres termes, vous faites appel à l'instance de la même manière que vous le feriez appel d'une fonction.

    Notez que vous pouvez alias __call__ avec une autre méthode définie dans la classe si vous le souhaitez:

    >>> class Foo(object):
...     def tick(self):
...         print ("something")
...     __call__ = tick
... 
>>> a = Foo()
>>> a()
something
>>> a.tick()
something
    si vous avez été de mettre en œuvre une fonction qui prend en arguments, pouvez-vous encore utiliser ce aliasing méthode? ou faut-il ne fonctionne que lorsque la fonction n'a qu'un seul argument self
    Il doit encore travailler.
    J'essaie de faire en sorte que les différentes instances ont différentes appel méthodes. Cependant, si j'ai mis en auto.__appelez__ à l'intérieur de init__(), lorsque j'ai fait appel en instance(), j'obtiens TypeError: 'CallableClass' objet n'est pas appelable. Est-il un moyen de définir __call différemment instance-à-exemple?
    Vous pouvez avoir un _delegate propriété qui __call__ de déléguer à: def __call__(self): self._delegate()

    OriginalL'auteur mgilson