Summary  
This chapter explains how to verify membership in a set using the in keyword and how to iterate through all elements of an unordered set with a for loop.  

General domain of usage  
Managing a movie collection.

Poiché i set sono **non ordinati**, non puoi accedere ai loro elementi tramite indice come faresti con una lista o una tupla. Tuttavia, puoi:

- Verificare l'esistenza di un elemento usando la parola chiave `in`;
- Iterare attraverso gli elementi usando un ciclo `for`.

### Verifica dell'Appartenenza con `in`
La parola chiave `in` ti consente di verificare se un elemento specifico esiste all'interno di un set:

# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Check if specific movies are in the set
is_inception_present = "Inception" in movies  # True
is_avatar_present = "Avatar" in movies        # False

# Print results
print(is_inception_present)  # Output: True
print(is_avatar_present)     # Output: False

In questo esempio, usiamo la parola chiave `in` per verificare se film specifici sono presenti nel set `movies` e memorizziamo il risultato come valore booleano nelle variabili `is_inception_present` e `is_avatar_present`.

### Iterare Attraverso un Set con un Ciclo `for`
Puoi iterare su un set usando un ciclo `for` per elaborare ciascun elemento individualmente. Poiché i set sono non ordinati, l'ordine di iterazione è imprevedibile.


# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Iterate through the set and print each movie title
print("Movie collection:")
for movie in movies:
    print(movie)

Ogni elemento nell'insieme viene accesso una volta durante l'iterazione.
L'ordine degli elementi nell'output può variare.

import unittest
import importlib
import re

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

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

    def test_is_first_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_first_movie_present'),
            "The `is_first_movie_present` variable is declared.",
            "Expected `is_first_movie_present` to be declared."
        )

    def test_is_second_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_second_movie_present'),
            "The `is_second_movie_present` variable is declared.",
            "Expected `is_second_movie_present` to be declared."
        )

    def test_is_third_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_third_movie_present'),
            "The `is_third_movie_present` variable is declared.",
            "Expected `is_third_movie_present` to be declared."
        )

    def test_is_first_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_first_movie_present is True,
            "The `is_first_movie_present` is correctly set to `True`.",
            "Expected `is_first_movie_present` to be `True`, but got `False`."
        )

    def test_is_second_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_second_movie_present is False,
            "The `is_second_movie_present` is correctly set to `False`.",
            "Expected `is_second_movie_present` to be `False`, but got `True`."
        )

    def test_is_third_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_third_movie_present is True,
            "The `is_third_movie_present` is correctly set to `True`.",
            "Expected `is_third_movie_present` to be `True`, but got `False`."
        )

    def test_in_keyword_used_three_times(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        in_keyword_count = len(re.findall(r'in\s+movies', user_code_source))
        _dynamic_test(
            self,
            in_keyword_count == 3,
            "The `in` keyword is used exactly three times in the code.",
            f"Expected the `in` keyword to be used exactly three times, but found {in_keyword_count} occurrences."
        )

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

test_main.py

Esplora le strutture dati fondamentali del linguaggio di programmazione Python, tra cui liste, dizionari, tuple e set, e apprendi come applicarle efficacemente per risolvere sfide di programmazione reali.

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.

Accesso agli Elementi in un Set: Iterazione e Verifica dell'Appartenenza

Verifica dell'Appartenenza con `in`

Iterare Attraverso un Set con un Ciclo `for`

Soluzione

Accesso agli Elementi in un Set: Iterazione e Verifica dell'Appartenenza

Verifica dell'Appartenenza con in

Iterare Attraverso un Set con un Ciclo for

Soluzione

Verifica dell'Appartenenza con `in`

Iterare Attraverso un Set con un Ciclo `for`