Python objektorientiert

Python war von Anfang an eine objektorientierte Sprache. Aus diesem Grund ist es einfach, Klassen und Objekte in Python zu erstellen. In diesem Kapitel stellen wir die objektorientierte Programmierung in Python ausführlich vor.

Wenn Sie noch nie mit objektorientierten Programmiersprachen in Berührung gekommen sind, müssen Sie möglicherweise zunächst einige Grundfunktionen objektorientierter Sprachen verstehen und sich ein grundlegendes objektorientiertes Konzept ausdenken. Dies wird Ihnen helfen, die objektorientierte Programmierung in Python ganz einfach zu erlernen.

Als nächstes wollen wir kurz einige grundlegende Merkmale der Objektorientierung verstehen.

Einführung in die objektorientierte Technologie

Klasse: wird verwendet, um eine Sammlung von Objekten mit denselben Eigenschaften und Methoden zu beschreiben. Es definiert die Eigenschaften und Methoden, die jedem Objekt in der Sammlung gemeinsam sind. Objekte sind Instanzen von Klassen.

Klassenvariablen: Klassenvariablen sind im gesamten instanziierten Objekt öffentlich. Klassenvariablen werden in der Klasse und außerhalb des Funktionskörpers definiert. Klassenvariablen werden im Allgemeinen nicht als Instanzvariablen verwendet.

Datenmitglieder: Klassenvariablen oder Instanzvariablen werden verwendet, um Daten zu verarbeiten, die sich auf Klassen und ihre Instanzobjekte beziehen.

Methodenüberladung: Wenn die von der übergeordneten Klasse geerbte Methode die Anforderungen der Unterklasse nicht erfüllen kann, kann sie neu geschrieben werden. Dieser Vorgang wird als Methodenüberschreibung oder Methodenüberladung bezeichnet.

Instanzvariablen: In Methoden definierte Variablen wirken sich nur auf die Klasse der aktuellen Instanz aus.

Vererbung: Eine abgeleitete Klasse erbt die Felder und Methoden einer Basisklasse. Durch Vererbung kann ein Objekt einer abgeleiteten Klasse auch als Basisklassenobjekt behandelt werden. Es gibt beispielsweise ein solches Design: Ein Objekt vom Typ Hund wird von der Klasse „Animal“ abgeleitet, die die „ist-ein“-Beziehung simuliert (z. B. „Hund ist ein Tier“).

Instantiierung: Erstellen Sie eine Instanz einer Klasse, ein bestimmtes Objekt der Klasse.

Methode: In der Klasse definierte Funktion.

Objekt: Eine Instanz einer durch eine Klasse definierten Datenstruktur. Zu den Objekten gehören zwei Datenelemente (Klassenvariablen und Instanzvariablen) und Methoden.

Erstellen Sie eine Klasse

Verwenden Sie die Klassenanweisung, um eine neue Klasse zu erstellen. Nach „Klasse“ steht der Name der Klasse und endet mit einem Doppelpunkt, wie im folgenden Beispiel:

Klasse Klassenname:

'Optionale Klassendokumentationszeichenfolge'#Klassendokumentationszeichenfolge

class_suite #Klassenkörper

Die Hilfeinformationen der Klasse können über ClassName.__doc__ angezeigt werden.

class_suite besteht aus Klassenmitgliedern, Methoden und Datenattributen.

Beispiel

Das Folgende ist ein einfaches Python-Klassenbeispiel:

Klasse Employee:

' Gemeinsame Basisklasse für alle Mitarbeiter

empCount = 0

def __init__(self, name, Salary):

self.name = name

self.salary = Gehalt

Employee.empCount = 1

def displayCount(self):

print „Total Employee % d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

Die empCount-Variable ist eine Klassenvariable und ihr Wert wird von allen Instanzen dieser Klasse gemeinsam genutzt. Sie können darauf zugreifen, indem Sie Employee.empCount in der inneren oder äußeren Klasse verwenden.

Die erste Methode __init__() ist eine spezielle Methode, die als Konstruktor oder Initialisierungsmethode der Klasse bezeichnet wird. Diese Methode wird aufgerufen, wenn eine Instanz dieser Klasse erstellt wird.

Erstellen von Instanzobjekten

Um eine Instanz einer Klasse zu erstellen, verwenden Sie den Namen der Klasse und akzeptieren Parameter über die Methode __init__.

"Dies würde das erste Objekt der Employee-Klasse erstellen"

emp1 = Employee("Zara", 2000)

„Dies würde ein zweites Objekt der Employee-Klasse erstellen“

emp2 = Employee("Manni", 5000)

Zugriffsattribut

Sie können den Punkt (.) verwenden, um auf die Eigenschaften eines Objekts zuzugreifen. Greifen Sie mit dem Klassennamen wie folgt auf die Klassenvariable zu:

emp1.displayEmployee()

emp2.displayEmployee()

print „Total Employee %d“ % Employee.empCount

Vollständiges Beispiel:

# !/usr/bin/python

class Employee:

'Gemeinsame Basisklasse für alle Mitarbeiter'

empCount = 0

def __init__(selbst, Name, Gehalt):

self.name = Name

self.salary = Gehalt

Employee.empCount = 1

def displayCount(self):

print „Total Employee %d“ % Employee.empCount

def displayEmployee(self):

print „Name : „, self.name, „, Gehalt: ", self.salary

"Dies würde das erste Objekt der Employee-Klasse erstellen"

emp1 = Employee("Zara", 2000)

"Dies würde ein zweites Objekt der Employee-Klasse erstellen"

emp2 = Employee("Manni", 5000)

emp1.displayEmployee()

emp2.displayEmployee()

print „Total Employee %d“ % Employee.empCount

Das Ausgabeergebnis der Ausführung des obigen Codes lautet wie folgt:

Name: Zara, Gehalt: 2000

Name: Manni, Gehalt: 5000

Angestellte insgesamt 2

Sie können die Attribute der Klasse wie folgt hinzufügen, löschen und ändern:

emp1.age = 7 # Ein „Alter“-Attribut hinzufügen

emp1.age = 8 # Das „Alter“-Attribut ändern

del emp1.age # Das „Alter“-Attribut löschen

Sie können auch die folgenden Funktionen verwenden, um auf Attribute zuzugreifen:

getattr(obj, name[, default]): Greifen Sie auf die Attribute des Objekts zu.

hasattr(obj,name) : Überprüfen Sie, ob ein Attribut vorhanden ist.

setattr(obj,name,value): Setzt ein Attribut. Wenn die Eigenschaft nicht vorhanden ist, wird eine neue Eigenschaft erstellt.

delattr(obj, name): Attribute löschen.

hasattr(emp1, 'age') # Gibt True zurück, wenn das Attribut „age“ vorhanden ist.

getattr(emp1, 'age') #Gibt den Wert des Attributs 'age' zurück

setattr(emp1, 'age', 8) #Füge das Attribut 'age' mit einem Wert hinzu von 8

delattr(empl, 'age') #Delete attribute 'age'

In Python integriertes Klassenattribut

__dict__: Klassenattribut (Enthält ein Wörterbuch bestehend aus den Datenattributen der Klasse)

__doc__: die Dokumentationszeichenfolge der Klasse

__name__: der Klassenname

__module__: das Modul, in dem die Klasse definiert ist (der vollständige Name der Klasse lautet „__main__.className“. Wenn sich die Klasse in einem importierten Modul mymod befindet, ist className.__module__ gleich mymod)

__bases__: Alle übergeordneten Klassen der Klasse stellen Elemente dar (einschließlich aller übergeordneten Klassen, aus denen ein Tupel besteht)

Das Beispiel für den Aufruf integrierter Python-Klassenattribute lautet wie folgt:

#!/usr/bin/python

class Employee:

'Gemeinsame Basisklasse für alle Mitarbeiter'

empCount = 0

def __init__(selbst, Name, Gehalt):

self.name = Name

self.salary = Gehalt

Employee.empCount = 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

print "Employee .__doc__:", Employee.__doc__

print "Employee.__name__ :", Employee.__name__

print "Employee.__module__:", Employee.__module__

print " Employee.__bases__:“, Employee.__bases__

print „Employee. __dict__:“, Employee.__dict__

Das Ausgabeergebnis der Ausführung Der obige Code lautet wie folgt:

Employee.__doc__: Gemeinsame Basisklasse für alle Mitarbeiter

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount':

, 'empCount': 2,

'displayEmployee': ,

'__doc__': 'Gemeinsame Basisklasse für alle Mitarbeiter',

'__init__': }

Python-Objektzerstörung (Garbage Collection)

Wie Java Python verwendet eine einfache Technologie namens Referenzzählung, um Objekte im Speicher zu verfolgen.

Intern zeichnet Python auf, wie viele Referenzen jedes verwendete Objekt hat.

Eine interne Tracking-Variable, Referenzzähler genannt.

Wenn ein Objekt erstellt wird, wird ein Referenzzähler erstellt. Wenn das Objekt nicht mehr benötigt wird, dh wenn der Referenzzähler des Objekts 0 wird, wird es durch Müll gesammelt. Das Recycling erfolgt jedoch nicht „sofort“. Der Interpreter wird den von Müllobjekten belegten Speicherplatz zum richtigen Zeitpunkt recyceln.

a = 40 # Objekt erstellen <40>

b = a # Referenz erhöhen, Anzahl von <40>

c = [b] # Erhöhen Sie die Anzahl der Referenzen

del a # Verringern Sie die Anzahl der Referenzen

