1. Objektorientiertes Konzept
Der Prozess der Klassifizierung von Klassen mit gemeinsamen Eigenschaften wird als Objektorientierung bezeichnet.
2. Angelegenheiten, die Aufmerksamkeit erfordern
Bei der Definition einer Klasse muss der erste Buchstabe des Klassennamens groß geschrieben werden
3. Objektorientierter Fall
1 Klasse Person(Objekt):
2 def __init__(self,name,age): #name,age kann als Attribut der Klasse verstanden werden, init ist Initialisierung, die in der Klasse definierte Funktion heißt Konstruktor/Konstruktor
3 self.name=name #Instanzattribut
4 selbst.alter=alter
5 print("Start")
6 def __del__(self): #Bereinigungsvorgang
7 print("ende")
8 def show(self): #self ist die Klasse selbst und kann nicht weggelassen werden
9 print("name:{0},age:{1}".format(self.name,self.age))
10 obj=Person(name="wuya",age=18) #Um die Variablen, Methodenfunktionen usw. in der Klasse aufzurufen, müssen Sie zuerst die Klasse instanziieren, obj ist das Objekt nach der Instanziierung der Klasse Person() , und die Klasse wird instanziiert. Der Prozess ist auch der Prozess der Klasseninitialisierung. Der Instanziierungsprozess der Klasse ist auch der Initialisierungsprozess für den Konstruktor (entspricht der Methode zum Aufrufen von __init__)
11 obj.show()
12 #Person(name="wuya",age=18).show() #Methode mit dem Klassennamen aufrufen
Das Ergebnis der Ausführung des obigen Codes ist:
4. Die Ausführungsreihenfolge von Methoden in der Klasse: Initialisierungsmethode -> spezifische Methode -> Reinigungsmethode
5. Objektorientierte Funktionen
1 Paket
a) Instanzattribute
b. Datenattribute (Variablen in einer Klasse)
2) Erbschaft
3) Polymorphismus
6. Methode:
a) Gewöhnliche Methode: gehört zum Objekt, gehört auch zur Klasse, kann nur lesen und schreiben;
b) Merkmalsmethode: gehört zum Objekt, hat nur das Leseattribut, und die Methode kann keine formalen Parameter haben;
c) Statische Methode: Sie gehört zu einer Klasse und kann nur über den Klassennamen aufgerufen werden.Im Allgemeinen werden Datenattribute von statischen Methoden verarbeitet.
7. Beispiel für einen Encapsulation-Eintrag
1 Klasse Tier(Objekt):
2 def __init__(selbst,alter):
3 selbst.alter=alter
4 def getAge(selbst):
5 Rückkehr self.age
6 def setAge (selbst, Alter):
7 wenn Alter>10 und Alter<100:
8 self.age=Alter #Änderung des Alters zulassen
9 sonst:
10 print("Altersfehler")
11 objAnimal=Animal(age=25) #Instanziierung der Klasse
12 print(objAnimal.getAge()) #Gib das Aufrufergebnis der Methode zum Ermitteln des Alters aus
13 objAnimal.setAge(age=11) #Rufen Sie die Methode auf, um das Alter zu ändern
14 print(objAnimal.getAge()) #Gib das Aufrufergebnis der Methode zum Ermitteln des Alters aus
8. Fortgeschrittene Verpackungsbeispiele
1 Klasse Tier(Objekt):
2 address="Erde" #Datenattribut
3 def __init__(selbst,alter):
4 self.age=age #Instance-Attribute
5 # @statischeMethode
6 def address(self): #Statische Methode, Datenattribute werden mit statischen Methoden behandelt
7 Rückkehr "Erde"
8 def show(self,name="❀"): #Gewöhnliche Methode, lesbar und schreibbar
9 print("Es kommt von {0}, und sein Alter ist {1}, und sein Name ist {2}".format(self.address(),self.age,name))
10 def func(self,**kwargs):
11 Druck (Kwarg)
12 @Eigenschaft
13 def info(self): #Feature Methode, read-only (nur Ausgabe)
14 Druck ("Hallo Welt")
15 @Eigenschaft
16 def getAge(self): #Attribute-Methode, schreibgeschützt (nur Rückgabe)
17 Rückkehr selbst. Alter
18 objAnimal=Animal(age=30) #Instanziierung der Klasse
19 objAnimal.show() #Gewöhnliche Methoden aufrufen
20 #objAnimal.show(name="Affe")
21 # Tier().show(name="Affe")
22 # Tier(Alter=10).Adresse()
23 objAnimal.func(name="cch",age=18,city="Xi'an")
24 objAnimal.info #Charakteristischer Methodenaufruf
25 print(Tier.adresse(""))
26 print(objAnimal.age)
9. Erbschaft
1) Konzept
Elternklasse (Basisklasse): Die Klasse, die geerbt wird
Unterklasse (abgeleitete Klasse): erbt von einer anderen Klasse
2) Der Unterschied zwischen Java- und Python-Vererbung
Java ist Einfachvererbung, Python ist Mehrfachvererbung
3) Was erbt die Unterklasse von der Elternklasse:
a) Variablen (Datenattribute)
b. Instanzattribute
c. Methode
3) Methodenüberschreibung
Wenn die Methode der übergeordneten Klasse die Anforderungen der untergeordneten Klasse nicht erfüllen kann, überschreibt die untergeordnete Klasse die Methode der übergeordneten Klasse, und das Objekt ruft nach der Instanziierung der untergeordneten Klasse die Methode auf, und die Methode der untergeordneten Klasse ist Priorität gegeben.
1 Klasse Vater (Objekt):
2 Adresse = "Xian"
3 def __init__(selbst,Name,Alter):
4 self.name=name
5 selbst.alter=alter
6 def info(selbst):
7 print("Das ist die Methode eines Vaters")
8 Klasse Sohn (Vater):
9 def __init__(selbst,Name,Alter,Ergebnis):
10 Father.__init__(self,name,age) #Die Unterklasse erbt die Instanzattribute der Elternklasse
11 self.score=Ergebnis
12 def zeigen (selbst):
13 print("Name ist {0}, und Alter ist {1}, und Punktzahl ist {1}".format(self.name,self.age,self.score))
14 def info(self): #Methodenüberschreibung der übergeordneten Klasse
15 print("Das ist die Methode eines Sohnes")
16 Sohn = Sohn (Name = "wuya", Alter = 18, Punktzahl = 99)
17 son.show()
18 print(son.address) #Die Unterklasse erbt die Variable (Datenattribut) der Elternklasse
19 son.info() #No print, es gibt print in info(), wenn die Funktion und der Rückgabewert, die Ausgabefunktion leer ist. Wenn die Unterklasse die Methode der Oberklasse überschreibt, ruft das Objekt nach der Instanziierung der Unterklasse die Methode auf, und der Methode der Unterklasse wird Priorität eingeräumt.
Das Ergebnis der Ausführung des obigen Codes ist:
10. Erbordnung
1) Von oben nach unten (Voraussetzungen):
a) Einfache Erbschaft
b) Die Unterklasse überschreibt die Methode der Oberklasse
2) Von links nach rechts (Voraussetzung): Unterklassen erben mehrere Klassen (Unterklassen können mehrere Elternklassen erben, aber die Elternklassen müssen in einer Geschwisterbeziehung stehen.)
3) In Python wird also basierend auf den Parsing-Order-Regeln von MRO die Basisklasse von links nach rechts durchsucht. Wenn die erste passende Attributklasse gefunden wird, wird die Suche gestoppt. Wenn nicht, wird die Suche fortgesetzt, bis find das Match
solange du fragst. MRO wird tatsächlich durch einen C3-Linearisierungsalgorithmus implementiert.Seine Kernidee ist:
Unterklassen werden Prüfungen von Oberklassen übertreffen
Mehrere übergeordnete Klassen werden nacheinander entsprechend ihrer Reihenfolge in der Liste geprüft
Wenn es zwei gültige Auswahlmöglichkeiten für die nächste Klasse gibt, kann nur die erste ausgewählt werden (lineare Suche)
11. Beispiel einer Erbordnung
1 Klasse Vater (Objekt):
2 def __init__(selbst,Name,Alter):
3 self.name=name
4 selbst.alter=alter
5 def funM(selbst):
6 Druck ("Vater")
7
8. Klasse Mutter (Objekt):
9 def funM(selbst):
10 print("Mutter")
11
12 Klasse Sohn (Vater, Mutter): #Unterklasse Sohn erbt zwei Elternklassen
13 def __init__(selbst,Name,Alter,Ergebnis):
14 Father.__init__(self,name,age) #Subclass Son erbt die Instanzattribute der Elternklassen Father und Mother
15 self.score=Ergebnis
16
17 Sohn = Sohn (name = "ccj", Alter = 18, Punktzahl = 100)
18 son.funM()
19 print(Son.mro()) #Verwenden Sie den Klassennamen, um mro aufzurufen, um die Ausführungsreihenfolge der Klasse anzuzeigen
Das Ergebnis der Ausführung des obigen Codes ist:
12. Beispiel einer Unterklasse, die mehrere nicht ähnliche Elternklassen erbt
1 Klasse Person(Objekt):
2 passieren
3
4 Klasse Vater (Person):
5 def __init__(selbst):
6 passieren
7 def funM(selbst):
8 Druck ("Vater")
9 Klasse Mutter (Objekt):
10 def funM(selbst):
11 print("Mutter")
12
13 class Son(Person,Vater): #Mehrere Elternklassen, die von Unterklassen geerbt werden, sind nicht auf derselben Ebene, der Code meldet einen Fehler, z-Unterklassen können mehrere Elternklassen erben, aber die Elternklassen müssen sich in derselben Ebenenbeziehung befinden.
14 def __init__(self,score): 15 Father.__init__(self) 16 self.score=score 17 son=Son(score=90) 18 son.funM() 19 print(Son.mro())
Das Ergebnis der Ausführung des obigen Codes ist;
13. Beispiel eines Vererbungsmethodenaufruffehlers
1 Klasse Person(Objekt):
2 passieren
3
4 Klasse Vater (Person):
5 def __init__(selbst):
6 passieren
7
8. Klasse Mutter(Person):
9 def funM(selbst):
10 print("Mutter")
11
12 Klasse Sohn(Vater): #Es gibt keine funM-Methode in der Elternklasse, die von der Unterklasse geerbt wird, und der Code wird einen Fehler melden
13 def __init__(self,score):
14 Vater.__init__(selbst)
15 self.score=Ergebnis
16
17 Sohn=Sohn(Punktzahl=99)
18 son.funM()
Das Ergebnis der Ausführung des obigen Codes ist:
14. Fehlerbeispiel für geerbte Methodenaufrufkorrektur
1 Klasse Person(Objekt):
2 def funM(selbst):
3 print("Person")
4
5 Klasse Vater (Person):
6 def __init__(selbst):
7 passieren
8
9. Klasse Mutter(Person):
10 def funM(selbst):
11 print("Mutter")
12
13 Klasse Sohn(Vater): #Die Elternklasse der Vererbungsmethode der Unterklasse ist Vater
14 def __init__(self,score):
15 Vater.__init__(selbst)
16 self.score=Ergebnis
17
18 Sohn=Sohn(Punktzahl=99)
19 son.funM() #Die Unterklasse ruft die Methode auf, sucht zuerst von der Unterklasse, dann von der geerbten Oberklasse, wenn nicht gefunden, dann von der Oberklasse der Oberklasse.
20 print(Sohn.mro())
Das Ergebnis der Ausführung der obigen Methode ist:
15. Erben historischer Probleme
python2 ist die Tiefe zuerst, python3 ist die Breite zuerst
1 Klasse A:
2 def zeigen (selbst):
3 Druck('A')
4
5 Klasse B(A):
6 passieren
7
8 Klasse C(A):
9 def zeigen (selbst):
10 Druck('C')
11
12 Klasse D(B,C):
13 passieren
14
15 wenn __name__ == '__main__':
16 obj=D()
17 obj.show() #Das Ergebnis der Ausführung in python2 ist A, und das Ergebnis der Ausführung in pyhton3 ist C
16. Polymorphismus
Die Vorteile von Dota lassen sich wie folgt zusammenfassen:
Laufende Flexibilität hinzugefügt
Laufende zusätzliche Erweiterungen hinzugefügt
1 Klasse Tier(Objekt):
2 def rede(selbst):
3 print("Tiere werden bellen")
4
5 Klasse Hund (Objekt):
6 def sprechen (selbst):
7 print("Hunde bellen auch")
8
9 Klasse Katze (Objekt):
10 def sprechen (selbst):
11 print("Katzen können auch bellen")
12
13 def func(Tier):
14 tier.gespräch()
15 wenn __name__ == '__main__':
16 Hund=Hund()
17 func(Tier=Hund)
Das Ergebnis der Ausführung des obigen Codes ist:
