Summary  
This chapter explains how to define and manipulate Python sets—unordered, mutable collections that automatically enforce element uniqueness—by using curly-brace literals or the set() constructor and highlights rules for handling duplicates and required input types.

General domain of usage  
Data deduplication

Ein **Set** in Python ist eine **ungeordnete Sammlung einzigartiger Elemente**. Im Gegensatz zu Listen oder Tupeln **erlauben Sets keine doppelten Elemente**, was sie ideal für Aufgaben wie das Entfernen von Duplikaten oder mathematische Mengenoperationen macht. Sets sind **veränderbar** (mutable), das heißt, ihre Elemente können hinzugefügt oder entfernt werden, aber die **Daten innerhalb des Sets müssen unveränderlich** (immutable) sein (z. B. Zahlen, Zeichenketten oder Tupel).

Ein Set kann keine Dictionaries oder Listen enthalten, da beide veränderbare Datentypen sind.

Hinweis

Es gibt zwei Hauptmethoden, um ein Set in Python zu erstellen:
1. Mit geschweiften Klammern `{}` und durch **Kommas** getrennten Elementen;
2. Mit der Funktion `set()`.

Wichtige Merkmale von Sets:
 - **Sie sind veränderbar:** Elemente können zu einem Set hinzugefügt oder daraus entfernt werden, aber das Set selbst darf nur unveränderliche Elemente enthalten;
 - **Doppelte Elemente:**
Wenn doppelte Elemente zu einem Set hinzugefügt werden, werden sie automatisch entfernt;
 - **Ungeordnet:**
Die Reihenfolge der Elemente in einem Set ist nicht garantiert und kann variieren;
 - **Verschiedene Datentypen:**
Sets können Elemente unterschiedlicher Datentypen enthalten, wie **Strings**, **Integer** oder **Tuples**.

Ein Set kann mit der Funktion `set()` definiert werden:

# Creating a set which contains strings
movie_set = set("Interstellar")
print(movie_set)

Als Nächstes wird ein Set beliebter Filme mit geschweiften Klammern definiert:

# Creating a set of movies using curly braces
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Tenet"}
print(movies)

Doppelte Einträge wie `"Tenet"` werden beim Erstellen des Sets automatisch entfernt.

### Einschränkungen beim Erstellen von Sets
Die Syntax zur Erstellung eines Sets mit der Funktion `set()` hat bestimmte Anforderungen. Wenn Sie versuchen, mehrere Argumente direkt zu übergeben, wie zum Beispiel:
``` python
set("Tenet", "Dunkirk", "Inception")
```
tritt ein `TypeError` auf, da die Funktion `set()` **ein einziges iterierbares Objekt** als Argument erwartet und nicht mehrere einzelne Werte.

Um ein Set mit mehreren Elementen zu erstellen, müssen diese als ein einziges iterierbares Objekt übergeben werden:

# Using a list `[]`
movies = set(["Tenet", "Dunkirk", "Inception"])
print(movies)

# Using a tuple `(,)`
movies = set(("Tenet", "Dunkirk", "Inception"))
print(movies)

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):
    def test_nolan_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'nolan_movies'),
            "The `nolan_movies` variable is declared.",
            "Expected `nolan_movies` to be declared."
        )

    def test_nolan_movies_is_set(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.nolan_movies, set),
            "The `nolan_movies` is of type `set`.",
            "Expected `nolan_movies` to be of type `set`."
        )

    def test_nolan_movies_contains_correct_values(self):
        import user_code
        expected_movies = {"Inception", "The Dark Knight", "Interstellar", "Tenet"}
        _dynamic_test(
            self,
            user_code.nolan_movies == expected_movies,
            f"The `nolan_movies` contains `{expected_movies}`.",
            f"Expected `nolan_movies` to contain `{expected_movies}`, but got `{user_code.nolan_movies}`."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Erkunden Sie die grundlegenden Datenstrukturen der Programmiersprache Python, einschließlich Listen, Dictionaries, Tupel und Sets, und erfahren Sie, wie Sie diese effektiv zur Lösung praxisnaher Programmieraufgaben einsetzen können.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die verändert werden kann. Sie erlaubt außerdem doppelte Elemente.

Was ist ein Dictionary? Ein Dictionary ist eine geordnete, veränderbare Sammlung, die keine doppelten Einträge zulässt. Es besteht aus Schlüssel:Wert-Paaren, die zur Optimierung seiner Struktur verwendet werden.

Was ist ein Tupel? Ein Tupel ist eine geordnete Sammlung, die nicht verändert werden kann. Es kann doppelte Elemente enthalten. Obwohl es einer Liste ähnelt, können die Werte in einem Tupel beliebigen Typs sein und werden durch Ganzzahlen indiziert. Es ist zwar nicht zwingend erforderlich, aber üblich, die Werte eines Tupels in Klammern zu setzen, um sie in Python leichter verständlich zu machen.

Was ist eine Menge? In Python ist eine Menge eine ungeordnete Sammlung, die sowohl iterierbar als auch veränderbar ist und keine doppelten Elemente enthält. Obwohl die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie verschiedene Elemente umfassen. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist die äußerst effiziente Methode zur Überprüfung, ob ein Element in der Menge vorhanden ist.

Erstellen eines Sets in Python: Definieren ungeordneter Sammlungen

Einschränkungen beim Erstellen von Sets

Lösung