b = 100 # Reduzieren Sie die Anzahl der Referenzen

c[0] = -1 # Reduzieren Sie die Anzahl der Referenzen

Garbage Der Recyclingmechanismus zielt nicht nur auf Objekte mit einem Referenzzähler von 0 ab, sondern kann auch Zirkelverweise verarbeiten. Ein Zirkelverweis liegt vor, wenn zwei Objekte aufeinander verweisen, aber keine andere Variable auf sie verweist. In diesem Fall reicht die Referenzzählung allein nicht aus. Der Garbage Collector von Python ist eigentlich ein Referenzzähler und ein zyklischer Garbage Collector. Zusätzlich zur Referenzzählung untersucht der Garbage Collector auch Objekte, denen eine große Menge zugewiesen wurde (und solche, die nicht durch Referenzzählung zerstört wurden). In diesem Fall hält der Interpreter an und versucht, alle nicht referenzierten Schleifen zu bereinigen.

Instanz

Destruktor __del__, __del__ wird aufgerufen, wenn das Objekt nicht mehr verwendet wird, wird die __del__-Methode ausgeführt:

#!/usr/bin/python

class Point:

def __init( self, x=0, y= 0):

self.x = x

self.y = y

def __del__(self):

class_name = self.__class__.__name__

print class_name, „destruyed“

pt1 = Point()

pt2 = pt1

pt3 = pt1

print id (pt1), id(pt2), id(pt3) # Gibt die ID des Objekts aus

del pt1

del pt2

del pt3

 
Punkt zerstört
 
Hinweis: Normalerweise müssen Sie eine Klasse in einer separaten Datei definieren , 
Vererbung von Klassen
Einer der Hauptvorteile der objektorientierten Programmierung ist die Wiederverwendung von Code, und eine Möglichkeit, diese Wiederverwendung zu erreichen, ist der Vererbungsmechanismus. Vererbung kann vollständig als Typ- und Subtypbeziehung zwischen Klassen verstanden werden. 
 Zu beachten: Vererbungssyntax, abgeleiteter Klassenname (Basisklassenname): //... Der Basisklassenname wird in Klammern geschrieben. Die Basisklasse wird im Tupel angegeben, wenn die Klasse definiert wird. von. 
Einige Merkmale der Vererbung in Python: 
1: Bei der Vererbung wird die Konstruktion der Basisklasse (__init__()-Methode) nicht automatisch aufgerufen, sie muss in der Konstruktion von enthalten sein seine abgeleitete Klasse wird persönlich genannt. 
2: Wenn Sie die Methode der Basisklasse aufrufen, müssen Sie das Klassennamenpräfix der Basisklasse hinzufügen und die Parametervariable self mitbringen. Anders als beim Aufrufen gewöhnlicher Funktionen in einer Klasse müssen Sie den Parameter self nicht mitbringen 
3: Python sucht immer zuerst nach der Methode des entsprechenden Typs. Wenn die entsprechende Methode in der abgeleiteten Klasse nicht gefunden werden kann, Es beginnt nacheinander mit der Suche in der Basisklasse. (Suchen Sie zuerst in dieser Klasse nach der aufrufenden Methode und dann in der Basisklasse danach, wenn Sie sie nicht finden können.) 
Wenn mehr als eine Klasse im Vererbungstupel aufgeführt ist, spricht man von „Mehrfachvererbung“. 
 Syntax: 
Deklaration abgeleiteter Klassen, ähnlich ihren übergeordneten Klassen, mit einer Liste geerbter Basisklassen nach dem Klassennamen, wie folgt: 
 
class SubClassName (ParentClass1[, ParentClass2, ...]):
 'Optionale Klassendokumentationszeichenfolge'
 class_suite
 
 
Instanz: 
#!/usr/bin/python
 
 Klasse Übergeordnet:           # übergeordnete Klasse definieren
   parentAttr = 100
   def __init__(self):
                                                                        verwendend verwendend verwendend verwendend           durchgehend aus verwendend aus aus aus ‐      ‐    ‐ ‐‐‐ unter, 🎜> def parentMethod(self):
 print 'Calling parent method'
 
 def setAttr(self, attr):
 Parent. parentAttr = attr
 
 def getAttr(self):
 print „Parent attribute:“, Parent.parentAttr
 
class Child(Parent): # untergeordnete Klasse definieren
 def __init__(self):
 print „Calling Child Constructor“
 
 def childMethod(self):
 print 'Calling child method'
 
c = Child() # Unterklasse instanziieren 
c.childMethod() # Aufruf die Unterklassenmethode 
c.parentMethod() # Rufen Sie die übergeordnete Klassenmethode auf 
c.setAttr(200) # Rufen Sie die übergeordnete Klassenmethode erneut auf 
c.getAttr () # Rufen Sie die Methode der übergeordneten Klasse erneut auf 
 >Untergeordneten Konstruktor aufrufen
