Der Unterschied zwischen objektorientierten Python-Methoden

Python war von Anfang an eine objektorientierte Sprache. Aus diesem Grund ist es einfach, Klassen und Objekte in Python zu erstellen.

Zu den Methoden gehören: Instanzmethoden, statische Methoden und Klassenmethoden. Alle drei Methoden gehören zu Klassen im Speicher. Der Unterschied liegt in der aufrufenden Methode.

Instanzmethode: Wird vom Objekt aufgerufen; beim Ausführen einer normalen Methode wird das Objekt, das die Methode aufruft, automatisch zugewiesen.

Klassenmethode: Wird von der Klasse aufgerufen ; mindestens ein cls-Parameter; beim Ausführen einer Klassenmethode wird die Klasse, die die Methode aufruft, automatisch nach cls kopiert;

Instanzmethode

class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
ik1 = Kls('leo')
ik2 = Kls('lee')
ik1.printd()
ik2.printd()

Ausgabe:

leo 
lee

Im obigen Beispiel ist printd ein Instanzmethode. Der erste Parameter der Instanzmethode ist self. Wenn die Instanzmethode mit ik1.printd() aufgerufen wird, wird die Instanz ik1 an den self-Parameter übergeben, sodass der self-Parameter auf die Instanz verweisen kann, die die Instanz gerade aufruft Verfahren. Unter Ausnutzung dieser Funktion von Instanzmethoden gibt der obige Code die Mitgliedsdaten der beiden Instanzen korrekt aus.

Verwandte Empfehlungen: „

Python-Video-Tutorial

“

Klassenmethode

Pythons Klassenmethode verwendet den Dekorator @classmethod Definition, schauen wir uns das Beispiel direkt an.

class Kls(object):
    num_inst = 0
    def __init__(self):
        Kls.num_inst = Kls.num_inst + 1
    @classmethod
    def get_no_of_instance(cls):
        return cls.num_inst
ik1 = Kls()
ik2 = Kls()
print ik1.get_no_of_instance()
print Kls.get_no_of_instance()

Ausgabe:

2 
2

Im obigen Beispiel müssen wir die Anzahl der Instanzen der Klasse Kls zählen, daher wird eine Klassenvariable num_inst definiert, um die Anzahl der Instanzen zu speichern. Durch die Verwendung des Dekorators @classmethod wird die Methode get_no_of_instance als Klassenmethode definiert. Beim Aufruf einer Klassenmethode übergibt Python die Klasse (Klasse Kls) an cls, sodass in get_no_of_instance auf die Klassenvariable num_inst verwiesen werden kann.

Da Sie beim Aufrufen einer Klassenmethode nur den Typ selbst an die Klassenmethode übergeben müssen, kann die Klassenmethode daher entweder über die Klasse oder über die Instanz aufgerufen werden.

Statische Methode

In der Entwicklung müssen wir häufig einige Methoden definieren, die sich auf die Klasse beziehen, aber während der Implementierung nicht auf die Klasse oder Instanz verweisen müssen B. Umgebungsvariablen festlegen, Variablen einer anderen Klasse ändern usw. Zu diesem Zeitpunkt können wir statische Methoden verwenden.

Python verwendet den Dekorator @staticmethod, um eine statische Methode zu definieren.

IND = 'ON'

class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return IND == 'ON'
    def do_reset(self):
        if self.checkind():
            print('Reset done for: %s' % self.data)
    def set_db(self):
        if self.checkind():
            print('DB connection made for: %s' % self.data)
ik1 = Kls(24)
ik1.do_reset()
ik1.set_db()

Ausgabe:

Reset done for: 24 
DB connection made for: 24

Im Code definieren wir eine globale Variable IND mit der Klasse Kls verknüpft, wir verwenden die Die Methode Checkind wird in der Klasse Kls platziert und definiert. Die Methode checkind muss nur den Wert von IND überprüfen, ohne auf die Klasse oder Instanz zu verweisen. Daher definieren wir die Methode checkind als statische Methode.

Für statische Methoden muss Python keine Klassen oder Instanzen übergeben, Sie können also entweder Klassen oder Instanzen verwenden, um statische Methoden aufzurufen.

Der Unterschied zwischen Instanzmethoden, Klassenmethoden und statischen Methoden

Wir verwenden Code, um die Unterschiede zwischen Instanzmethoden, Klassenmethoden und statischen Methoden zu veranschaulichen. Achten Sie auf die Definition und Verwendung der Methoden foo, class_foo und static_foo im folgenden Code.

class Kls(object):
    def foo(self, x):
        print('executing foo(%s,%s)' % (self, x))
    @classmethod
    def class_foo(cls,x):
        print('executing class_foo(%s,%s)' % (cls,x))
    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % x)
ik = Kls()
# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')
# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')
# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

Ausgabe:

executing foo(<__main__.Kls object at 0x0551E190>,1)
<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
==========================================
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
executing class_foo(<class &#39;__main__.Kls&#39;>,1)
<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>
==========================================
executing static_foo(1)
executing static_foo(hi)
<function static_foo at 0x055238B0>

Bei Instanzmethoden wird das Instanz-IK beim Aufruf als erster Parameter an den Parameter self übergeben. Daher gibt der Aufruf von ik.foo(1) die Adresse der Instanz ik aus.

Bei Klassenmethoden wird die Klasse Kls beim Aufruf als erster Parameter an den cls-Parameter übergeben. Daher werden beim Aufruf von ik.class_foo(1) Kls-Typinformationen ausgegeben.

Wie bereits erwähnt, können Klassenmethoden über Klassen oder Instanzen aufgerufen werden. Im obigen Code haben wir es erneut überprüft.

Bei statischen Methoden ist es nicht erforderlich, beim Aufruf eine Klasse oder Instanz zu übergeben. Tatsächlich sind statische Methoden den Funktionen, die wir außerhalb der Klasse definieren, sehr ähnlich, mit der Ausnahme, dass statische Methoden über Klassen oder Instanzen aufgerufen werden können.

Es ist erwähnenswert, dass foo im obigen Beispiel nur eine Funktion ist, aber wenn wir ik.foo aufrufen, erhalten wir eine Funktion, die an die Instanz ik gebunden wurde. Für den Aufruf von foo sind zwei Argumente erforderlich, für den Aufruf von ik.foo jedoch nur ein Argument. foo ist an ik gebunden. Wenn wir also ik.foo drucken, sehen wir die folgende Ausgabe:

<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

Wenn ik.class_foo aufgerufen wird, bezieht sich class_foo auf Kls Bind (stattdessen, da class_foo eine Klassenmethode ist). der Bindung an ik). Wenn wir ik.class_foo drucken, lautet die Ausgabe:

<bound method type.class_foo of <class &#39;__main__.Kls&#39;>>

Beim Aufruf von ik.static_foo ist die statische Methode nicht an die Klasse oder Instanz gebunden. Daher wird beim Drucken von ik.static_foo (oder Kls.static_foo) die Ausgabe:

<function static_foo at 0x055238B0>

Zusammenfassend lässt sich sagen, dass dies der Unterschied zwischen Instanzmethoden, Klassenmethoden und statischen Methoden ist, unabhängig davon, ob sie an eine Klasse oder eine Instanz gebunden ist.

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen objektorientierten Python-Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!