So verwenden Sie Python-Klassen und -Objekte

Objekt = Attribut + Methode

Wir sind tatsächlich schon einmal mit dem Konzept der Kapselung in Kontakt gekommen, das ist eine Art Kapselung, also eine Kapselung auf Datenebene Funktion, das ist auch eine Art Kapselung, ist eine Kapselung auf der Anweisungsebene ; das Objekt, das wir jetzt lernen wollen, ist auch eine Idee der Kapselung. Die Quelle des Objekts besteht darin, die reale Welt zu simulieren und beide Daten zu kapseln und gemeinsam codieren. Zum Beispiel ist eine Schildkröte ein Objekt in der realen Welt und wird normalerweise aus zwei Teilen beschrieben.

(1) Beschreibung aus

statischen Eigenschaften
: Zum Beispiel grün, hat vier Beine, hat eine Schale usw. Dies ist eine statische Beschreibung. (2) Beschreibung aus dem dynamischen Verhalten
: Zum Beispiel krabbelt es, wenn man es verfolgt, rennt es, manchmal beißt es, schläft usw. Dies wird alles aus dem Verhaltensaspekt beschrieben. Dasselbe gilt für Objekte in Python,

Die Eigenschaften eines Objekts werden „Eigenschaften“ genannt

, Das Verhalten eines Objekts wird „Methoden“ genannt. :

Wenn Sie Turtle als Code schreiben, sieht es so aus:

class Turtle: # Python中的类名约定以大写字母开头
    
    # 特征的描述称为属性，在代码层面看来其实就是变量
    color = 'green'
    legs = 4
    shell = True

    # 方法实际就是函数，通过调用这些函数来完成某些工作
    def climb(self):
        print('向前爬')
    def run(self):
        print('向前跑')
    def bite(self):
        print('咬人')
    def sleep(self):
        print('睡觉')

Der obige Code definiert die Eigenschaften (Eigenschaften) und Verhaltensweisen (Methoden) des Objekts

, aber es ist noch kein vollständiges Objekt wird als

Klasse definiert. Sie müssen eine Klasse verwenden, um ein echtes Objekt zu erstellen. Dieses Objekt wird als Instanz dieser Klasse bezeichnet, auch Instanzobjekte genannt. Das ist zum Beispiel wie eine Fabrik, die eine Reihe von Spielzeugen herstellen muss. Sie muss zunächst eine Form für das Spielzeug herstellen und es dann auf der Grundlage der Form in Massenproduktion herstellen. Wie erstellt man also ein echtes Instanzobjekt?
Das Erstellen eines Objekts, auch Instanziierung einer Klasse genannt

,

ist eigentlich ganz einfach:

# 首先要有上面那一段类的定义
tt = Turtle()

Hinweis:

Dem Klassennamen folgen Klammern, was dem Aufruf einer Funktion entspricht. In Python beginnen also

Klassennamen mit Großbuchstaben und Funktionen mit Kleinbuchstaben, wodurch sie leichter zu unterscheiden sind. Darüber hinaus ist die Zuweisungsoperation nicht erforderlich, aber wenn das erstellte Instanzobjekt keiner Variablen zugewiesen ist, kann das Objekt nicht verwendet werden, da kein Verweis auf diese Instanz vorhanden ist, und es wird schließlich automatisch von der Garbage Collection von Python recycelt Mechanismus. Wenn Sie

eine Methode in einem Objekt aufrufen möchten, verwenden Sie einfach den Punktoperator (.)

.

Schauen wir uns als Nächstes einen Teil des Codes an und erhalten ein tieferes Verständnis der drei Konzepte
Klasse

,

Klassenobjekt und Instanzobjekt:

Wie Sie sehen können Aus diesem Beispiel geht hervor, dass richtig ist. Nachdem dem Zählattribut des Instanzobjekts c ein Wert zugewiesen wurde, entspricht dies dem Überschreiben des Zählattributs des Klassenobjekts C. Wie in der folgenden Abbildung dargestellt, wird auf das Zählattribut des Klassenobjekts verwiesen, wenn keine Zuweisungsabdeckung vorhanden ist.

Es ist zu beachten, dass die in der Klasse definierten Attribute statische Variablen

