Que sont les «méthodes de classe» et les «méthodes d'instance» en Python?
Une "méthode d'instance" utilise les informations contenues dans l'instance pour déterminer la valeur à renvoyer (ou l'effet secondaire à effectuer). Ce sont très communs.
Une "méthode de classe" utilise des informations sur la classe (et non une instance de cette classe) pour affecter son action (elles sont généralement utilisées pour créer de nouvelles instances en tant que constructeurs alternatifs et ne sont donc pas incroyablement communes).
Une "méthode statique" n'utilise aucune information sur la classe ou l'instance pour calculer ce qu'elle fait. C'est généralement juste dans la classe pour plus de commodité. (En tant que tels, ils ne sont pas très courants non plus.)
Une fonction de X
Rappelez-vous la classe de mathématiques, "y est une fonction de x f(x),?" Appliquons cela dans le code:
y = function(x)
Ce qui est supposé par ce qui précède est que depuis xpeut changer, ypeut changer lorsque des xchangements C’est ce que l’on entend par " yfonction de x"
Qu'est - ce qui yest quand zest 1? 2? 'FooBarBaz'?
yn'est pas une fonction de z, donc zpeut être n'importe quoi et ne pas affecter le résultat de la fonction en supposant que notre fonction functionest pure. (Si elle accède en ztant que variable globale, alors ce n'est pas une fonction pure - c'est ce que l'on entend par pureté fonctionnelle.)
Gardez ce qui précède à l’esprit lorsque vous lisez les descriptions suivantes:
Méthodes d'instance
Une méthode d'instance est une fonction qui est une fonction d' une instance . La fonction accepte implicitement l'instance en tant qu'argument et l'instance est utilisée par la fonction pour déterminer la sortie de la fonction.
Un exemple intégré d'une méthode d'instance est str.lower:
>>> 'ABC'.lower()
'abc'
str.lower est appelé sur l'instance de la chaîne et utilise les informations contenues dans l'instance pour déterminer la nouvelle chaîne à renvoyer.
Méthodes de classe:
Rappelez-vous, en Python, tout est un objet. Cela signifie que la classe est un objet et peut être transmise comme argument à une fonction.
Une méthode de classe est une fonction qui est une fonction de la classe . Il accepte la classe comme argument.
Un exemple intégré est dict.fromkeys:
>>> dict.fromkeys('ABC')
{'C': None, 'B': None, 'A': None}
La fonction connaît implicitement sa propre classe. Elle utilise la classe pour affecter la sortie de la fonction et crée une nouvelle classe de cette classe à partir de l'itérable. OrderedDict le démontre en utilisant la même méthode:
>>> from collections import OrderedDict
>>> OrderedDict.fromkeys('ABC')
OrderedDict([('A', None), ('B', None), ('C', None)])
La méthode class utilise des informations sur la classe (et non une instance de cette classe) pour affecter le type de classe à renvoyer.
Méthodes statiques
Vous mentionnez une méthode qui "ne connaît pas sa classe" - il s'agit d'une méthode statique en Python. Il est simplement attaché par commodité à l'objet de classe. Il pourrait éventuellement s'agir d'une fonction distincte dans un autre module, mais sa signature d'appel serait la même.
Une méthode statique n'est une fonction ni de la classe ni de l'objet.
Str.maketrans de Python 3 est un exemple intégré de méthode statique.
>>> str.maketrans('abc', 'bca')
{97: 98, 98: 99, 99: 97}
À partir de quelques arguments, il crée un dictionnaire qui n'est pas une fonction de sa classe.
C'est pratique car il strest toujours disponible dans l'espace de noms global, vous pouvez donc l'utiliser facilement avec la fonction de traduction:
>>> 'abracadabra'.translate(str.maketrans('abc', 'bca'))
'bcrbabdbcrb'
En Python 2, vous devez y accéder depuis le stringmodule:
>>> 'abracadabra'.translate(str.maketrans('abc', 'bca'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'str' has no attribute 'maketrans'
>>> import string
>>> 'abracadabra'.translate(string.maketrans('abc', 'bca'))
'bcrbabdbcrb'
Exemple
class AClass(object):
"""In Python, a class may have several types of methods:
instance methods, class methods, and static methods
"""
def an_instance_method(self, x, y, z=None):
"""this is a function of the instance of the object
self is the object's instance
"""
return self.a_class_method(x, y)
@classmethod
def a_class_method(cls, x, y, z=None):
"""this is a function of the class of the object
cls is the object's class
"""
return cls.a_static_method(x, y, z=z)
@staticmethod
def a_static_method(x, y, z=None):
"""this is neither a function of the instance or class to
which it is attached
"""
return x, y, z
Instancions:
>>> instance = AClass()
Maintenant, l'instance peut appeler toutes les méthodes:
>>> instance.an_instance_method('x', 'y')
('x', 'y', None)
>>> instance.a_static_method('x', 'y')
('x', 'y', None)
>>> instance.a_class_method('x', 'y')
('x', 'y', None)
Mais la classe n'est généralement pas destinée à appeler la méthode d'instance, bien qu'elle soit appelée aux autres:
>>> AClass.a_class_method('x', 'y')
('x', 'y', None)
>>> AClass.a_static_method('x', 'y')
('x', 'y', None)
>>> AClass.an_instance_method('x', 'y')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: an_instance_method() missing 1 required positional argument: 'y'
Vous devez explicitement passer l'instance pour appeler la méthode d'instance:
>>> AClass.an_instance_method(instance, 'x', 'y')
('x', 'y', None)