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

Ett **set** i Python är en **oordnad samling av unika element**. Till skillnad från listor eller tupler tillåter set **inte dubbletter**, vilket gör dem idealiska för operationer som att ta bort dubbletter eller utföra matematiska mängdoperationer. Set är **mutabla**, vilket innebär att deras element kan läggas till eller tas bort, men **datan inuti setet måste vara omutabel** (t.ex. tal, strängar eller tupler).

Ett set kan inte innehålla ordböcker eller listor eftersom båda är mutabla datatyper.

Notera

Det finns två huvudsakliga sätt att skapa ett set i Python:
1. Genom att använda måsvingar `{}` med element separerade med **kommatecken**;
2. Genom att använda funktionen `set()`.

Här är några viktiga punkter om set:
 - **De är mutabla:** du kan lägga till eller ta bort element från ett set, men setet i sig måste innehålla omutabla element;
 - **Dubbletter:**
om dubbletter läggs till i ett set tas de automatiskt bort;
 - **Oordnade:**
ordningen på elementen i ett set är inte garanterad och kan variera;
 - **Blandade datatyper:**
set kan innehålla element av olika datatyper, såsom **strängar**, **heltal** eller **tupler**.

Låt oss definiera ett set med hjälp av funktionen `set()`: 

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

Nästa steg är att definiera en mängd med populära filmer med hjälp av klamrar:

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

Dubbletter som `"Tenet"` tas automatiskt bort när mängden skapas.

### Begränsningar vid skapande av mängder
Syntaxen för att skapa en mängd med funktionen `set()` har specifika krav. Om du försöker skicka flera argument direkt, till exempel:
``` python
set("Tenet", "Dunkirk", "Inception")
```
kommer du att få ett `TypeError`, eftersom funktionen `set()` förväntar sig en **enda itererbar** som argument, inte flera separata värden.

För att skapa en mängd med flera element måste du ange dem som en enda itererbar:

# 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

Utforska de grundläggande datastrukturerna i programmeringsspråket Python, inklusive listor, ordböcker, tupler och mängder, och lär dig hur dessa kan tillämpas effektivt för att lösa verkliga programmeringsproblem.

Vad är en lista? En lista är en ordnad samling som kan modifieras. Den tillåter även dubbletter av element.

Vad är ett dictionary? Ett dictionary är en ordnad samling som kan ändras, men tillåter inte dubbletter. Det består av nyckel:värde-par, vilka används för att optimera dess struktur.

Vad är en tuple? En tuple är en ordnad samling som inte kan ändras. Den kan innehålla dubbletter. Även om den liknar en lista kan värdena i en tuple vara av vilken typ som helst och indexeras med heltal. Det är vanligt, men inte obligatoriskt, att omsluta tuple-värden med parenteser för att göra dem lättare att förstå i Python.

Vad är en mängd? I Python är en mängd en oordnad samling som är både itererbar och muterbar, utan upprepade element. Även om ordningen på objekten i en mängd inte är fast, kan den innehålla olika typer av element. En viktig fördel med att använda mängder istället för listor är deras mycket effektiva metod för att avgöra om ett element finns i mängden.

Skapa en Mängd i Python: Definiera Oordnade Samlingar

Begränsningar vid skapande av mängder

Lösning