Summary  
This chapter explains how to define and manipulate Python sets—unordered, mutable collections that automatically enforce element uniqueness—by using curly-brace literals or the set() constructor and highlights rules for handling duplicates and required input types.

General domain of usage  
Data deduplication

Un **ensemble** en Python est une **collection non ordonnée d’éléments uniques**. Contrairement aux listes ou aux tuples, les ensembles **n’autorisent pas les éléments dupliqués**, ce qui les rend idéaux pour des opérations telles que la suppression de doublons ou la réalisation d’opérations mathématiques sur les ensembles. Les ensembles sont **mutables**, ce qui signifie que leurs éléments peuvent être ajoutés ou supprimés, mais les **données à l’intérieur de l’ensemble doivent être immuables** (par exemple, nombres, chaînes de caractères ou tuples).

Un ensemble ne peut pas contenir de dictionnaires ou de listes car ce sont des types de données mutables.

Remarque

Il existe deux principales façons de créer un ensemble en Python :
1. Utiliser des accolades `{}` avec des éléments séparés par des **virgules** ;
2. Utiliser la fonction `set()`.

Voici quelques points clés concernant les ensembles :
 - **Ils sont mutables :** il est possible d’ajouter ou de supprimer des éléments d’un ensemble, mais l’ensemble lui-même doit contenir des éléments immuables ;
 - **Éléments dupliqués :**
si des éléments dupliqués sont ajoutés à un ensemble, ils sont automatiquement supprimés ;
 - **Non ordonné :**
l’ordre des éléments dans un ensemble n’est pas garanti et peut varier ;
 - **Types de données variés :**
les ensembles peuvent contenir des éléments de différents types de données, tels que des **chaînes de caractères**, des **entiers** ou des **tuples**.

Définition d’un ensemble à l’aide de la fonction `set()` :

# Creating a set which contains strings
movie_set = set("Interstellar")
print(movie_set)

Ensuite, définition d'un ensemble de films populaires à l'aide d'accolades :

# Creating a set of movies using curly braces
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Tenet"}
print(movies)

Les entrées dupliquées comme `"Tenet"` sont automatiquement supprimées lors de la création de l'ensemble.

### Limitations lors de la création d'ensembles
La syntaxe pour créer un ensemble en utilisant la fonction `set()` comporte des exigences spécifiques. Si vous essayez de passer plusieurs arguments directement, comme :
``` python
set("Tenet", "Dunkirk", "Inception")
```
Vous obtiendrez une `TypeError`, car la fonction `set()` attend un **seul itérable** comme argument, et non plusieurs valeurs séparées.

Pour créer un ensemble avec plusieurs éléments, il faut les fournir sous forme d'un seul itérable :

# Using a list `[]`
movies = set(["Tenet", "Dunkirk", "Inception"])
print(movies)

# Using a tuple `(,)`
movies = set(("Tenet", "Dunkirk", "Inception"))
print(movies)

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

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

    def test_nolan_movies_contains_correct_values(self):
        import user_code
        expected_movies = {"Inception", "The Dark Knight", "Interstellar", "Tenet"}
        _dynamic_test(
            self,
            user_code.nolan_movies == expected_movies,
            f"The `nolan_movies` contains `{expected_movies}`.",
            f"Expected `nolan_movies` to contain `{expected_movies}`, but got `{user_code.nolan_movies}`."
        )

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 problèmes de programmation concrets.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée pouvant ê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 faciles à comprendre 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 hautement efficace pour déterminer si un élément existe dans l'ensemble.

Création d'un Ensemble en Python : Définition des Collections Non Ordonnées

Limitations lors de la création d'ensembles

Solution