Objektorientierte Python-Klassen und Beispiele

Der Inhalt, der in diesem Artikel mit Ihnen geteilt wird, handelt von objektorientierten Python-Klassen und Beispielen, die einen gewissen Referenzwert haben. Freunde in Not können sich auf

Klassen und Instanzen

Die wichtigsten objektorientierten Konzepte sind Klassen und Instanzen. Es muss beachtet werden, dass Klassen abstrakte Vorlagen sind, wie z. B. die Student-Klasse, während Instanzen spezifische Objekte sind, die auf der Klasse Object basieren. Jedes Objekt verfügt über dieselben Methoden, ihre Daten können jedoch unterschiedlich sein.

Nehmen Sie immer noch die Student-Klasse als Beispiel. In Python erfolgt die Definition einer Klasse über das Klassenschlüsselwort:

class Student(object):
   pass

auf class folgt der Klassenname, nämlich Student Die Klasse Der Name lautet normalerweise: Wörter, die mit einem Großbuchstaben beginnen, gefolgt von (Objekt), geben an, von welcher Klasse die Klasse geerbt wird. Wenn es keine geeignete Vererbungsklasse gibt, wird normalerweise die Objektklasse verwendet . Dies sind alle Klassen, die letztendlich vererbt werden.

Nachdem Sie die Student-Klasse definiert haben, können Sie eine Instanz von Student basierend auf der Student-Klasse erstellen. Das Erstellen einer Instanz erfolgt über den Klassennamen + ():

class Student(object):
   pass

bart = Student()
print(bart)
print(Student)

<__main__.Student object at 0x000001A9412A47B8>
<class &#39;__main__.Student&#39;>

Sie können sehen, dass die Variable bart auf eine Instanz von Student verweist und die folgende

0x000001A9412A47B8 die Speicheradresse ist. Die Adresse jedes Objekts ist unterschiedlich und Student selbst ist eine Klasse.

Sie können Attribute frei an eine Instanzvariable binden. Binden Sie beispielsweise ein Namensattribut an die Instanzbart:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s:%s'%(self.name,self.score))

bart = Student('Boyuan Zhou',100)
lisa = Student('Maomao',100)
bart.name= 'jeff'
print(bart.name)

jeff

Weil Klassen können als Vorlagen dienen, sodass wir beim Erstellen einer Instanz das Ausfüllen einiger Attribute erzwingen können, von denen wir glauben, dass sie gebunden werden müssen. Durch die Definition einer speziellen __init__-Methode werden beim Erstellen einer Instanz der Name, die Punktzahl und andere Attribute daran gebunden:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score

Beachten Sie, dass der erste Parameter der __init__-Methode immer self ist und die erstellte Instanz darstellt Daher können Sie innerhalb der __init__-Methode verschiedene Attribute an self binden, da self auf die erstellte Instanz selbst verweist.

Mit der __init__-Methode können Sie beim Erstellen einer Instanz keine leeren Parameter übergeben. Sie müssen Parameter übergeben, die mit der __init__-Methode übereinstimmen, aber self muss nicht übergeben werden. Die Instanzvariable wird übergeben:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s:%s'%(self.name,self.score))

bart = Student('Boyuan Zhou',100)
lisa = Student('Maomao',100)
bart.name= 'jeff'
print(bart.name)
print(bart.score)

jeff
100

Im Vergleich zu gewöhnlichen Funktionen weist die in der Klasse definierte Funktion nur einen Unterschied auf, dh der erste Parameter ist immer die Instanzvariable self und der Aufruf von When , muss dieser Parameter nicht übergeben werden. Davon abgesehen unterscheiden sich Klassenmethoden nicht von gewöhnlichen Funktionen, sodass Sie weiterhin Standardparameter, variable Parameter, Schlüsselwortparameter und benannte Schlüsselwortparameter verwenden können.

Datenkapselung

Ein wichtiges Merkmal der objektorientierten Programmierung ist die Datenkapselung. In der Student-Klasse oben hat jede Instanz ihren eigenen Namen und ihre eigenen Bewertungsdaten. Wir können auf diese Daten über Funktionen zugreifen, z. B. über das Drucken der Punktzahl eines Schülers.

>>> std1 = {'name':'jeff','score':100}
>>> std2 = {'name':'xin','score':0}
>>> def print_score(std):
...     print('%s:%s'%(std['name'],std['score']))
...
>>> print_score(std1)
jeff:100
>>> print_score(std2)
xin:0

Da jedoch die Schülerinstanz selbst Eigentümer dieser Daten ist, besteht keine Notwendigkeit, über externe Funktionen auf diese Daten zuzugreifen. Sie können sie direkt definieren Funktionen für den Zugriff auf Daten innerhalb der Student-Klasse, wodurch die „Daten“ gekapselt werden. Diese Funktionen, die Daten kapseln, sind mit der Student-Klasse selbst verknüpft. Wir nennen sie Methoden der Klasse:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s:%s'%(self.name,self.score))

Um eine Methode zu definieren, ist der erste Parameter self, die anderen sind die gleichen wie gewöhnlich Funktionen gleich. Um eine Methode aufzurufen, müssen Sie sie nur direkt für die Instanzvariable aufrufen. Außer self müssen Sie sie nicht übergeben. Andere Parameter werden normalerweise übergeben:

bart.print_score()
jeff:100

Auf diese Weise, wenn Wenn wir die Student-Klasse von außen betrachten, müssen wir nur wissen: Um eine Instanz zu erstellen, müssen Sie den Namen und die Punktzahl angeben, und wie gedruckt wird, wird intern von der Student-Klasse definiert. Diese Daten und Logik sind „gekapselt“. und sind einfach aufzurufen, Sie müssen jedoch nicht die Details der internen Implementierung kennen. Ein weiterer Vorteil der

-Kapselung besteht darin, dass Sie der Student-Klasse neue Methoden hinzufügen können, z. B. get_grade:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s:%s'%(self.name,self.score))
    def get_grade(self):
        if self.score >=90:
            return 'A'
        elif self.score>=600:
            return  'B'
        else:
            return  'C'
bart = Student('Boyuan Zhou',100)
lisa = Student('Maomao',100)
bart.name= 'jeff'
bart.print_score()

print(bart.get_grade())

jeff:100
A

Verwandte Empfehlungen:

Über Python Erste Erkundung des objektorientierten Beispielcodes

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