sind. Die Attribute der Klasse sind an das Klassenobjekt gebunden und hängen nicht von einem seiner Instanzobjekte ab.

Darüber hinaus gilt:

Wenn der Name des Attributs mit dem Methodennamen übereinstimmt, überschreibt das Attribut die Methode

:

Um Namenskonflikte zu vermeiden, sollten einige allgemeine Regeln befolgt werden: (1 ) Versuchen Sie nicht, es in einer Klasse zu definieren. Alle denkbaren Funktionen und Methoden sollten mithilfe von Vererbungs- und Kompositionsmechanismen erweitert werden.

(2) Verwenden Sie zum Benennen verschiedene Wortarten, z. B. Substantive für Attributnamen, Verben für Methodennamen, und verwenden Sie die Kamel-Fall-Benennung.

Was ist Selbst? Aufmerksame Leser werden feststellen, dass die Methoden von Objekten einen Selbstparameter haben. Was ist also dieses Selbst? Wenn Sie mit C++ vertraut sind, sollten Sie es leicht herausfinden können: „Pythons Selbst entspricht tatsächlich dem Zeiger von C++.“

Wenn Sie noch nie zuvor mit einer Programmiersprache in Berührung gekommen sind, dann sagen wir einfach: Wenn man
Klassen mit Zeichnungen vergleicht
, dann sind

durch Klassen instanziierte Objekte echte Häuser, in denen man leben kann

. Auf der Grundlage einer Zeichnung können Tausende von Häusern entworfen werden. Sie sehen alle ähnlich aus, aber jedes Haus hat einen anderen Eigentümer. Jeder möchte sein eigenes Haus finden,

Dann ist self hier gleichbedeutend mit der Hausnummer

Mit self können Sie ganz einfach Ihr eigenes Haus finden. Pythons Selbstparameter hat den gleichen Grund. Aus einer Klasse können unzählige Objekte generiert werden. Wenn eine Objektmethode aufgerufen wird, übergibt das Objekt seine eigene Referenz auf die Methode als ersten Parameter, dann weiß Python, was benötigt wird. Die Methode, mit der das Objekt bedient wird

.

Ein einfaches Beispiel:

公有和私有

一般面向对象的编程语言都会区分公有和私有的数据类型，像C++和Java它们使用public和private关键字用于声明数据是公有的还是私有的，但在Python中并没有类似的关键字来修饰。

默认上对象的属性和方法都是公开的，可以直接通过点操作符（.）进行访问：

为了实现类似私有变量的特征，Python内部采用了一种叫name mangling（名字改编）的技术，在Python中定义私有变量只需要在变量名或函数名前加上“_ _”两个下划线，那么这个函数或变量就会成为私有的了：

这样，在外部将变量名“隐藏”起来了，理论上如果要访问，就要从内部进行：

但是认真想一下这个技术的名字name mangling（名字改编），那就不难发现其实Python只是把双下横线开头的变量进行了改名而已。实际上，在外部使用“_类名_ _变量名”即可访问双下横线开头的私有变量了：

说明：Python目前的私有机制其实是伪私有的，Python的类是没有权限控制的，所有的变量都是可以被外部调用的。

继承

举个例子来说明继承。例如现在有个游戏，需要对鱼类进行细分，有金鱼（Goldfish）、鲤鱼（Carp）、三文鱼（Salmon）以及鲨鱼（Shark）。那么我们能不能不要每次都从头到尾去重新定义一个新的鱼类呢？因为我们知道大多数鱼的属性和方法是相似的，如果有一种机制可以让这些相似的东西得以自动传递，那么就方便多了。这就是继承。

继承的语法很简单：

c l a s s 类 名 （ 被 继 承 的 类 ） : . . . class 类名（被继承的类）: \\ \quad ... class类名（被继承的类）:...

被继承的类称为基类、父类或超类；继承者称为子类，一个子类可以继承它的父类的任何属性和方法。

举个例子：

需要注意的是，如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性：

接下来，尝试写一下开头提到的金鱼（Goldfish）、鲤鱼（Carp）、三文鱼（Salmon）以及鲨鱼（Shark）的例子。

