En programmation Python, la compréhension et l’utilisation efficace des itérables sont fondamentales pour un codage efficace. Les itérables sont des objets sur lesquels vous pouvez itérer ou faire une boucle. Ils permettent de parcourir séquentiellement les éléments qu’ils contiennent, ce qui en fait un outil essentiel pour accéder à des éléments dans des objets ou des structures de données et les manipuler.

Cet article explique comment utiliser correctement les itérables Python en se concentrant sur les types de données itérables intégrés au langage : les listes, les tuples, les dictionnaires, les chaînes et les ensembles. Il explique également comment implémenter des types d’itérables personnalisés et effectuer des opérations avancées.

Comment effectuer des boucles dans les itérables de Python

En Python, vous pouvez parcourir divers types d’itérables à l’aide d’une boucle for. Cela vous permet de naviguer dans des séquences et d’effectuer des opérations sur des éléments individuels au sein de listes, d’ensembles et de dictionnaires.

Le mot-clé for de Python diffère de son utilité dans d’autres langages orientés objet comme Java. Les boucles de Python for fonctionnent davantage comme des méthodes d’itérateur. Voici des exemples de boucles dans des itérables :

1. Boucle dans une liste

Les listes sont des collections ordonnées d’éléments, ce qui permet une itération facile à l’aide d’une boucle for.

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]

for fruit in fruits_list:
    print(fruit)

Dans le code ci-dessus, fruit agit comme un itérateur que la boucle utilise pour parcourir chaque élément de la liste tout en les imprimant simultanément. La boucle se termine après avoir évalué le dernier élément de la liste. Le code ci-dessus devrait produire la sortie suivante :

Apple
Mango
Peach
Orange
Banana

2. Itérer dans un n-uplet

Les n-uplets (ou tuples) sont similaires aux listes, mais ils sont immuables. Vous pouvez les parcourir comme des listes.

fruits_tuple = ("Apple", "Mango", "Peach", "Orange", "Banana")

for fruit in fruits_tuple:
	print(fruit)

Dans cet exemple, la boucle for parcourt le n-uplet et, à chaque itération, la variable fruit prend la valeur de l’élément actuel du n-uplet. Le code devrait donner la sortie suivante :

Apple
Mango
Peach
Orange
Banana

3. Boucler sur des ensembles

Les ensembles sont des collections non ordonnées d’éléments uniques. Vous pouvez les parcourir à l’aide d’une boucle for.

fruits_set = {"Apple", "Mango", "Peach", "Orange", "Banana"}

for fruit in fruits_set:
	print(fruit)

Dans cet exemple, la boucle for parcourt l’ensemble. Toutefois, comme les ensembles ne sont pas ordonnés, l’ordre d’itération peut être différent de l’ordre dans lequel les éléments ont été définis dans l’ensemble. À chaque itération, la variable fruit prend la valeur de l’élément actuel de l’ensemble. Le code doit produire un résultat similaire à ce qui suit (l’ordre peut varier) :

Mango
Banana
Peach
Apple
Orange

4. Itération sur des chaînes

Les chaînes de caractères sont des séquences de caractères que vous pouvez parcourir en boucle, caractère par caractère.

string = "Kinsta"

for char in string:
	print(char)

Le code ci-dessus parcourt la chaîne « Kinsta » et imprime chaque caractère sur une nouvelle ligne. À chaque itération, la variable char prend la valeur du caractère courant de la chaîne. Le code devrait produire la sortie suivante :

K
i
n
s
t
a

5. Traverser un dictionnaire

L’utilisation de la boucle for est similaire pour les listes, les ensembles, les tuples et les chaînes, mais elle est différente pour les dictionnaires puisqu’ils utilisent des paires clé-valeur pour stocker les éléments. Les dictionnaires présentent un cas unique pour la boucle, car vous pouvez les itérer en utilisant différentes approches. Voici les différentes approches que vous pouvez utiliser pour parcourir un dictionnaire Python :

  • Itération à travers les clés : 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for country in countries_capital.keys():
    print(country)

    Le code ci-dessus définit un dictionnaire appelé countries_capital, dans lequel les noms de pays sont les clés et leurs capitales respectives sont les valeurs. La boucle for parcourt les clés du dictionnaire countries_capital à l’aide de la méthode keys(). Cette méthode renvoie un objet de vue qui affiche une liste des clés du dictionnaire, ce qui permet de parcourir facilement toutes les clés. À chaque itération, la variable country prend la valeur de la clé actuelle. Ce code devrait produire la sortie suivante :

    USA
Australia
France
Egypt
Japan
  • Itération à travers les valeurs : 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for capital in countries_capital.values():
    print(capital)

    Dans le code ci-dessus, for parcourt les valeurs du dictionnaire countries_capital à l’aide de la méthode values(). Cette méthode renvoie un objet View qui affiche une liste des valeurs du dictionnaire, ce qui permet de parcourir facilement toutes les valeurs. À chaque itération, la variable capital prend la valeur de la valeur courante dans la liste. Ce code devrait produire le résultat suivant :

    Washington D.C.
Canberra
Paris
Cairo
Tokyo
  • Itération à travers les paires clé-valeur : 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for country, capital in countries_capital.items():
    print(country, ":", capital)

    Le code ci-dessus montre comment parcourir les clés et les valeurs du dictionnaire countries_capital à l’aide de la méthode items(). La méthode items() renvoie un objet de vue qui affiche une liste de tuples clé-valeur dans le dictionnaire. Dans la boucle for, chaque itération décompresse une paire clé-valeur à partir de l’élément actuel de la liste. Les variables country et capital reçoivent respectivement la clé et la valeur correspondantes. Ce code devrait produire le résultat suivant :

    USA : Washington D.C.
Australia : Canberra
France : Paris
Egypt : Cairo
Japan : Tokyo

Itération avancée avec enumerate() en Python

La fonction enumerate() est un autre moyen d’itérer sur des tables itératives Python en renvoyant à la fois l’index et la valeur correspondante des éléments. Regardez cet exemple :

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]

for index, fruit in enumerate(fruits_list):
    print(fruit, index)

Voici le résultat :

Apple 0
Mango 1
Peach 2
Orange 3
Banana 4

La fonction enumerate vous permet également de spécifier l’indice de départ, en plus de 0, pour l’opération d’itération. Vous pouvez modifier l’exemple ci-dessus comme suit :

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]
for index, fruit in enumerate(fruits_list, start = 2):
    print(fruit, index)

Voici le résultat :

Apple 2
Mango 3
Peach 4
Orange 5
Banana 6

Notez que bien que cet exemple spécifie l’index de départ de l’énumération, enumerate n’applique pas d’indexation basée sur zéro à l’itérable, comme c’est le cas avec les listes natives. Il ajoute simplement la valeur de départ au premier élément de la liste jusqu’au dernier.

Comment mettre en œuvre les générateurs Python

Les générateurs sont des itérables Python spéciaux qui vous permettent de construire des objets générateurs sans créer explicitement des types intégrés tels que des listes, des ensembles ou des dictionnaires. Vous pouvez utiliser les générateurs pour produire des valeurs au fur et à mesure en fonction de la logique de génération.

Les générateurs utilisent l’instruction yield pour renvoyer les valeurs générées une par une. Voici un exemple de générateurs itérables :

def even_generator(n):
    counter = 0
    while counter <= n:
        if counter % 2 == 0:
            yield counter
        counter += 1

for num in even_generator(20):
    print(num)

Le code fourni définit une fonction even_generator qui produit une séquence de nombres pairs de 0 à une valeur spécifiée n à l’aide de l’instruction yield. Il utilise une boucle pour générer ces valeurs et itère à travers le résultat à l’aide de l’itérateur num, en s’assurant de l’évaluation de toutes les valeurs dans la plage donnée. Ce code produit une liste de nombres pairs de 0 à 20, comme indiqué ci-dessous :

0
2
4
6
8
10
12
14
16
18
20

Vous pouvez être encore plus concis lorsque vous travaillez avec des expressions de générateur. Par exemple, vous pouvez concevoir une fonction de générateur qui intègre également une logique de boucle :

cube = (num ** 3 for num in range(1, 6))
for c in cube:
    print(c)

Ici, vous affectez la variable cube au résultat d’une fonction qui calcule le cube des valeurs comprises entre 1 et 6. La fonction passe ensuite en boucle par les valeurs comprises dans l’intervalle spécifié, en produisant les résultats du calcul, l’un après l’autre. Le résultat est le suivant :

1
8
27
64
125

Comment construire des itérables personnalisés

Python vous permet de personnaliser davantage les opérations itérables en utilisant des itérateurs. Les objets itérateurs mettent en œuvre le protocole itérateur et contiennent deux méthodes : __iter__() et __next__(). La méthode __iter__() renvoie un objet itérateur, tandis que __next__() renvoie la valeur suivante dans un conteneur itérable. Voici un exemple d’itérateur en Python :

even_list = [2, 4, 6, 8, 10]
my_iterator = iter(even_list)
print(next(my_iterator)) # Prints 2
print(next(my_iterator)) # Prints 4
print(next(my_iterator)) # Prints 6

Dans cet exemple, vous utilisez la méthode iter() pour créer un objet itérateur (my_iterator) à partir de la liste. Pour accéder à chacun des éléments de la liste, vous enveloppez l’objet itérateur avec la méthode next(). Les listes étant des collections ordonnées, l’itérateur renvoie les éléments de manière séquentielle.

Les itérateurs personnalisés sont idéaux pour les opérations impliquant de grands ensembles de données que vous ne pouvez pas charger simultanément en mémoire. La mémoire étant coûteuse et sujette à des contraintes d’espace, vous pouvez utiliser un itérateur pour traiter les éléments de données individuellement sans charger l’ensemble des données en mémoire.

Fonctions itérables

Python utilise des fonctions pour se déplacer, manipuler et inspecter les éléments d’une liste. Les fonctions de liste les plus courantes sont les suivantes

  • sum – Renvoie la somme d’un itérable donné, à condition que la collection soit de type numérique (entiers, valeurs à virgule flottante et nombres complexes)
  • any – Renvoie true si l’un des éléments de l’itérable est vrai. Sinon, il renvoie false.
  • all – Renvoie true si tous les éléments de l’itérable sont vrais. Dans le cas contraire, il renvoie false.
  • max – Renvoie la valeur maximale d’une collection itérable donnée
  • min – Renvoie la valeur minimale d’une collection itérable donnée
  • len – Renvoie la longueur d’un itérable donné
  • append – Ajoute une valeur à la fin d’une liste itérable

L’exemple ci-dessous illustre ces fonctions à l’aide d’une liste :

even_list = [2, 4, 6, 8, 10]

print(sum(even_list))
print(any(even_list))
print(max(even_list))
print(min(even_list))
even_list.append(14) # Add 14 to the end of the list
print(even_list)
even_list.insert(0, 0) # Insert 0 and specified index [0]
print(even_list)
print(all(even_list)) # Return true only if ALL elements in the list are true
print(len(even_list)) # Print the size of the list

Voici le résultat :

30
True
10
2
[2, 4, 6, 8, 10, 14]
[0, 2, 4, 6, 8, 10, 14]
False
7

Dans l’exemple ci-dessus, la fonction append ajoute un seul paramètre (14) à la fin de la liste. La fonction insert permet de spécifier l’indice d’insertion. Par conséquent, even_list.insert(0, 0) insère 0 à l’index [0].
L’instruction print(all(even_list)) renvoie false car il existe une valeur 0 dans la liste, interprétée comme false. Enfin, print(len(even_list)) affiche la longueur de l’itérable.

Opérations avancées sur les itérables

Python offre des fonctionnalités avancées qui favorisent la concision des opérations sur les itérables. En voici quelques-unes.

1. Compréhension de listes

