Wie man prüft, ob eine Variable in Python eine Menge (Set) ist

Einführung

In diesem Lab lernen Sie, wie Sie feststellen können, ob eine Variable in Python ein Set (Menge) ist. Sie beginnen damit, die grundlegenden Eigenschaften von Sets zu verstehen, einschließlich ihrer ungeordneten Natur und der Eindeutigkeit ihrer Elemente. Durch praktische Übungen erstellen Sie Sets sowohl mit geschweiften Klammern als auch mit dem set()-Konstruktor und erkunden gängige Set-Operationen wie das Hinzufügen und Entfernen von Elementen sowie die Prüfung auf Mitgliedschaft.

Das Lab führt Sie dann durch die Verwendung der type()-Funktion und der isinstance()-Funktion, um festzustellen, ob eine Variable tatsächlich ein Set ist. Am Ende dieses Labs verfügen Sie über das Wissen und die Fähigkeiten, um Sets in Ihrem Python-Code sicher zu identifizieren.

Mengen (Sets) verstehen

In diesem Schritt lernen Sie über Sets in Python. Sets sind ungeordnete Sammlungen eindeutiger Elemente. Das bedeutet, dass ein Set keine doppelten Werte enthalten kann und die Reihenfolge der Elemente in einem Set nicht garantiert ist. Sets sind nützlich für die Durchführung mathematischer Mengenoperationen wie Vereinigung, Schnittmenge und Differenz.

Beginnen wir damit, ein Set zu erstellen. Sie können ein Set mit geschweiften Klammern {} oder dem set()-Konstruktor erstellen.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

Erstellen Sie eine neue Datei namens sets_example.py im Verzeichnis ~/project.

## Create a set using curly braces
my_set = {1, 2, 3, 4, 5}
print(my_set)

## Create a set using the set() constructor
another_set = set([3, 4, 5, 6, 7])
print(another_set)

Führen Sie das Skript mit dem python-Befehl im Terminal aus:
```
python ~/project/sets_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
{1, 2, 3, 4, 5}
{3, 4, 5, 6, 7}
```

Jetzt erkunden wir einige gängige Set-Operationen.

Fügen Sie den folgenden Code Ihrer sets_example.py-Datei hinzu:

## Add an element to a set
my_set.add(6)
print(my_set)

## Remove an element from a set
my_set.remove(1)
print(my_set)

## Check if an element is in a set
print(3 in my_set)
print(1 in my_set)

Führen Sie das Skript erneut aus:
```
python ~/project/sets_example.py
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
{1, 2, 3, 4, 5, 6}
{2, 3, 4, 5, 6}
True
False
```

Sets sind besonders nützlich für das Entfernen doppelter Elemente aus einer Liste.

Fügen Sie den folgenden Code Ihrer sets_example.py-Datei hinzu:

## Create a list with duplicate elements
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
print(my_list)

## Convert the list to a set to remove duplicates
unique_elements = set(my_list)
print(unique_elements)

Führen Sie das Skript aus:

python ~/project/sets_example.py

Die Ausgabe sollte wie folgt sein:

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
{1, 2, 3, 4}

Wie Sie sehen können, enthält das Set unique_elements nur die eindeutigen Elemente aus der ursprünglichen Liste.

Verwenden Sie type() zur Identifizierung

In diesem Schritt lernen Sie, wie Sie die type()-Funktion in Python verwenden, um den Datentyp einer Variablen zu identifizieren. Das Verständnis von Datentypen ist entscheidend für das Schreiben korrekten und effizienten Codes.

Die type()-Funktion gibt den Typ eines Objekts zurück. Sehen wir uns an, wie sie mit verschiedenen Datentypen funktioniert.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

Erstellen Sie eine neue Datei namens type_example.py im Verzeichnis ~/project.

## Check the type of an integer
x = 10
print(type(x))

## Check the type of a float
y = 3.14
print(type(y))

## Check the type of a string
z = "Hello"
print(type(z))

## Check the type of a boolean
a = True
print(type(a))

## Check the type of a list
b = [1, 2, 3]
print(type(b))

## Check the type of a tuple
c = (1, 2, 3)
print(type(c))

## Check the type of a set
d = {1, 2, 3}
print(type(d))

## Check the type of a dictionary
e = {"name": "Alice", "age": 30}
print(type(e))

Führen Sie das Skript mit dem python-Befehl im Terminal aus:

python ~/project/type_example.py

Sie sollten die folgende Ausgabe sehen:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

Die Ausgabe zeigt den Datentyp jeder Variablen. Beispielsweise gibt <class 'int'> an, dass die Variable eine Ganzzahl ist, und <class 'str'> gibt an, dass die Variable eine Zeichenkette ist.

