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

Et **set** i Python er en **uordnet samling af unikke elementer**. I modsætning til lister eller tuples tillader sets **ikke dublerede elementer**, hvilket gør dem ideelle til operationer som at fjerne dubletter eller udføre matematiske mængdeoperationer. Sets er **mutable**, hvilket betyder, at deres elementer kan tilføjes eller fjernes, men **dataene inde i settet skal være immutable** (f.eks. tal, strenge eller tuples).

Et set kan ikke indeholde dictionaries eller lister, da begge er mutable datatyper.

Bemærk

Der er to hovedmåder at oprette et set i Python på:
1. Ved at bruge krøllede parenteser `{}` med elementer adskilt af **kommaer**;
2. Ved at bruge funktionen `set()`.

Her er nogle vigtige punkter om sets:
 - **De er mutable:** du kan tilføje eller fjerne elementer fra et set, men selve settet skal indeholde immutable elementer;
 - **Dublerede elementer:**
hvis dublerede elementer tilføjes til et set, fjernes de automatisk;
 - **Uordnet:**
rækkefølgen af elementer i et set er ikke garanteret og kan variere;
 - **Forskellige datatyper:**
sets kan indeholde elementer af forskellige datatyper, såsom **strenge**, **heltal** eller **tuples**.

Lad os definere et set ved hjælp af funktionen `set()`: 

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

Dernæst defineres et sæt af populære film ved hjælp af krøllede parenteser:

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

Dublerede elementer som `"Tenet"` fjernes automatisk, når sættet oprettes.

### Begrænsninger ved oprettelse af sæt
Syntaksen for at oprette et sæt ved hjælp af funktionen `set()` har specifikke krav. Hvis du forsøger at videregive flere argumenter direkte, såsom:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Vil du støde på en `TypeError`, fordi funktionen `set()` forventer et **enkelt iterabelt objekt** som argument, ikke flere separate værdier.

For at oprette et sæt med flere elementer skal du give dem som et enkelt iterabelt objekt:

# 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

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også duplikerede elementer.

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men som ikke tillader dublerede poster. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

Hvad er et tuple? Et tuple er en ordnet samling, der ikke kan ændres. Det kan indeholde duplikerede elementer. Selvom det ligner en liste, kan værdierne i et tuple være af enhver type og indekseres med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i et tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Oprettelse af et Sæt i Python: Definition af Uordnede Samlinger

Begrænsninger ved oprettelse af sæt

Løsning