Summary  
This chapter covers how to check for the presence of elements in an unordered set using membership testing and how to iterate through a set with a for loop to access each element.

General domain of usage  
Managing a collection of unique items such as favorite movies.

Comme les ensembles sont **non ordonnés**, il n'est pas possible d'accéder à leurs éléments par indice comme avec une liste ou un tuple. Cependant, il est possible de :

- Vérifier l'existence d'un élément à l'aide du mot-clé `in` ;
- Parcourir les éléments à l'aide d'une boucle `for`.

### Vérification de l'appartenance avec `in`
Le mot-clé `in` permet de vérifier si un élément spécifique existe dans un ensemble :

# 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

Dans cet exemple, le mot-clé `in` est utilisé pour vérifier si certains films sont présents dans l'ensemble `movies` et stocker le résultat sous forme de valeur booléenne dans les variables `is_inception_present` et `is_avatar_present`.

### Parcours d'un ensemble avec une boucle `for`
Il est possible de parcourir un ensemble à l'aide d'une boucle `for` afin de traiter chaque élément individuellement. Comme les ensembles sont non ordonnés, l'ordre d'itération est imprévisible.


# 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)

Chaque élément de l'ensemble est accédé une seule fois lors de l'itération.
L'ordre des éléments dans la sortie peut varier.

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

Explorez les structures de données fondamentales du langage de programmation Python, y compris les listes, les dictionnaires, les tuples et les ensembles, et découvrez comment les appliquer efficacement pour résoudre des défis de programmation concrets.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée pouvant être modifiée. Elle autorise également les éléments dupliqués.

Accès aux éléments d'un ensemble en Python

Vérification de l'appartenance avec `in`

Parcours d'un ensemble avec une boucle `for`

Solution

Accès aux éléments d'un ensemble en Python

Vérification de l'appartenance avec in

Parcours d'un ensemble avec une boucle for

Solution

Vérification de l'appartenance avec `in`

Parcours d'un ensemble avec une boucle `for`