Il metodo `update()` in Python ti permette di **aggiungere più elementi** a un set in una sola volta. Questo metodo accetta un iterabile (come una **lista**, una **tupla** o un altro **set**) e aggiunge i suoi elementi al set esistente.

Il metodo `update()` può accettare:
- **Liste:** `[movie1, movie2, ...]`;
- **Tuple:** `(movie1, movie2, ...)`;
- **Altri Set:** `{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)

> Nota
>
> Se un elemento che viene aggiunto esiste già nel set, non verrà duplicato.
L'ordine degli elementi in un set non è garantito e può variare.

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

In questo corso, conoscerai le strutture dati fondamentali del linguaggio di programmazione Python. Esploreremo l'utilizzo delle strutture dati native di Python come liste, dizionari, tuples e sets per affrontare diverse sfide.

Cos'è una lista? Una lista è una collezione ordinata che può essere modificata. Consente anche elementi duplicati.

Cos'è un dizionario? Un dizionario è una raccolta ordinata che può essere modificata, ma non consente voci duplicate. Consiste in coppie `key:value`, che vengono utilizzate per ottimizzare la sua struttura.

Cos'è una tupla? Una tupla è una collezione ordinata che non può essere modificata. Può avere elementi duplicati. Anche se è simile a una lista, i valori in una tupla possono essere di qualsiasi tipo e sono indicizzati da numeri interi. Anche se non è obbligatorio, è comune racchiudere i valori di una tupla tra parentesi, rendendoli più facili da comprendere in Python.

Cos'è un set? In Python, un `set` è una collezione non ordinata che è sia `iterable` che `mutable`, senza elementi ripetuti. Sebbene l'ordine degli elementi in un set non sia fisso, può includere una varietà di elementi. Un vantaggio chiave dell'utilizzo dei set rispetto alle liste è il loro metodo altamente efficiente per determinare se un elemento esiste all'interno del set.

Utilizzare il Metodo update(): Unire Più Elementi in un Set

Soluzione

Utilizzare il Metodo update(): Unire Più Elementi in un Set

Soluzione