Summary  
Demonstrates using a set’s add() method to insert single elements into a set collection.

General domain of usage  
Managing a list of unique favorite movies.

Il est également possible d’ajouter des éléments à un ensemble. Pour cela, il existe une méthode spécifique : `add()`. Il est important de noter qu’avec cette méthode, il est possible d’ajouter **un seul élément** à la fois. Ainsi, si vous souhaitez ajouter 4 éléments, par exemple, il faudra utiliser cette méthode 4 fois. Voici un exemple.

# Creating an empty set
favorite_movies = set()
print("Initial set:", favorite_movies)  # Output - Initial set: set()

# Adding movies to the set
favorite_movies.add("Inception")
favorite_movies.add("Interstellar")
favorite_movies.add("Tenet")
favorite_movies.add("Dunkirk")

print("Updated set:", favorite_movies)  # Output - Updated set: {'Interstellar', 'Dunkirk', 'Inception', 'Tenet'}

La méthode `add()` est particulièrement adaptée pour l’ajout d’**éléments uniques**.

import unittest
import importlib
import ast

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 AddCallVisitor(ast.NodeVisitor):
    def __init__(self):
        self.add_calls = 0
    def visit_Call(self, node):
        # Check for method calls: something.add(...)
        if isinstance(node.func, ast.Attribute):
            if node.func.attr == 'add':
                self.add_calls += 1
        self.generic_visit(node)

class TestUserCode(unittest.TestCase):
    def test_tarantino_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'tarantino_movies'),
            "The `tarantino_movies` set is declared.",
            "Expected `tarantino_movies` to be declared."
        )

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

    def test_tarantino_movies_contains_initial_movies(self):
        import user_code
        initial_movies = {
            'Pulp Fiction',
            'Kill Bill: Vol. 1',
            'Kill Bill: Vol. 2',
            'Inglourious Basterds',
            'Django Unchained'
        }
        _dynamic_test(
            self,
            initial_movies.issubset(user_code.tarantino_movies),
            f"The `tarantino_movies` contains the initial movies: {initial_movies}.",
            f"Expected `tarantino_movies` to contain the initial movies: {initial_movies}, but got {user_code.tarantino_movies}."
        )

    def test_tarantino_movies_contains_new_movies(self):
        import user_code
        new_movies = {'Reservoir Dogs', 'Once Upon a Time in Hollywood'}
        _dynamic_test(
            self,
            new_movies.issubset(user_code.tarantino_movies),
            f"The `tarantino_movies` contains the newly added movies: {new_movies}.",
            f"Expected `tarantino_movies` to contain the newly added movies: {new_movies}, but got {user_code.tarantino_movies}."
        )

    def test_add_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        try:
            tree = ast.parse(user_code_source)
            visitor = AddCallVisitor()
            visitor.visit(tree)
            add_call_count = visitor.add_calls
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Error during AST parsing: {e}"
            )
            return
        _dynamic_test(
            self,
            add_call_count >= 2,
            "The `add()` method is called at least twice to add new movies.",
            f"Expected the `add()` method to be called at least twice, but found only {add_call_count} call(s)."
        )

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 réels.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée qui peut être modifiée. Elle permet également la présence d'éléments en double.

Qu'est-ce qu'un dictionnaire ? Un dictionnaire est une collection ordonnée et modifiable qui n'autorise pas les doublons. Il se compose de paires clé:valeur, utilisées pour optimiser sa structure.

Qu'est-ce qu'un tuple ? Un tuple est une collection ordonnée qui ne peut pas être modifiée. Il peut contenir des éléments dupliqués. Bien qu'il soit similaire à une liste, les valeurs d'un tuple peuvent être de tout type et sont indexées par des entiers. Bien que cela ne soit pas obligatoire, il est courant d'entourer les valeurs d'un tuple de parenthèses, ce qui les rend plus compréhensibles en Python.

Qu'est-ce qu'un ensemble ? En Python, un ensemble est une collection non ordonnée, à la fois itérable et mutable, sans éléments répétés. Bien que l'ordre des éléments dans un ensemble ne soit pas fixe, il peut inclure une variété d'éléments. Un avantage clé de l'utilisation des ensembles par rapport aux listes est leur méthode très efficace pour déterminer si un élément existe dans l'ensemble.

Ajout d'Éléments Uniques à un Ensemble

Solution