Was sind in Python „Klassenmethoden“ und „Instanzmethoden“?
Eine "Instanzmethode" verwendet die in der Instanz enthaltenen Informationen, um herauszufinden, welcher Wert zurückgegeben werden soll (oder welche Nebenwirkung zu erzielen ist). Diese sind sehr verbreitet.
Eine "Klassenmethode" verwendet Informationen über die Klasse (und nicht eine Instanz dieser Klasse), um ihre Funktion zu beeinflussen (normalerweise werden sie zum Erstellen neuer Instanzen als alternative Konstruktoren verwendet und sind daher nicht sehr verbreitet).
Eine "statische Methode" verwendet keine Informationen über die Klasse oder Instanz, um zu berechnen, was sie tut. Es ist in der Regel nur in der Klasse für die Bequemlichkeit. (Daher sind diese auch nicht sehr verbreitet.)
Eine Funktion von X
Denken Sie daran, Mathe-Klasse, "y ist eine Funktion von x f(x),?" Wenden wir das im Code an:
y = function(x)
Aus dem oben Gesagten ergibt sich, dass xsich Änderungen ändern ykönnen, wenn sich xÄnderungen ergeben. Das ist gemeint, wenn wir sagen, dass " yeine Funktion von x" ist.
Was wird ysein , wenn zist 1? 2? 'FooBarBaz'?
yist keine Funktion von z, zkann also alles sein und hat keinen Einfluss auf das Ergebnis der Funktion, vorausgesetzt unsere functionist eine reine Funktion. (Wenn es zals globale Variable zugreift , dann ist es keine reine Funktion - das ist, was mit funktionaler Reinheit gemeint ist.)
Beachten Sie beim Lesen der folgenden Beschreibungen Folgendes:
Instanzmethoden
Eine Instanzmethode ist , die Funktion ist eine Funktion von einer Instanz . Die Funktion akzeptiert die Instanz implizit als Argument und die Instanz wird von der Funktion verwendet, um die Ausgabe der Funktion zu bestimmen.
Ein eingebautes Beispiel für eine Instanzmethode ist str.lower:
>>> 'ABC'.lower()
'abc'
str.lower wird für die Instanz der Zeichenfolge aufgerufen und verwendet die in der Instanz enthaltenen Informationen, um herauszufinden, welche neue Zeichenfolge zurückgegeben werden soll.
Klassenmethoden:
Denken Sie daran, in Python ist alles ein Objekt. Das heißt, die Klasse ist ein Objekt und kann als Argument an eine Funktion übergeben werden.
Eine Klasse - Methode ist eine Funktion , die eine Funktion ist von der Klasse . Es akzeptiert die Klasse als Argument dafür.
Ein eingebautes Beispiel ist dict.fromkeys:
>>> dict.fromkeys('ABC')
{'C': None, 'B': None, 'A': None}
Die Funktion kennt implizit ihre eigene Klasse, die Funktion verwendet die Klasse, um die Ausgabe der Funktion zu beeinflussen, und erstellt aus dem Iterablen eine neue Klasse dieser Klasse. Ein OrderedDict demonstriert dies mit der gleichen Methode:
>>> from collections import OrderedDict
>>> OrderedDict.fromkeys('ABC')
OrderedDict([('A', None), ('B', None), ('C', None)])
Die Klassenmethode verwendet Informationen zur Klasse (und nicht zu einer Instanz dieser Klasse), um zu bestimmen, welcher Klassentyp zurückgegeben werden soll.
Statische Methoden
Sie erwähnen eine Methode, die "ihre Klasse nicht kennt" - dies ist eine statische Methode in Python. Es wird lediglich der Einfachheit halber an das Klassenobjekt angehängt. Es könnte optional eine separate Funktion in einem anderen Modul sein, aber seine Anrufsignatur wäre dieselbe.
Eine statische Methode ist weder eine Funktion der Klasse noch des Objekts.
Ein eingebautes Beispiel für eine statische Methode ist str.maketrans aus Python 3.
>>> str.maketrans('abc', 'bca')
{97: 98, 98: 99, 99: 97}
Mit ein paar Argumenten wird ein Wörterbuch erstellt, das nicht von seiner Klasse abhängt.
Dies ist praktisch, da stres immer im globalen Namespace verfügbar ist, sodass Sie es problemlos mit der Übersetzungsfunktion verwenden können:
>>> 'abracadabra'.translate(str.maketrans('abc', 'bca'))
'bcrbabdbcrb'
In Python 2 müssen Sie über das stringModul darauf zugreifen :
>>> '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'
Beispiel
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
Lasst uns instanziieren:
>>> instance = AClass()
Jetzt kann die Instanz alle Methoden aufrufen:
>>> 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)
Die Klasse ist jedoch normalerweise nicht zum Aufrufen der Instanzmethode gedacht, obwohl erwartet wird, dass die anderen Methoden aufgerufen werden:
>>> 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'
Sie müssten die Instanz explizit übergeben, um die Instanzmethode aufzurufen:
>>> AClass.an_instance_method(instance, 'x', 'y')
('x', 'y', None)