Das Verständnis des Datentyps einer Variablen ist wichtig, da es bestimmt, welche Operationen Sie auf diese Variable anwenden können. Beispielsweise können Sie arithmetische Operationen auf Ganzzahlen und Fließkommazahlen ausführen, aber nicht auf Zeichenketten.

Sehen wir uns ein Beispiel an, wie die type()-Funktion verwendet werden kann, um zu prüfen, ob eine Variable einen bestimmten Typ hat, bevor eine Operation ausgeführt wird.

Fügen Sie den folgenden Code Ihrer type_example.py-Datei hinzu:

## Check if a variable is an integer before adding 5 to it
num = 10
if type(num) == int:
    result = num + 5
    print(result)
else:
    print("Variable is not an integer")

## Check if a variable is a string before concatenating it with another string
text = "Hello"
if type(text) == str:
    greeting = text + ", World!"
    print(greeting)
else:
    print("Variable is not a string")

Führen Sie das Skript erneut aus:
```
python ~/project/type_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
15
Hello, World!
```

In diesem Beispiel wird die type()-Funktion verwendet, um zu prüfen, ob die Variable num eine Ganzzahl und die Variable text eine Zeichenkette ist, bevor die Addition und die Verkettung ausgeführt werden.

Bestätigen Sie mit isinstance()

In diesem Schritt lernen Sie, wie Sie die isinstance()-Funktion in Python verwenden, um zu bestätigen, ob ein Objekt eine Instanz einer bestimmten Klasse oder eines bestimmten Typs ist. Dies ist eine robuster und empfohlene Methode zum Prüfen von Datentypen im Vergleich zur Verwendung von type().

Die isinstance()-Funktion nimmt zwei Argumente entgegen: das zu prüfende Objekt und die Klasse oder den Typ, gegen den geprüft werden soll. Sie gibt True zurück, wenn das Objekt eine Instanz der angegebenen Klasse oder des angegebenen Typs ist, und False sonst.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.

Erstellen Sie eine neue Datei namens isinstance_example.py im Verzeichnis ~/project.

## Check if a variable is an integer
x = 10
print(isinstance(x, int))

## Check if a variable is a float
y = 3.14
print(isinstance(y, float))

## Check if a variable is a string
z = "Hello"
print(isinstance(z, str))

## Check if a variable is a boolean
a = True
print(isinstance(a, bool))

## Check if a variable is a list
b = [1, 2, 3]
print(isinstance(b, list))

## Check if a variable is a tuple
c = (1, 2, 3)
print(isinstance(c, tuple))

## Check if a variable is a set
d = {1, 2, 3}
print(isinstance(d, set))

## Check if a variable is a dictionary
e = {"name": "Alice", "age": 30}
print(isinstance(e, dict))

Führen Sie das Skript mit dem python-Befehl im Terminal aus:
```
python ~/project/isinstance_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
True
True
True
True
True
True
True
True
```

Alle Variablen sind Instanzen der Typen, gegen die wir geprüft haben, daher hat isinstance() in jedem Fall True zurückgegeben.

isinstance() ist besonders nützlich, wenn es um Vererbung geht. Wenn eine Klasse von einer anderen Klasse erbt, wird ein Objekt der Unterklasse auch als Instanz der Basisklasse betrachtet.

Fügen Sie den folgenden Code Ihrer isinstance_example.py-Datei hinzu:

class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()

## Check if my_dog is an instance of Dog
print(isinstance(my_dog, Dog))

## Check if my_dog is an instance of Animal
print(isinstance(my_dog, Animal))

Führen Sie das Skript erneut aus:
```
python ~/project/isinstance_example.py
```
Sie sollten die folgende Ausgabe sehen:
```
True
True
```

In diesem Beispiel erbt Dog von Animal. Daher ist my_dog sowohl eine Instanz von Dog als auch von Animal.

Die Verwendung von isinstance() wird im Allgemeinen gegenüber type() bevorzugt, da sie Vererbung korrekt behandelt und flexibler ist.

Zusammenfassung

In diesem Lab haben Sie sich mit Mengen (sets) in Python vertraut gemacht. Mengen sind ungeordnete Sammlungen eindeutiger Elemente. Sie haben Mengen mit geschweiften Klammern {} und dem set()-Konstruktor erstellt und gängige Mengenoperationen wie das Hinzufügen und Entfernen von Elementen durchgeführt.

Darüber hinaus haben Sie untersucht, wie Mengen verwendet werden können, um doppelte Elemente aus einer Liste zu entfernen, indem Sie die Liste in eine Menge umwandeln. Sie haben auch gelernt, wie Sie mithilfe des in-Operators prüfen können, ob ein Element in einer Menge enthalten ist.