Verstehen von Klassen- und Instanzvariablen in Python 3

Einführung

Objektorientierte Programmierung ermöglicht es, Variablen auf Klassenebene oder Instanzebene zu verwenden. Variablen sind im Grunde genommen Symbole, die für einen Wert stehen, den Sie in einem Programm verwenden.

Auf Klassenebene werden Variablen als Klassenvariablen bezeichnet, während Variablen auf Instanzebene als Instanzvariablen bezeichnet werden.

Wenn wir erwarten, dass Variablen in verschiedenen Instanzen konsistent sind, oder wenn wir eine Variable initialisieren möchten, können wir diese auf Klassenebene definieren. Wenn wir voraussehen, dass sich die Variablen in verschiedenen Instanzen erheblich ändern, können wir sie auf Instanzebene definieren.

Eines der Prinzipien der Softwareentwicklung ist das DRY-Prinzip, das für don’t repeat yourself steht. Dieses Prinzip zielt darauf ab, Wiederholungen im Code zu begrenzen, und die objektorientierte Programmierung hält sich an das DRY-Prinzip, da es Redundanz verringert.

Dieses Tutorial wird die Verwendung von sowohl Klassen- als auch Instanzvariablen in der objektorientierten Programmierung in Python demonstrieren.

Voraussetzungen

Sie sollten Python 3 installiert und eine Programmierumgebung auf Ihrem Computer oder Server eingerichtet haben. Wenn Sie keine Programmierumgebung eingerichtet haben, können Sie auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server verweisen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Klassenvariablen

Klassenvariablen werden innerhalb der Klassendefinition definiert. Da sie der Klasse selbst gehören, werden Klassenvariablen von allen Instanzen der Klasse geteilt. Sie haben daher im Allgemeinen den gleichen Wert für jede Instanz, es sei denn, Sie verwenden die Klassenvariable, um eine Variable zu initialisieren.

Außerhalb aller Methoden definiert, werden Klassenvariablen aus Konvention typischerweise direkt unter der Klassenüberschrift und vor der Konstruktormethode und anderen Methoden platziert.

Eine Klassenvariable sieht alleine folgendermaßen aus:

class Shark:
    animal_type = "fish"

Hier wird der Variable animal_type der Wert "Fisch" zugewiesen.

Wir können eine Instanz der Shark-Klasse erstellen (wir nennen sie new_shark) und die Variable mithilfe der Punktnotation ausgeben:

class Shark:
    animal_type = "fish"

new_shark = Shark()
print(new_shark.animal_type)

Lass uns das Programm ausführen:

python shark.py

fish

Unser Programm gibt den Wert der Variablen zurück.

Lass uns ein paar weitere Klassenvariablen hinzufügen und sie ausgeben:

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)

Genau wie bei jeder anderen Variablen können Klassenvariablen aus jedem in Python verfügbaren Datentyp bestehen. In diesem Programm haben wir Zeichenfolgen und eine Ganzzahl. Lassen Sie uns das Programm erneut mit dem Befehl python shark.py ausführen und die Ausgabe überprüfen:

fish
ocean
5

Die Instanz von new_shark kann auf alle Klassenvariablen zugreifen und sie ausgeben, 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 zu den Instanzen der Klasse. Das bedeutet, dass die Instanzvariablen für jedes Objekt oder jede Instanz einer Klasse unterschiedlich sind.

Im Gegensatz zu Klassenvariablen werden Instanzvariablen innerhalb von Methoden definiert.

Im Beispiel der Shark-Klasse unten sind name und age Instanzvariablen:

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

Wenn wir ein Shark-Objekt erstellen, müssen wir diese Variablen definieren, die als Parameter im Konstruktor 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 Instanzvariablen auf ähnliche Weise ausdrucken:

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 oben stehende Programm mit python shark.py ausführen, erhalten wir die folgende Ausgabe:

Sammy
5

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

Lass uns ein weiteres Objekt der Shark-Klasse namens stevie erstellen:

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)

Sammy
5
Stevie
8

Das stevie Objekt übergibt, ähnlich dem new_shark Objekt, die spezifischen Parameter für diese Instanz der Shark Klasse, um Werte den Instanzvariablen zuzuweisen.

Instanzvariablen, die von Objekten der Klasse besessen werden, ermöglichen es jedem Objekt oder jeder Instanz, unterschiedliche Werte für diese Variablen zuzuweisen.

Arbeiten mit Klassen- und Instanzvariablen zusammen

Klassenvariablen und Instanzvariablen werden oft gleichzeitig verwendet, also schauen wir uns ein Beispiel dafür an, das die Shark-Klasse, die wir erstellt haben, nutzt. Die Kommentare im Programm umreißen jeden Schritt des Prozesses.

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 mit python shark.py ausführen, erhalten wir die folgende Ausgabe:

Sammy
ocean
Stevie
This user has 77 followers
fish

Hier haben wir sowohl Klassen- als auch Instanzvariablen in zwei Objekten der Shark-Klasse, sammy und stevie, verwendet.

Schlussfolgerung

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

Diese Differenzierung ermöglicht es uns, Klassenvariablen zu verwenden, um Objekte mit einem spezifischen Wert für die Variablen zu initialisieren, und unterschiedliche Variablen für jedes Objekt mit Instanzvariablen zu verwenden.

Die Verwendung von klassen- und instanzspezifischen Variablen kann sicherstellen, dass unser Code dem DRY-Prinzip folgt, um Wiederholungen im Code zu reduzieren.