Appel d'une méthode non statique à partir d'une méthode statique en Python

Question

Je ne trouve pas s'il est possible d'appeler une méthode non statique à partir d'une méthode statique en Python.

Merci

EDIT: Ok. Et qu'en est-il de statique de statique? Puis-je faire ceci:

class MyClass(object): 

    @staticmethod 
    def static_method_one(cmd): 
    ... 

    @staticmethod 
    def static_method_two(cmd): 
     static_method_one(cmd) 

Answer 1

Lorsque vous utilisez une méthode statique, vous n'avez pas de self-instance: sur quel objet appelez-vous les méthodes non statiques? Certainement, si vous avez une instance qui traîne, vous pouvez appeler des méthodes dessus.

Answer 2

Ce n'est pas possible sans l'instance de la classe. Vous pouvez ajouter un paramètre à votre méthode f(x, y, ..., me) et utiliser me comme objet pour appeler les méthodes non statiques.

Answer 3

Après les autres réponses et votre question de suivi - en ce qui concerne la méthode statique de méthode statique: Oui, vous pouvez:

>>> class MyClass(object): 
    @staticmethod 
    def static_method_one(x): 
     return MyClass.static_method_two(x) 
    @staticmethod 
    def static_method_two(x): 
     return 2 * x 


>>> MyClass.static_method_one(5) 
10 

Et, au cas où vous êtes curieux, oui aussi pour la méthode de la classe de méthode de classe (facile à tester ce genre de choses dans l'interpréteur - tout cela est coupé et collé de repos au paragraphe 2.5.2) [**EDITED to make correction in usage pointed out by others**]:

>>> class MyClass2(object): 
    @classmethod 
    def class_method_one(cls, x): 
     return cls.class_method_two(x) 
    @classmethod 
    def class_method_two(cls, x): 
     return 2 * x 


>>> MyClass2.class_method_one(5) 
10 

Answer 4

Utiliser des méthodes de classe, non pas des méthodes statiques. Pourquoi autrement le mettre dans une classe?

class MyClass(object): 

    @classmethod 
    def static_method_one(cls, cmd): 
    ... 

    @classmethod 
    def static_method_two(cls, cmd): 
     cls.static_method_one(cmd) 

Answer 5

C'est parfaitement possible, mais pas très significatif. Méditez la classe suivante:

class MyClass: 
    # Normal method: 
    def normal_method(self, data): 
     print "Normal method called with instance %s and data %s" % (self, data) 

    @classmethod 
    def class_method(cls, data): 
     print "Class method called with class %s and data %s" % (cls, data) 

    @staticmethod 
    def static_method(data): 
     print "Static method called with data %s" % (data) 

De toute évidence, nous pouvons appeler cela de la manière attendus:

>>> instance = MyClass() 
>>> instance.normal_method("Success!") 
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success! 

>>> instance.class_method("Success!") 
Class method called with class __main__.MyClass and data Success! 

>>> instance.static_method("Success!") 
Static method called with data Success! 

Mais aussi considérer ceci:

>>> MyClass.normal_method(instance, "Success!") 
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success! 

La syntaxe instance.normal_method() est à peu près juste un "raccourci" pour MyClass.normal_method(instance). C'est pourquoi il y a ce paramètre "self" dans les méthodes, pour passer en soi. Le nom de soi n'est pas magique, vous pouvez l'appeler comme vous voulez.

La même astuce est parfaitement possible avec une méthode statique. Vous pouvez appeler la méthode normale avec une instance comme premier paramètre, comme ceci:

@staticmethod 
    def a_cool_static_method(instance, data): 
     print "Cool method called with instance %s and data %s" % (instance, data) 
     MyClass.normal_method(instance, data) 
     MyClass.class_method(data) 
     MyClass.static_method(data) 

>>> instance.a_cool_static_method(instance, "So Cool!") 
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool! 
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool! 
Class method called with class __main__.MyClass and data So Cool! 
Static method called with data So Cool! 

Donc, la réponse est oui, vous pouvez cal méthodes non statiques de méthodes statiques. Mais seulement si vous pouvez passer dans une instance en tant que premier paramètre. Vous devez donc le générer à partir de la méthode statique (et dans ce cas vous êtes probablement mieux avec une méthode de classe) ou le transmettre. Mais si vous passez dans l'instance, vous pouvez généralement en faire une méthode normale.

Alors vous pouvez, mais c'est plutôt inutile.

Et cela pose alors la question: Pourquoi voulez-vous?