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

Question

Je n'arrive pas à trouver 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 static from static ? Je peux faire ça :

class MyClass(object):

    @staticmethod
    def static_method_one(cmd):
    ...

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

Answer 1

C'est parfaitement possible, mais pas très significatif. Réfléchissez à 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)

Évidemment, nous pouvons appeler cela de la manière attendue :

>>> 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 considérez aussi ceci :

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

La syntaxe instance.normal_method() n'est qu'un "raccourci" pour l'option MyClass.normal_method(instance) . C'est pourquoi il y a ce paramètre "self" dans les méthodes, pour passer dans le self. Le nom self n'est pas magique, vous pouvez l'appeler comme vous voulez.

La même astuce est parfaitement possible à partir d'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!

La réponse est donc oui, vous pouvez caler des méthodes non-statiques à partir de méthodes statiques. Mais seulement si vous pouvez passer une instance comme premier paramètre. Vous devez donc soit la générer à l'intérieur de la méthode statique (et dans ce cas, il est probablement préférable d'utiliser une méthode de classe), soit la transmettre. Mais si vous transmettez l'instance, vous pouvez généralement en faire une méthode normale.

Alors tu peux, mais c'est plutôt inutile.

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

Answer 2

Après les autres réponses et votre question de suivi - concernant la méthode statique de la 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 seriez curieux, également oui pour la méthode de classe à partir de la méthode de classe (facile de tester ce genre de choses dans l'interpréteur - tout ceci est copié-collé de Idle dans 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 3

Utilisez des méthodes de classe, et non des méthodes statiques. Sinon, pourquoi les 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 4

Lorsque dans une méthode statique, vous n'avez pas d'instance de self : sur quel objet appelez-vous les méthodes non statiques ? Il est certain que si vous avez une instance qui traîne, vous pouvez appeler des méthodes sur elle.

Answer 5

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