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

Een **set** in Python is een **onordelijke verzameling van unieke elementen**. In tegenstelling tot lijsten of tuples staan sets **geen dubbele elementen toe**, waardoor ze ideaal zijn voor bewerkingen zoals het verwijderen van duplicaten of het uitvoeren van wiskundige setoperaties. Sets zijn **mutabel**, wat betekent dat hun elementen kunnen worden toegevoegd of verwijderd, maar de **gegevens binnen de set moeten immutabel zijn** (bijvoorbeeld getallen, strings of tuples).

Een set kan geen dictionaries of lijsten bevatten omdat beide mutabele datatypes zijn.

Opmerking

Er zijn twee hoofdmethoden om een set in Python te maken:
1. Met behulp van accolades `{}` met elementen gescheiden door **komma's**;
2. Met de functie `set()`.

Hier zijn enkele belangrijke punten over sets:
 - **Ze zijn mutabel:** je kunt elementen toevoegen aan of verwijderen uit een set, maar de set zelf moet immutabele elementen bevatten;
 - **Dubbele elementen:**
als dubbele elementen aan een set worden toegevoegd, worden deze automatisch verwijderd;
 - **Ongeordend:**
de volgorde van elementen in een set is niet gegarandeerd en kan variëren;
 - **Diverse datatypes:**
sets kunnen elementen van verschillende datatypes bevatten, zoals **strings**, **integers** of **tuples**.

Laten we een set definiëren met behulp van de functie `set()`: 

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

Vervolgens een set met populaire films definiëren met behulp van accolades:

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

Dubbele items zoals `"Tenet"` worden automatisch verwijderd wanneer de set wordt aangemaakt.

### Beperkingen bij het aanmaken van sets
De syntaxis voor het aanmaken van een set met de functie `set()` heeft specifieke vereisten. Als je probeert om meerdere argumenten direct door te geven, zoals:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Krijg je een `TypeError`, omdat de functie `set()` **één enkele iterabele** als argument verwacht, niet meerdere losse waarden.

Om een set met meerdere elementen te maken, moet je deze als één enkele iterabele aanbieden:

# 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

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om programmeeruitdagingen uit de praktijk op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit key:value-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, wat het in Python overzichtelijker maakt.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Een Set Maken in Python: Het Definiëren van Ongeordende Verzamelingen

Beperkingen bij het aanmaken van sets

Oplossing