import random as r
class Fish:
    def __init__(self):
        self.x = r.randint(0, 10)
        self.y = r.randint(0, 10)
    def move(self):
        # 这里主要演示类的继承机制，就不考虑检查场景边界和移动方向问题
        # 假设所有的鱼都是一路向西游
        self.x -= 1
        print("我的位置是：", self.x, self.y)
# 金鱼
class Goldfish(Fish):
    pass
# 鲤鱼
class Carp(Fish):
    pass
#三文鱼
class Salmon(Fish):
    pass
# 上面三种鱼都是食物，直接继承Fish类的全部属性和方法
# 下面定义鲨鱼类，除了继承Fish类的属性和方法，还要添加一个吃的方法
class Shark(Fish):
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("吃掉你!")
            self.hungry = False
        else:
            print("太饱了，吃不下了~")

首先运行这段代码，然后进行测试：

同样是继承于Fish类，为什么金鱼（goldfish）可以移动，而鲨鱼（shark）一移动就报错呢？
可以看到报错提示为：Shark对象没有x属性，这是因为在Shark类中，重写了_ _init_ _()方法，但新的_ _init_ _()方法里面没有初始化鲨鱼的x坐标和y坐标，因此调用move()方法就会出错。
那么解决这个问题，只要在鲨鱼类中重写_ _init_ _()方法的时候先调用基类Fish的_ _init_ _()方法。

下面介绍两种可以实现的技术：

• （1）调用未绑定的父类方法

• （2）使用super函数

调用未绑定的父类方法

什么是调用未绑定的父类方法？举个例子：

修改之后，再运行下发现鲨鱼也可以成功移动了：

这里需要注意的是，这个self并不是父类Fish的实例对象，而是子类Shark的实例对象。所以这里说的未绑定是指并不需要绑定父类的实例对象，使用子类的实例对象代替即可。

Verwenden der Superfunktion

Die Superfunktion kann uns dabei helfen,automatisch die Basisklassenmethode zu finden und auch den Selbstparameter für uns übergeben, sodass wir diese Dinge nicht tun müssen:

Nach dem Ausführen erhalten wir das gleiche Ergebnis:

Mehrfachvererbung

Darüber hinaus unterstützt Python auch

Mehrfachvererbung, das heißt, Sie können die Eigenschaften und Methoden mehrerer übergeordneter Klassen gleichzeitig erben :

c l a s Klassenname (übergeordnete Klasse 1, übergeordnete Klasse 3, . . . ): . quad ... Klasse Klassenname (übergeordnete Klasse 1, übergeordnete Klasse 2, übergeordnete Klasse 3,...):...

Zum Beispiel:

Dies ist die grundlegende Mehrfachvererbungssyntax, aber Mehrfachvererbung kann leicht zu Codeverwirrung führen. Wenn Sie sich also nicht sicher sind, ob Sie Mehrfachvererbung wirklich verwenden müssen, vermeiden Sie die Verwendung, da manchmal unvorhergesehene Fehler auftreten können.

Zusammensetzung

Wir haben das Konzept der Vererbung bereits kennengelernt und Mehrfachvererbung erwähnt, aber wenn wir jetzt Schildkröten und Fische haben, müssen wir jetzt eine Klasse namens Pool definieren, und es müssen Schildkröten und Fische im Pool sein . Es scheint seltsam, Mehrfachvererbung zu verwenden, da der Pool, die Schildkröte und der Fisch unterschiedliche Arten sind. Wie kann man sie also zu einer Poolklasse kombinieren?

Tatsächlich ist es in Python ganz einfach:
Fügen Sie die erforderlichen Klassen ein und instanziieren Sie dies:

Führen Sie zuerst den obigen Code aus und testen Sie dann:

Konstruktion und Zerstörung

Python-Objekte verfügen über viele magische Methoden. Wenn Ihr Objekt eine dieser Methoden implementiert, wird diese Methode unter besonderen Umständen von Python aufgerufen, und das alles geschieht automatisch.

_ _init_ _(self[, …])-Konstruktor

Die _ _init_ _()-Methode wird normalerweise als Konstruktor bezeichnet. Solange ein Objekt instanziiert ist, wird diese Methode automatisch aufgerufen, wenn das Objekt erstellt wird . Beim Instanziieren eines Objekts können Parameter übergeben werden. Diese Parameter werden automatisch an die Methode _ _init_ _() übergeben. Sie können den Initialisierungsvorgang des Objekts anpassen, indem Sie diese Methode überschreiben.