Les compréhensions de listes vous permettent de créer de nouvelles listes en appliquant une fonction à chaque élément d’une liste existante. Voici un exemple :

my_numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
even_number_list = [num for num in my_numbers if num%2 == 0]
print(even_number_list)

Dans cet extrait de code, une liste nommée my_numbers est créée avec des nombres entiers allant de 11 à 20. L’objectif est de générer une nouvelle liste, even_number_list, contenant uniquement des nombres entiers pairs. Pour ce faire, appliquez une compréhension de liste qui renvoie un entier de my_numbers uniquement si cet entier est pair. L’instruction if contient la logique qui renvoie les nombres pairs.

Voici le résultat :

[12, 14, 16, 18, 20]

2. Zip

La fonction zip() de Python combine plusieurs itérables en tuples. Les tuples stockent plusieurs valeurs dans une seule variable et sont immuables. Voici comment combiner des itérables à l’aide de zip():

fruits = ["apple", "orange", "banana"]
rating = [1, 2, 3]

fruits_rating = zip(rating, fruits)
print(list(fruits_rating))

Dans cet exemple, fruits_rating associe chaque note à un fruit, créant ainsi une seule table itérative. Le résultat est le suivant :

[(1, 'apple'), (2, 'orange'), (3, 'banana')]

Ce code agit comme un système d’évaluation pour différents fruits, la première liste (fruits) représentant les fruits et la deuxième liste représentant les évaluations sur une échelle de 1 à 3.

3. Filtre

Une autre fonction avancée, filter, prend deux arguments – une fonction et une table itérative. Elle applique la fonction à chaque élément de l’itérable, puis renvoie un nouvel itérable contenant uniquement les éléments pour lesquels la fonction renvoie une valeur true. L’exemple suivant filtre une liste de valeurs entières dans un intervalle donné pour ne renvoyer que les valeurs paires :

def is_even(n):
    return n%2 == 0

nums_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_list = filter(is_even, nums_list)
print(list(even_list))

Dans le code ci-dessus, vous commencez par définir une fonction, is_even, pour calculer un nombre pair qui lui est transmis. Ensuite, vous créez une liste de valeurs entières comprises entre 1 et 10 – nums_list. Enfin, vous définissez une nouvelle liste, even_list, qui utilise la fonction filter() pour appliquer la méthode définie par l’utilisateur à la liste originale et ne renvoyer que les éléments pairs de la liste. Voici le résultat :

[2, 4, 6, 8, 10]

4. Carte

Comme filter(), la fonction map() de Python prend un itérable et une fonction comme arguments. Mais au lieu de renvoyer des éléments de l’itérable initial, elle renvoie un nouvel itérable contenant le résultat de la fonction appliquée à chaque élément du premier itérable. Pour élever au carré une liste d’entiers, utilisez la fonction map():

my_list = [2, 4, 6, 8, 10]
square_numbers = map(lambda x: x ** 2, my_list)
print(list(square_numbers))

Dans ce code, x est l’itérateur qui parcourt la liste et la transforme par le calcul du carré. La fonction map() exécute cette opération en prenant la liste d’origine comme argument ainsi qu’une fonction de mise en correspondance. Le résultat est le suivant :

[4, 16, 36, 64, 100]

5. Trié

La fonction sorted trie les éléments d’un itérable donné dans un ordre spécifique (croissant ou décroissant) et les renvoie sous forme de liste. Elle prend un maximum de 3 paramètres – iterable, reverse(optionnel), et key(optionnel). Ensuite, reverse prend par défaut la valeur False, et si elle prend la valeur True, les éléments sont triés dans l’ordre décroissant. key est une fonction qui calcule une valeur pour déterminer l’ordre de tri de l’élément dans un itérable et prend par défaut la valeur None.

Voici un exemple de la manière dont vous pouvez appliquer la fonction sorted à différentes tables itératives :

# set
py_set = {'e', 'a', 'u', 'o', 'i'}
print(sorted(py_set, reverse=True))

# dictionary
py_dict = {'e': 1, 'a': 2, 'u': 3, 'o': 4, 'i': 5}
print(sorted(py_dict, reverse=True))

