Es gab eine Diskussion im Chat über eine Frage (die Frage selbst ist für diese irrelevant), die ergeben hat, dass ich Python möglicherweise überhaupt nicht kenne.

Obwohl sich die Terminologie in den verschiedenen Sprachen unterscheidet, können wir meiner Meinung nach Funktionen im Allgemeinen wie folgt einteilen:

• [freie] Funktionen
• statische Methoden / statische Elementfunktionen
• nicht statische Methoden / nicht statische Elementfunktionen

Anscheinend gibt es in Python eine andere Art von Funktion, die nicht in die obigen Kategorien passt, eine Methode, die aber "ihre Klasse nicht kennt".

Was sind "Klassenmethoden" und "Instanzmethoden" in Python?

Die kurze Antwort

• Eine Instanzmethode kennt ihre Instanz (und daraus ihre Klasse)
• Eine Klassenmethode kennt ihre Klasse
• Eine statische Methode kennt ihre Klasse oder Instanz nicht

Die lange Antwort

Klassenmethoden

Eine Klassenmethode ist eine, die zur gesamten Klasse gehört. Es ist keine Instanz erforderlich. Stattdessen wird die Klasse automatisch als erstes Argument gesendet. Mit dem @classmethodDecorator wird eine Klassenmethode deklariert .

Beispielsweise:

class Foo(object):
    @classmethod
    def hello(cls):
        print("hello from %s" % cls.__name__)
Foo.hello()
-> "Hello from Foo"
Foo().hello()
-> "Hello from Foo"

Instanzmethoden

Auf der anderen Seite, eine Instanz - Methode erfordert eine Instanz, um sie zu nennen, und erfordert keinen Dekorateur. Dies ist bei weitem die gebräuchlichste Methode.

class Foo(object):
    def hello(self):
        print("hello from %s" % self.__class__.__name__)
Foo.hello()
-> TypeError: hello() missing 1 required positional argument: 'self'

(Hinweis: Das obige ist mit python3; mit python2 wird ein etwas anderer Fehler angezeigt)

Statische Methoden

Eine statische Methode ähnelt einer Klassenmethode, ruft jedoch das Klassenobjekt nicht als automatischen Parameter ab. Es wird mit dem @staticmethodDekorateur erstellt.

class Foo(object):
    @staticmethod
    def hello(cls):
        print("hello from %s" % cls.__name__)

Foo.hello()
-> TypeError: hello() missing 1 required positional argument: 'cls'

Dokumentationslinks

Hier sind Links zur entsprechenden python3-Dokumentation:

• https://docs.python.org/3.5/library/functions.html#classmethod
• https://docs.python.org/3.5/library/functions.html#staticmethod

Die Dokumentation des Datenmodells enthält folgende Informationen zum Unterschied zwischen Klassenmethoden und statischen Methoden:

Statische Methodenobjekte Mit statischen Methodenobjekten können Sie die oben beschriebene Transformation von Funktionsobjekten in Methodenobjekte verhindern. Ein statisches Methodenobjekt ist ein Wrapper um ein beliebiges anderes Objekt, normalerweise ein benutzerdefiniertes Methodenobjekt. Wenn ein statisches Methodenobjekt aus einer Klasse oder einer Klasseninstanz abgerufen wird, ist das tatsächlich zurückgegebene Objekt das umschlossene Objekt, das keiner weiteren Transformation unterzogen wird. Statische Methodenobjekte sind selbst nicht aufrufbar, obwohl dies normalerweise die Objekte sind, die sie umschließen. Statische Methodenobjekte werden mit dem integrierten staticmethod () -Konstruktor erstellt.

Klassenmethodenobjekte Ein Klassenmethodenobjekt ist wie ein statisches Methodenobjekt ein Wrapper um ein anderes Objekt, der die Art und Weise ändert, in der dieses Objekt aus Klassen und Klasseninstanzen abgerufen wird. Das Verhalten von Klassenmethodenobjekten bei einem solchen Abruf ist oben unter „Benutzerdefinierte Methoden“ beschrieben. Klassenmethodenobjekte werden vom integrierten classmethod () -Konstruktor erstellt.

Verwandte Fragen

• Was ist der Unterschied zwischen @staticmethod und @classmethod in Python? (Paketüberfluss)

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)

• Eine "Instanzmethode" ist eine Methode, die das Instanzobjekt als ersten Parameter übergibt, der per Konvention aufgerufen wird self. Dies ist die Standardeinstellung.

• Eine "statische Methode" ist eine Methode ohne den Anfangsparameter self. Dies wird mit dem Dekorator @staticmethod implementiert .

• Eine "Klassenmethode" ist eine Methode, bei der der Anfangsparameter kein Instanzobjekt ist, sondern das Klassenobjekt ( was ein "Klassenobjekt" ist, erfahren Sie in diesem Teil der Python-Dokumentation ), das gemäß der Konvention aufgerufen wird cls. Dies wird mit dem @ classmethod decorator implementiert .

Die typische Verwendung des Begriffs "statische Methode" in C / C ++ / etc gilt sowohl für Python-Methoden "static" als auch für Python-Methoden "class", da diese beiden Methoden keinen Verweis auf die Instanz enthalten. In C / C ++ / etc haben Methoden normalerweise impliziten Zugriff auf alle Nicht-Instanz-Member / Methoden der Klasse, weshalb diese Unterscheidung wahrscheinlich nur in Sprachen wie Python / Ruby / etc vorhanden ist.