Wie man prüft, ob ein Objekt eine Instanz einer Klasse in Python ist

Einführung

In diesem Lab werden Sie Klassen und Instanzen in Python untersuchen und lernen, wie Sie prüfen können, ob ein Objekt eine Instanz einer Klasse ist. Sie beginnen damit, eine Dog-Klasse mit Klassen- und Instanzattributen zu erstellen, erstellen dann Instanzen der Dog-Klasse und greifen auf deren Attribute zu.

Anschließend lernen Sie, die Funktion isinstance() zur Typüberprüfung zu verwenden und vergleichen sie mit der Funktion type() für exakte Übereinstimmungen. Dies ermöglicht es Ihnen, zu bestimmen, ob ein Objekt zu einer bestimmten Klasse oder einer Unterklasse dieser Klasse gehört und vermittelt ein tieferes Verständnis der objektorientierten Programmierung in Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ObjectOrientedProgrammingGroup(["Object-Oriented Programming"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/ObjectOrientedProgrammingGroup -.-> python/classes_objects("Classes and Objects") python/ObjectOrientedProgrammingGroup -.-> python/constructor("Constructor") python/ObjectOrientedProgrammingGroup -.-> python/inheritance("Inheritance") subgraph Lab Skills python/build_in_functions -.-> lab-559613{{"Wie man prüft, ob ein Objekt eine Instanz einer Klasse in Python ist"}} python/classes_objects -.-> lab-559613{{"Wie man prüft, ob ein Objekt eine Instanz einer Klasse in Python ist"}} python/constructor -.-> lab-559613{{"Wie man prüft, ob ein Objekt eine Instanz einer Klasse in Python ist"}} python/inheritance -.-> lab-559613{{"Wie man prüft, ob ein Objekt eine Instanz einer Klasse in Python ist"}} end

Klassen und Instanzen untersuchen

In diesem Schritt lernen Sie etwas über Klassen und Instanzen in Python. Klassen sind wie Baupläne für die Erstellung von Objekten, und Instanzen sind die tatsächlichen Objekte, die aus diesen Bauplänen erstellt werden. Das Verständnis von Klassen und Instanzen ist grundlegend für die objektorientierte Programmierung in Python.

Zunächst erstellen wir eine einfache Klasse namens Dog.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei namens dog.py im Verzeichnis ~/project.
```
~/project/dog.py
```
Fügen Sie den folgenden Code in die Datei dog.py ein:
```
## Define a class called Dog
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age
```
Hier definieren wir eine Klasse namens Dog. Das Attribut species ist ein Klassenattribut, was bedeutet, dass es von allen Instanzen der Dog-Klasse geteilt wird. Die Methode __init__ ist eine spezielle Methode, die Konstruktor genannt wird. Sie wird verwendet, um die Instanzattribute name und age zu initialisieren, wenn ein neues Dog-Objekt erstellt wird.

Jetzt erstellen wir Instanzen der Dog-Klasse. Fügen Sie den folgenden Code am Ende der Datei dog.py hinzu:

## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Access instance attributes
print(f"{buddy.name} is {buddy.age} years old.")
print(f"{miles.name} is {miles.age} years old.")

## Access class attribute
print(f"{buddy.name} is a {buddy.species}.")
print(f"{miles.name} is a {miles.species}.")

In diesem Teil erstellen wir zwei Instanzen der Dog-Klasse: buddy und miles. Anschließend greifen wir auf ihre Instanzattribute (name und age) und das Klassenattribut (species) über die Punktnotation (.) zu.

Um das Skript dog.py auszuführen, öffnen Sie ein Terminal in VS Code und führen Sie den folgenden Befehl aus:
```
python dog.py
```
Sie sollten die folgende Ausgabe sehen:
```
Buddy is 9 years old.
Miles is 4 years old.
Buddy is a Canis familiaris.
Miles is a Canis familiaris.
```
Diese Ausgabe bestätigt, dass Sie erfolgreich Instanzen der Dog-Klasse erstellt und auf deren Attribute zugegriffen haben.

Verwendung von `isinstance()` zur Typüberprüfung

In diesem Schritt lernen Sie, wie Sie die Funktion isinstance() in Python verwenden, um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist. Dies ist ein nützliches Werkzeug, um sicherzustellen, dass Ihr Code verschiedene Objekttypen korrekt verarbeitet.

Basierend auf der Dog-Klasse aus dem vorherigen Schritt erstellen wir eine neue Python-Datei, um isinstance() zu untersuchen.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei namens type_check.py im Verzeichnis ~/project.
```
~/project/type_check.py
```

Kopieren Sie die Definition der Dog-Klasse aus dog.py in type_check.py. Ihre type_check.py-Datei sollte nun wie folgt aussehen:

class Dog:
    species = "Canis familiaris"

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

Jetzt fügen wir etwas Code hinzu, um die Funktion isinstance() zu verwenden. Fügen Sie den folgenden Code am Ende der Datei type_check.py hinzu:
```
## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Check if buddy is an instance of the Dog class
print(isinstance(buddy, Dog))

## Check if miles is an instance of the Dog class
print(isinstance(miles, Dog))

## Check if a string is an instance of the Dog class
print(isinstance("Hello", Dog))
```
Hier erstellen wir zwei Instanzen der Dog-Klasse, buddy und miles. Anschließend verwenden wir die Funktion isinstance(), um zu prüfen, ob diese Instanzen vom Typ Dog sind. Wir prüfen auch, ob die Zeichenkette "Hello" eine Instanz der Dog-Klasse ist.
Um das Skript type_check.py auszuführen, öffnen Sie ein Terminal in VS Code und führen Sie den folgenden Befehl aus:
```
python type_check.py
```
Sie sollten die folgende Ausgabe sehen:
```
True
True
False
```
Die Ausgabe zeigt, dass buddy und miles tatsächlich Instanzen der Dog-Klasse sind, während die Zeichenkette "Hello" es nicht ist.

Vergleich mit `type()` für exakte Übereinstimmungen

In diesem Schritt lernen Sie, wie Sie die Funktion type() in Python verwenden und sie mit isinstance() für die Typüberprüfung vergleichen. Während isinstance() prüft, ob ein Objekt eine Instanz einer Klasse oder ihrer Unterklassen ist, gibt type() den genauen Typ eines Objekts zurück.

Um den Unterschied zu veranschaulichen, erstellen wir eine Unterklasse der Dog-Klasse und verwenden dann sowohl isinstance() als auch type(), um den Typ von Instanzen zu prüfen.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Bearbeiten Sie die Datei type_check.py im Verzeichnis ~/project.
```
~/project/type_check.py
```

Fügen Sie eine neue Klasse namens GermanShepherd hinzu, die von der Dog-Klasse erbt. Ihre type_check.py-Datei sollte nun wie folgt aussehen:

class Dog:
    species = "Canis familiaris"

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

class GermanShepherd(Dog):
    def __init__(self, name, age, training_level):
        super().__init__(name, age)
        self.training_level = training_level

Hier ist GermanShepherd eine Unterklasse von Dog. Sie erbt die Attribute name und age von der Dog-Klasse und fügt ein neues Attribut training_level hinzu.

Jetzt fügen wir etwas Code hinzu, um die Funktionen isinstance() und type() zu verwenden. Fügen Sie den folgenden Code am Ende der Datei type_check.py hinzu:

## Create instances of the Dog and GermanShepherd classes
buddy = Dog("Buddy", 9)
sparky = GermanShepherd("Sparky", 3, "Advanced")

## Check types using isinstance()
print(f"buddy isinstance Dog: {isinstance(buddy, Dog)}")
print(f"sparky isinstance Dog: {isinstance(sparky, Dog)}")
print(f"sparky isinstance GermanShepherd: {isinstance(sparky, GermanShepherd)}")

## Check types using type()
print(f"type(buddy) == Dog: {type(buddy) == Dog}")
print(f"type(sparky) == Dog: {type(sparky) == Dog}")
print(f"type(sparky) == GermanShepherd: {type(sparky) == GermanShepherd}")

In diesem Teil erstellen wir eine Instanz der Dog-Klasse (buddy) und eine Instanz der GermanShepherd-Klasse (sparky). Anschließend verwenden wir isinstance() und type(), um ihre Typen zu prüfen.

Um das Skript type_check.py auszuführen, öffnen Sie ein Terminal in VS Code und führen Sie den folgenden Befehl aus:
```
python type_check.py
```
Sie sollten die folgende Ausgabe sehen:
```
buddy isinstance Dog: True
sparky isinstance Dog: True
sparky isinstance GermanShepherd: True
type(buddy) == Dog: True
type(sparky) == Dog: False
type(sparky) == GermanShepherd: True
```
Die Ausgabe zeigt, dass isinstance(sparky, Dog) True zurückgibt, weil sparky eine Instanz der GermanShepherd-Klasse ist, die eine Unterklasse von Dog ist. Allerdings gibt type(sparky) == Dog False zurück, weil type(sparky) den genauen Typ zurückgibt, der GermanShepherd und nicht Dog ist.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen von Klassen und Instanzen in Python untersucht. Sie haben gelernt, wie Sie eine Klasse definieren, einschließlich Klassenattributen und Instanzattributen, die innerhalb des __init__-Konstruktors initialisiert werden.

Anschließend haben Sie Instanzen der Dog-Klasse erstellt und ihren spezifischen Attributen Werte zugewiesen. Schließlich haben Sie sowohl Instanzattribute (Name, Alter) als auch das Klassenattribut (Spezies) mit der Punktnotation zugegriffen, was zeigt, wie man Informationen abruft, die mit Objekten und ihren Klassen verbunden sind.