Untergeordnete Methode aufrufen
Übergeordnete Methode aufrufen
Übergeordnetes Attribut: 200
 
 
 Sie können von mehreren Klassen erben 
Klasse A:           # Definieren Sie Ihre Klasse A
 
....
 
Klasse B:        # Definieren Sie Ihre Klassen B
.....
 
 Klasse C(A, B):    # Unterklasse von A und B 
....
 
Sie können issubclass() oder verwenden isinstance()-Methode zum Erkennen. 
issubclass() – Boolesche Funktion, um zu bestimmen, ob eine Klasse eine Unterklasse oder ein Nachkomme einer anderen Klasse ist, Syntax: issubclass(sub,sup)
isinstance(obj, Class) Boolesche Funktion, wenn obj Gibt true zurück, wenn es sich um ein Instanzobjekt der Class-Klasse oder ein Instanzobjekt einer Class-Unterklasse handelt. 
Überladene Methoden
Wenn die Funktion Ihrer übergeordneten Klassenmethode Ihre Anforderungen nicht erfüllen kann, können Sie die Methode Ihrer übergeordneten Klasse in der Unterklasse überladen: 
Beispiel: 
#!/usr/bin/python
 
class Parent:                                                                                                            > def myMethod(self):
 print 'Calling parent method'
 
class Child(Parent): # Subclass definieren 
 def myMethod( self):
 print 'Calling child method'
 
c = Child() # Subclass-Instanz 
c.myMethod() # Subclass Rufen Sie die überladene Methode auf 
 
Das Ausgabeergebnis der Ausführung des obigen Codes lautet wie folgt: 
Untergeordnete Methode aufrufen 
 
 
Grundlegende überladene Methoden 
Die folgende Tabelle listet einige allgemeine Funktionen auf, die Sie in Ihrer eigenen Klasse überschreiben können: 
 
Seriennummer
Methode, Beschreibung und einfacher Aufruf
1 __init__ ( self [,args...] )
 Konstruktor
Einfache Aufrufmethode: obj = className(args ) 
2 __del__(self)
Destruktormethode, Objekt löschen
Einfache Aufrufmethode: dell obj 
 
3 __repr__( self )
 wird in ein Formular für umgewandelt der zu lesende Interpreter 
 Einfache Aufrufmethode: repr(obj) 
4 __str__( self )
 wird verwendet, um den Wert umzuwandeln. In für Menschen lesbare Form umwandeln
Einfache Aufrufmethode: str( obj) 
5 __cmp__ (self, x)
Objektvergleich
Einfache Aufrufmethode: cmp(obj, x) 
Operatorüberladung

Python unterstützt auch Operatorüberladung, Beispiele sind wie folgt: 


#!/usr/bin/ python

 
class Vector:
 def __init__(self, a, b):
 self.a = a
 self .b = b
 
 def __str__(self):
 return 'Vector (%d, %d)' % (self.a, self.b)
 
 def __add__(self,other ):
 return Vector(self.a other.a, self.b other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 v2
 
Das Ausführungsergebnis des obigen Codes ist wie folgt:
Vector(7,8)
 
Daten ausblenden
Das ist es Es ist sehr einfach, das Ausblenden von Daten in Python zu implementieren. Es ist nicht erforderlich, vor dem Klassenvariablennamen oder der Mitgliedsfunktion zwei Unterstriche hinzuzufügen Bei einer Instanz einer Klasse können ihr Variablenname und ihre Mitgliedsfunktion nicht verwendet werden, und für ihre geerbte Klasse ist sie ebenfalls ausgeblendet. Auf diese Weise kann ihre geerbte Klasse ihren genauen Variablennamen oder Mitgliedsfunktionsnamen definieren, ohne dass es zu Namenskonflikten kommt. Beispiel: 
#!/usr/bin/python
 
class JustCounter:
 __secretCount = 0
 
 def count( self):
 self.__secretCount = 1
 print self.__secretCount
 
counter = JustCounter()
counter.count ()
counter.count()
print counter.__secretCount
 
Python ändert den Namen, um den Klassennamen einzuschließen : 
1
2
Traceback (letzter Anruf zuletzt):
 Datei „test .py", Zeile 12, in 
 print counter.__secretCount
AttributeError: JustCounter-Instanz hat kein Attribut '__secretCount'
 
 
Python erlaubt instanziierten Klassen nicht, auf versteckte Daten zuzugreifen, aber Sie können object._className__attrName verwenden, um auf Attribute zuzugreifen. Ersetzen Sie die letzte Zeile des obigen Codes durch den folgenden Code: 
 

........................
Zähler drucken._JustCounter__secretCount
 

Führen Sie den obigen Code aus. Das Ausführungsergebnis ist wie folgt:

1
2
2