TOC

Grundlegendes zu Klassen- und Instanzvariablen in Python 3

Einführung

Object-oriented programming ermöglicht die Verwendung vonvariables auf Klassen- oder Instanzebene. Variables sind im Wesentlichen Symbole, die für einen Wert stehen, den Sie in einem Programm verwenden.

Auf Klassenebene werden Variablen alsclass variables bezeichnet, während Variablen auf Instanzebene alsinstance variables bezeichnet werden.

Wenn wir erwarten, dass Variablen instanzübergreifend konsistent sind oder wenn wir eine Variable initialisieren möchten, können wir diese Variable auf Klassenebene definieren. Wenn wir davon ausgehen, dass sich die Variablen in den einzelnen Instanzen erheblich ändern werden, können wir sie auf Instanzebene definieren.

Eines der Prinzipien der Softwareentwicklung ist dasDRY-Prinzip, das fürdon’t repeat yourself steht. Dieses Prinzip zielt darauf ab, die Wiederholung innerhalb des Codes zu begrenzen, und die objektorientierte Programmierung folgt dem DRY-Prinzip, da es die Redundanz verringert.

In diesem Lernprogramm wird die Verwendung von Klassen- und Instanzvariablen bei der objektorientierten Programmierung in Python veranschaulicht.

Klassenvariablen

Klassenvariablen werden innerhalb vonclass construction definiert. Da sie der Klasse selbst gehören, werden Klassenvariablen von allen Instanzen der Klasse gemeinsam genutzt. Sie haben daher im Allgemeinen für jede Instanz den gleichen Wert, es sei denn, Sie verwenden die Klassenvariable zum Initialisieren einer Variablen.

Außerhalb aller Methoden definiert, werden Klassenvariablen üblicherweise direkt unter dem Klassenkopf und vor denconstructor method und anderen Methoden platziert.

Eine Klassenvariable sieht alleine so aus: 

class Shark:
    animal_type = "fish"

Hier wird der Variablenanimal_type der Wert"fish" zugewiesen.

Wir können eine Instanz der KlasseSharkerstellen (wir nennen sienew_shark) und die Variable mithilfe der Punktnotation drucken:

shark.py

class Shark:
    animal_type = "fish"

new_shark = Shark()
print(new_shark.animal_type)

Führen wir das Programm aus: 

python shark.py
Outputfish

Unser Programm gibt den Wert der Variablen zurück.

Fügen wir ein paar weitere Klassenvariablen hinzu und drucken sie aus:

shark.py

class Shark:
    animal_type = "fish"
    location = "ocean"
    followers = 5

new_shark = Shark()
print(new_shark.animal_type)
print(new_shark.location)
print(new_shark.followers)

Wie bei jeder anderen Variablen können Klassenvariablen aus beliebigendata typebestehen, die uns in Python zur Verfügung stehen. In diesem Programm haben wir Strings und eine ganze Zahl. Führen Sie das Programm erneut mit dem Befehlpython shark.py aus und sehen Sie sich die Ausgabe an: 

Outputfish
ocean
5

Die Instanz vonnew_shark kann auf alle Klassenvariablen zugreifen und diese ausdrucken, wenn wir das Programm ausführen.

Klassenvariablen ermöglichen es uns, Variablen beim Erstellen der Klasse zu definieren. Diese Variablen und ihre zugehörigen Werte sind dann für jede Instanz der Klasse zugänglich.

Instanzvariablen

Instanzvariablen gehören Instanzen der Klasse. Dies bedeutet, dass die Instanzvariablen für jedes Objekt oder jede Instanz einer Klasse unterschiedlich sind.

Im Gegensatz zu Klassenvariablen werden Instanzvariablen in Methoden definiert.

Im folgenden Klassenbeispiel fürShark sindname undage Instanzvariablen: 

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Wenn wir einShark-Objekt erstellen, müssen wir diese Variablen definieren, die als Parameter innerhalb der Konstruktormethode oder einer anderen Methode übergeben werden. 

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)

Wie bei Klassenvariablen können wir auch beim Drucken von Instanzvariablen Folgendes aufrufen:

shark.py

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)
print(new_shark.name)
print(new_shark.age)

Wenn wir das obige Programm mitpython shark.py ausführen, erhalten wir die folgende Ausgabe: 

OutputSammy
5

Die Ausgabe, die wir erhalten, besteht aus den Werten der Variablen, die wir für die Objektinstanz vonnew_shark initialisiert haben.

Erstellen wir ein weiteres Objekt derShark-Klasse mit dem Namenstevie:

shark.py

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)
print(new_shark.name)
print(new_shark.age)

stevie = Shark("Stevie", 8)
print(stevie.name)
print(stevie.age)

Das Objektstevie übergibt wie das Objektnew_sharkdie für diese Instanz der KlasseSharkpezifischen Parameter, um den Instanzvariablen Werte zuzuweisen.

Instanzvariablen, deren Eigentümer Objekte der Klasse sind, ermöglichen es jedem Objekt oder jeder Instanz, diesen Variablen unterschiedliche Werte zuzuweisen.

Gemeinsam mit Klassen- und Instanzvariablen arbeiten

Klassenvariablen und Instanzvariablen werden häufig gleichzeitig verwendet. Schauen wir uns also ein Beispiel dafür mit der von uns erstellten KlasseSharkan. Die Kommentare im Programm beschreiben jeden Schritt des Prozesses.

shark.py

class Shark:

    # Class variables
    animal_type = "fish"
    location = "ocean"

    # Constructor method with instance variables name and age
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Method with instance variable followers
    def set_followers(self, followers):
        print("This user has " + str(followers) + " followers")


def main():
    # First object, set up instance variables of constructor method
    sammy = Shark("Sammy", 5)

    # Print out instance variable name
    print(sammy.name)

    # Print out class variable location
    print(sammy.location)

    # Second object
    stevie = Shark("Stevie", 8)

    # Print out instance variable name
    print(stevie.name)

    # Use set_followers method and pass followers instance variable
    stevie.set_followers(77)

    # Print out class variable animal_type
    print(stevie.animal_type)

if __name__ == "__main__":
    main()

Wenn wir das Programm mitpython shark.py ausführen, erhalten wir die folgende Ausgabe: 

OutputSammy
ocean
Stevie
This user has 77 followers
fish

Hier haben wir sowohl Klassen- als auch Instanzvariablen in zwei Objekten der KlasseShark verwendet,sammy undstevie.

Fazit

In der objektorientierten Programmierung werden Variablen auf Klassenebene als Klassenvariablen bezeichnet, während Variablen auf Objektebene als Instanzvariablen bezeichnet werden.

Diese Unterscheidung ermöglicht es uns, Klassenvariablen zu verwenden, um Objekte mit einem bestimmten Wert zu initialisieren, der Variablen zugewiesen ist, und für jedes Objekt mit Instanzvariablen unterschiedliche Variablen zu verwenden.

Durch die Verwendung von klassen- und instanzspezifischen Variablen kann sichergestellt werden, dass unser Code dem DRY-Prinzip entspricht, um Wiederholungen im Code zu reduzieren.

Related