Comment itérer sur un ensemble en Python

Les ensembles Python sont des collections non ordonnées d'éléments uniques. Comme ils sont non ordonnés, vous ne pouvez pas accéder aux éléments par index — mais vous pouvez tout de même itérer sur chaque élément avec une boucle for, utiliser des boucles while pour consommer un ensemble, et appliquer des opérations sur les ensembles à l'intérieur des boucles pour résoudre des problèmes courants.

Cette page explique comment parcourir des ensembles en Python, notamment l'itération déterministe avec sorted(), enumerate(), le filtrage avec break et continue, les compréhensions d'ensembles et des cas d'usage pratiques.

Créer un ensemble

Avant d'itérer, vous devez disposer d'un ensemble. Vous pouvez en créer un avec des accolades {} ou avec la fonction intégrée set(). Consultez Python Sets pour une introduction complète.

Créer un ensemble en Python

# Using curly braces
fruits = {'apple', 'banana', 'cherry'}

# Using set() — useful when converting another sequence
numbers = set([1, 2, 2, 3, 4, 4, 5])
print(numbers)   # {1, 2, 3, 4, 5}  — duplicates are removed

Notez que set() appliqué à une liste supprime automatiquement les doublons. L'ordre d'affichage n'est pas garanti.

Parcourir un ensemble avec une boucle For

La façon la plus courante d'itérer sur un ensemble est la boucle for. Python visite chaque élément une fois, mais dans un ordre arbitraire.

Itérer sur un ensemble en Python

python— editable, runs on the server

L'exécution peut afficher :

banana
cherry
apple

L'ordre peut varier à chaque exécution du programme. Si vous avez besoin d'un ordre prévisible, enveloppez l'ensemble dans sorted().

Itérer dans un ordre trié

sorted() renvoie une liste ordinaire contenant les éléments de l'ensemble dans l'ordre croissant. L'ensemble original n'est pas modifié.

Parcourir un ensemble dans l'ordre trié

fruits = {'apple', 'banana', 'cherry'}

for fruit in sorted(fruits):
    print(fruit)

Résultat :

apple
banana
cherry

Utilisez sorted(my_set, reverse=True) pour itérer dans l'ordre décroissant.

Utiliser enumerate() avec un ensemble

enumerate() associe chaque élément à un compteur. Combiné à sorted(), cela vous donne un index stable à côté de chaque élément.

Énumérer un ensemble en Python

fruits = {'apple', 'banana', 'cherry'}

for index, fruit in enumerate(sorted(fruits)):
    print(index, fruit)

Résultat :

0 apple
1 banana
2 cherry

C'est utile lorsque vous devez numéroter des éléments dans un rapport ou les étiqueter dans un pipeline de données.

Boucler avec break et continue

Vous pouvez utiliser break pour arrêter la boucle prématurément et continue pour ignorer des éléments spécifiques.

Utiliser continue pour ignorer des éléments

Ignorer des éléments lors du parcours d'un ensemble

scores = {55, 72, 88, 64}

for score in sorted(scores):
    if score < 60:
        continue       # skip failing scores
    print(score)

Résultat :

64
72
88

Utiliser break pour arrêter tôt

Arrêter une boucle prématurément avec break

scores = {55, 72, 88, 91, 64}

for score in sorted(scores):
    if score >= 90:
        print(f'First score at 90 or above: {score}')
        break

Résultat :

First score at 90 or above: 91

Parcourir un ensemble avec une boucle While

Une boucle while combinée à pop() vous permet de traiter et consommer un ensemble élément par élément. Utilisez ce modèle lorsque vous souhaitez vider l'ensemble au fur et à mesure (par exemple, une file de travaux).

Utiliser une boucle while pour consommer un ensemble

tasks = {'send email', 'write report', 'update database'}

while tasks:
    task = tasks.pop()   # removes and returns an arbitrary element
    print(f'Processing: {task}')

print('All tasks done.')

