Wie man prüft, ob eine Klasse in Python ein bestimmtes Attribut hat

Einführung

In diesem Lab lernen Sie, wie Sie in Python prüfen können, ob eine Klasse ein bestimmtes Attribut hat. Das Lab konzentriert sich darauf, Klassenattribute zu verstehen, die Variablen sind, die von allen Instanzen einer Klasse geteilt werden, und sie von Instanzattributen zu unterscheiden.

Das Lab führt Sie durch die Erstellung einer Dog-Klasse mit einem Klassenattribut species und Instanzattributen name und age. Sie lernen, beide Arten von Attributen zuzugreifen und zu beobachten, wie die Änderung eines Klassenattributs alle Instanzen beeinflusst. Anschließend werden die Funktionen hasattr() und getattr() eingeführt und genutzt, um sicher auf Attribute innerhalb einer Klasse zu prüfen und zuzugreifen.

Klassenattribute verstehen

In diesem Schritt lernen Sie über Klassenattribute in Python. Klassenattribute sind Variablen, die innerhalb einer Klasse definiert werden und von allen Instanzen (Objekten) dieser Klasse geteilt werden. Sie unterscheiden sich von Instanzattributen, die für jede Instanz spezifisch sind. Das Verständnis von Klassenattributen ist entscheidend für das Design effizienter und organisierter Klassen.

Beginnen wir mit der Erstellung einer einfachen Klasse mit einem Klassenattribut:

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei namens class_attributes.py im Verzeichnis ~/project.
```
~/project/class_attributes.py
```

Fügen Sie den folgenden Code zur Datei class_attributes.py hinzu:

class Dog:
    species = "Canis familiaris"

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

## Creating instances of the Dog class
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

## Accessing the class attribute
print(dog1.species)
print(dog2.species)

## Accessing instance attributes
print(dog1.name)
print(dog2.name)

In diesem Beispiel ist species ein Klassenattribut, da es innerhalb der Dog-Klasse, aber außerhalb jeder Methode definiert ist. name und age sind Instanzattribute, da sie innerhalb der __init__-Methode definiert werden und für jede Dog-Instanz spezifisch sind.

Führen Sie das Skript class_attributes.py mit dem folgenden Befehl im Terminal aus:
```
python class_attributes.py
```
Sie sollten die folgende Ausgabe sehen:
```
Canis familiaris
Canis familiaris
Buddy
Lucy
```
Wie Sie sehen können, teilen sich sowohl dog1 als auch dog2 denselben species-Wert, nämlich "Canis familiaris". Sie haben jedoch unterschiedliche name-Werte, da name ein Instanzattribut ist.

Jetzt ändern wir das Klassenattribut und sehen, wie sich dies auf die Instanzen auswirkt:

class Dog:
    species = "Canis familiaris"

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

## Creating instances of the Dog class
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

## Accessing the class attribute
print(dog1.species)
print(dog2.species)

## Modifying the class attribute
Dog.species = "New Species"

## Accessing the class attribute again
print(dog1.species)
print(dog2.species)

Führen Sie das Skript class_attributes.py erneut aus:
```
python class_attributes.py
```
Sie sollten die folgende Ausgabe sehen:
```
Canis familiaris
Canis familiaris
New Species
New Species
```
Beachten Sie, dass wenn wir Dog.species ändern, die Änderung sowohl in dog1 als auch in dog2 widergespiegelt wird, da sie dasselbe Klassenattribut teilen.

Dieses Beispiel demonstriert das grundlegende Konzept von Klassenattributen. Sie werden von allen Instanzen einer Klasse geteilt und können durch direkten Zugriff auf die Klasse geändert werden.

hasattr() auf der Klasse verwenden

In diesem Schritt lernen Sie, wie Sie die hasattr()-Funktion in Python verwenden, um zu prüfen, ob eine Klasse oder ein Objekt ein bestimmtes Attribut hat. Diese Funktion ist nützlich, um festzustellen, ob ein Attribut existiert, bevor Sie versuchen, darauf zuzugreifen. Dies kann Fehler vermeiden und Ihren Code robuster machen.

Basierend auf dem vorherigen Beispiel verwenden wir hasattr(), um die Existenz von Klassen- und Instanzattributen in der Dog-Klasse zu prüfen:

Öffnen Sie die Datei class_attributes.py in Ihrem VS Code-Editor (dies ist dieselbe Datei, die Sie im vorherigen Schritt erstellt haben).
```
~/project/class_attributes.py
```

Ändern Sie den Code, um hasattr()-Prüfungen wie folgt einzubeziehen:

class Dog:
    species = "Canis familiaris"

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

## Creating an instance of the Dog class
dog1 = Dog("Buddy", 3)

## Checking for the existence of class attributes
print(hasattr(Dog, "species"))
print(hasattr(Dog, "breed"))

