Quand dois-je utiliser @classmethod et quand def méthode(auto)?

Tout en intégrant un Django app je n'ai pas utilisé avant, j'ai trouvé deux façons différentes utilisées pour définir les fonctions dans les classes. L'auteur semble utiliser à la fois très intentionnellement. Le premier est celui que j'utilise moi-même beaucoup:

class Dummy(object):

    def some_function(self,*args,**kwargs):
        do something here
        self is the class instance

L'autre est un je n'ai pas l'utilisation, principalement parce que je ne comprends pas quand l'utiliser, et ce pour:

class Dummy(object):

    @classmethod
    def some_function(cls,*args,**kwargs):
        do something here
        cls refers to what?

Dans le Python docs le classmethod décorateur est expliqué avec cette phrase:

Une méthode de la classe reçoit la classe implicite premier argument, juste
comme une méthode d'instance reçoit l'instance.

Donc je suppose que cls se réfère à Dummy lui-même (le class, pas l'instance). Je n'ai pas de comprendre exactement pourquoi cela existe, car j'ai toujours pu le faire:

type(self).do_something_with_the_class

Est-ce juste par souci de clarté, ou ai-je raté la partie la plus importante: effrayant et fascinant des choses qui n'a pas pu être fait sans elle?

InformationsquelleAutor marue | 2012-05-14

61

Votre supposition est correcte - vous comprendre comment classmethods de travail.

La raison est que ces méthodes peuvent être appelées à la fois sur une instance OU sur la classe (dans les deux cas, l'objet de classe sera passé comme premier argument):
```
class Dummy(object):

    @classmethod
    def some_function(cls,*args,**kwargs):
        print cls

#both of these will have exactly the same effect
Dummy.some_function()
Dummy().some_function()
```
Sur l'utilisation de ces instances: Il y a au moins deux utilisations principales pour l'appel d'une classmethod sur un exemple:
1. self.some_function() va appeler la version de some_function sur le type réel de self, plutôt que de la classe dans laquelle cet appel arrive à apparaître (et n'aurez pas besoin de l'attention si la classe est renommé); et
2. Dans les cas où some_function est nécessaire de mettre en œuvre un protocole, mais il est utile de faire appel à l'objet de classe seul.
La différence avec staticmethod: Il y a une autre manière de définir des méthodes qui n'ont pas accès à des données de l'instance, appelé staticmethod. Qui crée une méthode qui ne bénéficie pas d'un implicite premier argument; en conséquence, il ne sera pas adopté toutes les informations au sujet de l'instance ou de classe sur laquelle il a été appelé.
```
In [6]: class Foo(object): some_static = staticmethod(lambda x: x+1)

In [7]: Foo.some_static(1)
Out[7]: 2

In [8]: Foo().some_static(1)
Out[8]: 2

In [9]: class Bar(Foo): some_static = staticmethod(lambda x: x*2)

In [10]: Bar.some_static(1)
Out[10]: 2

In [11]: Bar().some_static(1)
Out[11]: 2
```
L'utilisation principale que j'ai trouvé pour elle est de s'adapter à une fonction existante (ce qui ne veut pas s'attendre à recevoir un self) à une méthode d'une classe (ou un objet).
- Joli: j'aime la réponse étant divisé en comment - pourquoi. Aussi loin que je le suis maintenant @classmethod permet d'accéder à la fonction sans la nécessité d'une instance. C'est exactement ce que je cherchais, merci.
- Vous êtes les bienvenus!
- Je dirais d'appeler les méthodes de la classe sur les instances est mauvais style de codage - tout simplement pas de raison de le faire et peut entraîner de la confusion. Mais oui, il fonctionne (java permet la même chose, mais les questions de la compilation d'avertissement lors de l'appel de méthodes statiques dans les instances)
- Tu veux dire quoi par "pas de raison de le faire"? Il est nécessaire si la méthode d'exécution de l'appel s'attend à ce que l'objet à mettre en œuvre cette méthode.
- Je pense que c'est juste pour le plaisir de l'explication. Personne de sensé écrire 2 parenthèse de plus s'il fallait 😀
- Il est souvent utile où un autre code s'attend à un objet de mettre en œuvre une méthode, mais la mise en œuvre ne nécessite pas l'instance, et dans certains autres contextes que vous voulez l'appeler sur la classe.
- True duck-typing donne une autre dimension. Il était plus sur de ne pas écrire des choses comme self.foo() quand il doit être Bar.foo().
- Que voulez-vous dire avec l'objet "s'attend à un objet de mettre en œuvre une méthode"? Un exemple?
- Oui, c'est ce que je veux dire.
- En fait, self.foo() est préférable, parce que self peut être une instance d'une sous-classe qui implémente sa propre foo.
- Je pense que cela dépend de ce que vous voulez atteindre. Mais je reçois votre point de vue.
- Cette réponse toujours ne touchez pas sur les différences entre classmethod et staticmethod, FWIW.
- C'est vrai, mais la question ne posez pas de questions sur staticmethod. Je vais ajouter quelque chose, bien que.
- Vous devriez utiliser un autre lambda pour Bar, comme 1+1 == 2 == 1*2, il est donc impossible de dire à partir des résultats montre que Bar().static_method est en fait appelé.
- grand cas d'utilisation won't need attention if the class is renamed
- Belle explication , j'ai eu la même question.
InformationsquelleAutor Marcin
-2

Si vous ajoutez le décorateur @classmethod, cela signifie Que vous allez faire de cette méthode en tant que méthode statique de java ou C++. ( méthode statique est une terme général je suppose que 😉 )
Python dispose également d' @staticmethod. et la différence entre classmethod et staticmethod est de savoir si vous pouvez
l'accès à la classe ou variable statique à l'aide d'un argument ou d'un nom de classe elle-même.
```
class TestMethod(object):
    cls_var = 1
    @classmethod
    def class_method(cls):
        cls.cls_var += 1
        print cls.cls_var

    @staticmethod
    def static_method():
        TestMethod.cls_var += 1
        print TestMethod.cls_var
#call each method from class itself.
TestMethod.class_method()
TestMethod.static_method()

#construct instances
testMethodInst1 = TestMethod()    
testMethodInst2 = TestMethod()   

#call each method from instances
testMethodInst1.class_method()
testMethodInst2.static_method()
```
toutes ces classes augmentation de la cls.cls_var par 1 et de l'imprimer.

Et toutes les classes avec le même nom sur le même champ d'application, ou des instances construit avec ces classe va partager ces méthodes.
Il n'y a qu'un TestMethod.cls_var
et aussi il n'y a qu'un TestMethod.class_method() , TestMethod.static_method()

Et importante question. pourquoi ces méthodes seraient nécessaires.

classmethod ou staticmethod est utile lorsque vous effectuez cette classe comme une usine
ou lorsque vous devez initialiser votre classe qu'une seule fois. comme d'ouvrir le fichier une fois, et en utilisant la méthode d'alimentation pour lire le fichier ligne par ligne.
- (a) les méthodes Statiques sont quelque chose d'autre; (b) classmethods ne sont pas partagées par toutes les classes.
- merci de me laisser savoir mon définitions floues et tout ça.
InformationsquelleAutor Ryan Kim

Vous devez vous connecter pour publier un commentaire.