Résultat (l'ordre peut varier) :

Processing: update database
Processing: write report
Processing: send email
All tasks done.

Après la boucle, tasks est vide. Si vous avez besoin de conserver l'ensemble original intact, travaillez sur une copie : tasks.copy().

Test d'appartenance dans une boucle

L'un des grands atouts des ensembles est le test d'appartenance en O(1). Vérifier item in my_set est bien plus rapide que item in my_list pour les grandes collections, car les ensembles utilisent une table de hachage en interne.

Filtrer une liste en utilisant un ensemble pour des recherches rapides

allowed_roles = {'admin', 'editor', 'viewer'}
users = ['admin', 'guest', 'editor', 'unknown']

for user in users:
    if user in allowed_roles:
        print(f'{user}: access granted')
    else:
        print(f'{user}: access denied')

Résultat :

admin: access granted
guest: access denied
editor: access granted
unknown: access denied

Ce modèle est courant pour les vérifications de permissions, les listes de blocage et le filtrage de données.

Supprimer les doublons d'une liste

Convertir une liste en ensemble à l'intérieur d'une boucle est un moyen rapide de s'assurer que vous ne traitez chaque valeur unique qu'une seule fois.

Supprimer les doublons d'une liste en utilisant un ensemble

my_list = [1, 2, 2, 3, 4, 4, 5]
unique_values = set(my_list)   # duplicates removed

for value in sorted(unique_values):
    print(value)

Résultat :

Itérer sur des opérations d'ensembles

Vous pouvez itérer directement sur le résultat d'une opération d'ensemble — union, intersection, différence — sans créer de variable intermédiaire.

Itérer sur des opérations d'ensembles en Python

python— editable, runs on the server

Résultat :

Intersection:
3
4
Difference (set1 - set2):
1
2
Symmetric difference:
1
2
5
6

Consultez Join Sets pour en savoir plus sur la combinaison d'ensembles et Set Methods pour la liste complète des opérations.

Compréhensions d'ensembles

Une compréhension d'ensemble construit un nouvel ensemble à partir d'une expression en une seule ligne. La syntaxe ressemble aux compréhensions de listes, mais utilise des accolades.

Construire un ensemble avec une compréhension d'ensemble

# Squares of numbers 1 through 5
squares = {x**2 for x in range(1, 6)}
print(sorted(squares))

Résultat :

[1, 4, 9, 16, 25]

Vous pouvez ajouter une condition pour filtrer les éléments :

Compréhension d'ensemble avec un filtre

numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
evens = {n for n in numbers if n % 2 == 0}
print(sorted(evens))

Résultat :

[2, 4, 6, 8, 10]

Les compréhensions d'ensembles sont plus concises qu'une boucle for qui appelle .add() dans le corps, et elles expriment clairement l'intention. Pour les équivalents avec des listes, consultez List Comprehension.

Points clés

Les ensembles sont non ordonnés — ne vous fiez pas à l'ordre d'itération. Utilisez sorted() lorsqu'un ordre stable est nécessaire.
Les ensembles contiennent des éléments uniques — l'itération ignore automatiquement les doublons.
Les vérifications d'appartenance in sur les ensembles sont O(1) — bien plus rapides que sur les listes pour les grandes données.
pop() supprime un élément arbitraire et est utile pour consommer un ensemble dans une boucle while.
Les compréhensions d'ensembles {expr for item in iterable} sont la façon idiomatique de construire un ensemble filtré ou transformé en une seule ligne.

Sujets connexes

Python Sets — créer, ajouter et supprimer des éléments
Add Set Items — méthodes add() et update()
Remove Set Items — remove(), discard() et pop()
Join Sets — union, intersection, différence et plus encore
Set Methods — référence complète de toutes les méthodes d'ensembles
Python For Loops — la boucle for en profondeur
Loop Lists — itérer sur des listes
Loop Tuples — itérer sur des tuples
Loop Dictionaries — itérer sur des dictionnaires

Pratique

Which of the following is true about loop sets in Python?

A loop set is a collection of unchangeable, unordered and indexed items.The set is a built-in Python data type, and it is an unordered collection of unique elements.If you want to loop through a set by using the for-each loop, you can do it by taking an item directly from the set object.Sets in Python are mutable, we can change their items using the add and remove methods.In Python, all the sets are indexed and ordered.