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 **sett** i Python er en **uordnet samling av unike elementer**. I motsetning til lister eller tupler, **tillater ikke sett duplikate elementer**, noe som gjør dem ideelle for operasjoner som å fjerne duplikater eller utføre matematiske mengdeoperasjoner. Sett er **mutable**, noe som betyr at elementer kan legges til eller fjernes, men **dataene i settet må være immutable** (f.eks. tall, strenger eller tupler).

Et sett kan ikke inneholde ordbøker eller lister fordi begge er mutable datatyper.

Merk

Det finnes to hovedmåter å opprette et sett i Python på:
1. Ved å bruke krøllparenteser `{}` med elementer adskilt av **komma**;
2. Ved å bruke funksjonen `set()`.

Her er noen viktige punkter om sett:
 - **De er mutable:** du kan legge til eller fjerne elementer fra et sett, men selve settet må inneholde immutable elementer;
 - **Duplikate elementer:**
hvis duplikate elementer legges til et sett, fjernes de automatisk;
 - **Uordnet:**
rekkefølgen på elementene i et sett er ikke garantert og kan variere;
 - **Ulike datatyper:**
sett kan inneholde elementer av forskjellige datatyper, som **strenger**, **heltall** eller **tupler**.

La oss definere et sett ved å bruke funksjonen `set()`: 

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

Deretter defineres et sett med populære filmer ved å bruke krøllparenteser:

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

Dupliserte oppføringer som `"Tenet"` fjernes automatisk når settet opprettes.

### Begrensninger ved opprettelse av sett
Syntaksen for å opprette et sett med funksjonen `set()` har spesifikke krav. Hvis du prøver å sende flere argumenter direkte, slik som:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Vil du få en `TypeError`, fordi funksjonen `set()` forventer **ett enkelt itererbart objekt** som argument, ikke flere separate verdier.

For å opprette et sett med flere elementer må du sende dem som ett itererbart 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

Utforsk de grunnleggende datastrukturene i programmeringsspråket Python, inkludert lister, ordbøker, tupler og mengder, og lær hvordan disse kan brukes effektivt for å løse reelle programmeringsutfordringer.

Hva er en liste? En liste er en ordnet samling som kan endres. Den tillater også dupliserte elementer.

Hva er et dictionary? Et dictionary er en ordnet samling som kan endres, men det tillater ikke dupliserte oppføringer. Det består av nøkkel:verdi-par, som brukes for å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan inneholde dupliserte elementer. Selv om den ligner på en liste, kan verdiene i en tuple være av hvilken som helst type og er indeksert med heltall. Selv om det ikke er påkrevd, er det vanlig å omslutte verdiene i en tuple med parenteser, noe som gjør dem lettere å forstå i Python.

Hva er et sett? I Python er et sett en uordnet samling som både er itererbar og muterbar, uten gjentatte elementer. Selv om rekkefølgen på elementene i et sett ikke er fast, kan det inneholde ulike typer elementer. En viktig fordel med å bruke sett fremfor lister er den svært effektive metoden for å avgjøre om et element finnes i settet.

Oppretting av et Sett i Python: Definere Uordnede Samlinger

Begrensninger ved opprettelse av sett

Løsning