# frozen set
frozen_set = frozenset(('e', 'a', 'u', 'o', 'i'))
print(sorted(frozen_set, reverse=True))

# string
string = "kinsta"
print(sorted(string))

# list
py_list = ['a', 'e', 'i', 'o', 'u']
print(py_list)

Vous obtenez le résultat suivant :

['u', 'o', 'i', 'e', 'a']
['u', 'o', 'i', 'e', 'a']
['u', 'o', 'i', 'e', 'a']
['a', 'i', 'k', 'n', 's', 't']
['a', 'e', 'i', 'o', 'u']

Comment gérer les cas limites et les erreurs dans les itérabilités

Les cas limites sont fréquents dans de nombreux scénarios de programmation, et vous devez les anticiper dans les itérables. Examinons quelques possibilités que vous pouvez rencontrer.

1. Itérables vides

Vous pouvez rencontrer des problèmes lorsqu’une table itérative est vide, mais qu’une logique de programmation tente de la traverser. Vous pouvez résoudre ce problème de manière programmatique afin d’éviter toute inefficacité. Voici un exemple utilisant une instruction if not pour vérifier si une liste est vide :

fruits_list=[]
if not fruits_list:
    print("The list is empty")

Voici le résultat :

The list is empty

2. Itérables imbriqués

Python prend également en charge les itérables imbriqués, qui sont des objets itérables contenant d’autres itérables à l’intérieur d’eux. Par exemple, vous pouvez avoir une liste d’aliments contenant des listes imbriquées de catégories d’aliments, telles que les viandes, les légumes et les céréales. Voici comment modéliser un tel scénario à l’aide d’itérables imbriqués :

food_list = [["kale", "broccoli", "ginger"], ["beef", "chicken", "tuna"], ["barley", "oats", "corn"]]
for inner_list in food_list:
    for food in inner_list:
        print(food)

Dans le code ci-dessus, la variable food_list contient trois listes imbriquées, représentant différentes catégories d’aliments. La boucle externe (for inner_list in food_list:) parcourt la liste primaire et la boucle interne (for food in inner_list:) parcourt chaque liste imbriquée, en imprimant chaque aliment. La sortie est la suivante :

kale
broccoli
ginger
beef
chicken
tuna
barley
oats
corn

3. Gestion des exceptions

En Python, les itérables prennent également en charge les opérations de gestion des exceptions. Par exemple, vous pouvez itérer sur une liste et rencontrer une erreur IndexError. Cette erreur signifie que vous essayez de référencer un élément qui dépasse les limites de l’itérable. Voici comment gérer une telle exception à l’aide d’un bloc try-except:

fruits_list = ["apple", "mango", "orange", "pear"]
try:
    print(fruits_list[5])
except IndexError:
    print("The index specified is out of range.")

Dans le code ci-dessus, l’itérable fruits_list contient cinq éléments correspondant aux indices 0 et 5 dans la collection de listes. La phrase try contient une fonction print qui tente d’afficher la valeur à l’index 5 de l’itérable, qui n’existe pas. Cette fonction exécute la fonction except clause, returning the associated error message. The console returns the error:

The index specified is out of range.

Résumé

La maîtrise de l’itération en Python est cruciale pour un code efficace et lisible. Comprendre les différentes façons d’itérer sur différentes structures de données, en utilisant les compréhensions, les générateurs et en exploitant les fonctions intégrées, fait de vous un programmeur Python compétent.

Que vous travailliez avec des listes, des dictionnaires, des chaînes de caractères ou des objets personnalisés, savoir comment utiliser et manipuler les itérables est une compétence indispensable dans la programmation Python.

Lorsque vous aurez terminé la construction de votre application Python et que vous souhaiterez l’héberger en ligne, essayez l’hébergement d’applications de Kinsta. Vos premiers 20 $ sont offerts !

Nous avons oublié quelque chose dans ce guide ? N’hésitez pas à nous en faire part dans la section des commentaires ci-dessous !

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).