## Checking for the existence of instance attributes
print(hasattr(dog1, "name"))
print(hasattr(dog1, "age"))
print(hasattr(dog1, "breed"))

In diesem Code verwenden wir hasattr(), um zu prüfen, ob die Dog-Klasse die Attribute species und breed hat und ob die Instanz dog1 die Attribute name, age und breed hat.

Führen Sie das Skript class_attributes.py mit dem folgenden Befehl im Terminal aus:
```
python class_attributes.py
```
Sie sollten die folgende Ausgabe sehen:
```
True
False
True
True
False
```
Die Ausgabe zeigt, dass die Dog-Klasse das Attribut species hat (True), aber nicht das Attribut breed (False). Ebenso hat die Instanz dog1 die Attribute name und age (True), aber nicht das Attribut breed (False).

hasattr() gibt True zurück, wenn das Attribut existiert, und False sonst. Dies ermöglicht es Ihnen, bedingten Code zu schreiben, der unterschiedliche Fälle basierend auf der Existenz von Attributen behandelt. Beispielsweise möchten Sie möglicherweise einen Standardwert bereitstellen, wenn ein Attribut fehlt.

Dieses Beispiel zeigt, wie Sie hasattr() verwenden können, um die Existenz von Attributen in einer Klasse und ihren Instanzen zu prüfen. Dies ist eine nützliche Technik für das Schreiben von flexiblerem und robusterem Code.

Sicheren Zugriff mit getattr()

In diesem Schritt lernen Sie, wie Sie die getattr()-Funktion in Python verwenden, um sicher auf Attribute einer Klasse oder eines Objekts zuzugreifen. Die getattr()-Funktion ermöglicht es Ihnen, einen Standardwert anzugeben, wenn das Attribut nicht existiert. Dadurch werden AttributeError-Ausnahmen vermieden und Ihr Code robuster.

Wir setzen das Beispiel mit der Dog-Klasse fort und verwenden getattr(), um auf das breed-Attribut zuzugreifen, von dem wir wissen, dass es möglicherweise nicht existiert:

Öffnen Sie die Datei class_attributes.py in Ihrem VS Code-Editor (dies ist dieselbe Datei, die Sie in den vorherigen Schritten verwendet haben).
```
~/project/class_attributes.py
```

Ändern Sie den Code, um getattr() einzubeziehen, um sicher auf das breed-Attribut zuzugreifen:

class Dog:
    species = "Canis familiaris"

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

## Creating an instance of the Dog class
dog1 = Dog("Buddy", 3)

## Safely accessing the 'breed' attribute using getattr()
breed = getattr(dog1, "breed", "Unknown")
print(breed)

## Accessing existing attributes
print(getattr(dog1, "name"))

In diesem Code verwenden wir getattr(dog1, "breed", "Unknown"), um auf das breed-Attribut der dog1-Instanz zuzugreifen. Wenn das breed-Attribut nicht existiert, gibt getattr() den Standardwert "Unknown" zurück. Wir greifen auch auf das vorhandene name-Attribut mit getattr() zu.

Führen Sie das Skript class_attributes.py mit dem folgenden Befehl im Terminal aus:
```
python class_attributes.py
```
Sie sollten die folgende Ausgabe sehen:
```
Unknown
Buddy
```
Die Ausgabe zeigt, dass da das breed-Attribut nicht existiert, getattr() den Standardwert "Unknown" zurückgegeben hat. Das name-Attribut wird erfolgreich mit getattr() zugegriffen.

Durch die Verwendung von getattr() mit einem Standardwert können Sie AttributeError-Ausnahmen vermeiden und Fälle behandeln, in denen ein Attribut fehlen könnte. Dies macht Ihren Code widerstandsfähiger und leichter zu warten.

Dieses Beispiel zeigt, wie Sie getattr() verwenden können, um sicher auf Attribute in einer Klasse und ihren Instanzen zuzugreifen. Dies ist eine wertvolle Technik für das Schreiben von robusterem und flexiblerem Code.

Zusammenfassung

In diesem Lab haben Sie sich mit Klassenattributen in Python vertraut gemacht. Klassenattribute sind Variablen, die innerhalb einer Klasse definiert werden und von allen Instanzen geteilt werden. Sie haben eine Dog-Klasse mit dem Klassenattribut species sowie den Instanzattributen name und age erstellt. Sie haben beobachtet, dass alle Instanzen der Dog-Klasse denselben Wert für das species-Attribut teilen, während jede Instanz eigene, eindeutige Werte für die Attribute name und age hat.

Sie haben auch das Skript class_attributes.py ausgeführt und die Ausgabe überprüft. Dadurch haben Sie bestätigt, dass auf Klassenattribute auf die gleiche Weise zugegriffen wird wie auf Instanzattribute, aber dass sie von allen Instanzen der Klasse geteilt werden.