Zum Beispiel:

Einige Leser fragen sich vielleicht: Manchmal ist die Methode _ _init_ _() in der Klassendefinition geschrieben, manchmal jedoch nicht. Warum ist das so? Schauen Sie sich das folgende Beispiel an:

Hier muss beachtet werden, dass der Rückgabewert der Methode _ _init_ _() None sein muss und nicht anders sein darf

:

Also ist

im Allgemeinen Wird verwendet, wenn eine Initialisierung erforderlich ist. Schreiben Sie einfach die Methode _ _init_ _() neu. Diese _ _init_ _()-Methode ist also nicht die erste Methode, die beim Instanziieren eines Objekts aufgerufen wird. _ _new_ _(cls[, …])-Methode

_ _new_ _()-Methode ist die erste Methode , die aufgerufen wird, wenn ein Objekt instanziiert wird. Anders als bei anderen Methoden ist der erste Parameter nicht self, sondern die Klasse (cls), und andere Parameter werden direkt an die Methode _ _init_ _() übergeben. Die Methode

_ _new_ _() muss ein Instanzobjekt zurückgeben, normalerweise das von der cls-Klasse instanziierte Objekt. Natürlich können Sie auch andere Objekte zurückgeben. _ _new_ _()-Methode wird selten neu geschrieben. Im Allgemeinen kann Python mit dem Standardschema ausgeführt werden. Aber

Es gibt eine Situation, in der Sie diese Methode überschreiben müssen

, das heißt,

wenn Sie einen unveränderlichen Typ erben

, werden dessen Eigenschaften besonders wichtig.

_ _del_ _(self) Destruktormethode

Wenn die Methoden _ _init_ _() und _ _new_ _() die Konstruktoren von Objekten sind, stellt Python auch einen Destruktor namens _ _del_ _() zur Verfügung. Wenn das Objekt zerstört werden soll, wird diese Methode aufgerufen

. Es ist jedoch zu beachten, dass del x nicht dem automatischen Aufruf von x entspricht. Die Methode _ _del_ _() wird aufgerufen, wenn der Garbage Collection-Mechanismus dieses Objekt recycelt.

Zum Beispiel:

Was ist Bindung

Das Konzept der Bindung wurde bereits erwähnt, aber was genau ist Bindung? Python verlangt unbedingt, dass Methoden eine Instanz haben müssen, bevor sie aufgerufen werden können. Diese Einschränkung ist eigentlich das sogenannte Bindungskonzept von Python.

Jemand könnte dies versuchen und feststellen, dass es auch aufgerufen werden kann:

Dabei gibt es jedoch ein Problem, nämlich Die darin enthaltene Funktion kann gemäß dem von der Klasse instanziierten Objekt überhaupt nicht aufgerufen werden :

Tatsächlich wird das BB-Objekt aufgrund des Bindungsmechanismus von Python automatisch als erster Parameter übergeben, sodass TypeError auftritt.

Sehen Sie sich ein anderes Beispiel an:

_ _dict_ _Attribute bestehen aus einem Wörterbuch, es gibt nur Attribute von Instanzobjekten. Der Schlüssel stellt dar Der Attributname , value stellt den entsprechenden Datenwert des Attributs dar.

Jetzt hat das Instanzobjekt dd zwei neue Attribute, und diese beiden Attribute gehören nur zum Instanzobjekt:

Warum ist das so? Tatsächlich ist dies vollständig auf den Parameter self zurückzuführen: Wenn das Instanzobjekt dd die Methode setXY aufruft, ist der erste Parameter, den es übergibt, dd, sodass self.x = 4 und self.y = 5 äquivalent zu dd x = sind 4, dd.y = 5, daher können Sie x und y weder im Instanzobjekt noch im Klassenobjekt sehen, da diese beiden Attribute nur zum Instanzobjekt dd gehören. Wenn die Klasseninstanz gelöscht wird, kann das Instanzobjekt dd weiterhin die printXY-Methode aufrufen? Die Antwort ist ja:

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Python-Klassen und -Objekte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!