`update()`-metoden i Python giver dig mulighed for at **tilføje flere elementer** til et sæt på én gang. Denne metode tager en iterabel (som en **liste**, **tuple** eller et andet **sæt**) og tilføjer dens elementer til det eksisterende sæt.

`update()`-metoden kan acceptere:
- **Lister:** `[movie1, movie2, ...]`;
- **Tupler:** `(movie1, movie2, ...)`;
- **Andre sæt:** `{movie1, movie2, ...}`.

# Original set of favorite movies
favorite_movies = {"Inception", "Interstellar", "Tenet"}

# Adding multiple new movies
favorite_movies.update(["Tenet", "Memento", "The Prestige"])

# Print the updated set
print(favorite_movies)

> Bemærk
>
> Hvis et element, der tilføjes, allerede findes i sættet, vil det ikke blive duplikeret.
Rækkefølgen af elementer i et sæt er ikke garanteret og kan variere.

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_marvel_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'marvel_movies'),
            "The `marvel_movies` set is declared.",
            "Expected `marvel_movies` to be declared."
        )

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

    def test_movies_to_add_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movies_to_add'),
            "The `movies_to_add` tuple is declared.",
            "Expected `movies_to_add` to be declared."
        )

    def test_movies_to_add_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movies_to_add, tuple),
            "The `movies_to_add` is of type `tuple`.",
            "Expected `movies_to_add` to be of type `tuple`."
        )

    def test_marvel_movies_contains_initial_movies(self):
        import user_code
        initial_movies = {
            'Avengers: Endgame',
            'Black Panther',
            'Iron Man'
        }
        _dynamic_test(
            self,
            initial_movies.issubset(user_code.marvel_movies),
            f"The `marvel_movies` contains the initial movies: {initial_movies}.",
            f"Expected `marvel_movies` to contain the initial movies: {initial_movies}, but got {user_code.marvel_movies}."
        )

    def test_marvel_movies_contains_new_movies(self):
        import user_code
        new_movies = {'Spider-Man: No Way Home', 'Guardians of the Galaxy'}
        _dynamic_test(
            self,
            new_movies.issubset(user_code.marvel_movies),
            f"The `marvel_movies` contains the newly added movies: {new_movies}.",
            f"Expected `marvel_movies` to contain the newly added movies: {new_movies}, but got {user_code.marvel_movies}."
        )

    def test_update_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            "update" in user_code_source,
            "The `update()` method is used to add movies.",
            "Expected the `update()` method to be used to add movies."
        )

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


test_main.py

I dette kursus vil du lære de grundlæggende datastrukturer i Python-programmeringssproget at kende. Vi vil udforske brugen af Pythons indbyggede datastrukturer som lister, ordbøger, tuples og sæt til at tackle forskellige udfordringer.

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

Hvad er en ordbog? En ordbog er en ordnet samling, der kan ændres, men den tillader ikke dublerede poster. Den består af `key:value` par, som bruges til at optimere dens struktur.

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

Hvad er et sæt? I Python er et `set` en uordnet samling, der både er `iterable` og `mutable`, uden gentagne elementer. Selvom rækkefølgen af elementer i et sæt ikke er fast, kan det inkludere en række forskellige elementer. En vigtig fordel ved at bruge sæt frem for lister er deres meget effektive metode til at bestemme, om et element findes inden for sættet.

Brug af update() Metoden: Sammenfletning af Flere Elementer i et Sæt

Løsning

Brug af update() Metoden: Sammenfletning af Flere Elementer i et Sæt

Løsning