Accès rapide :
La vidéo
Parcours d'une collection via l'instruction for
Utilisation du for conjointement avec un range
Quelques outils bien utiles
Utilisation de l'instruction break dans une boucle for
Utilisation de l'instruction continue dans une boucle for
Travaux pratiques
Les énoncés
Les corrections
Cette vidéo vous apprend à utiliser la boucle for
pour parcourir une collection Python. Les instructions break
et continue
,
ainsi que les outils enumerate
et zip
y sont aussi présentés.
Tout comme pour l'instruction précédente (le while
) cela fait déjà quelques temps que nous utilisons l'instruction for
.
Pour autant, je voulais aussi lui consacrer un chapitre et compléter nos connaissances sur certaines possibilités utilisables au sein d'une
boucle for
.
De base, l'instruction for
permet de parcourir toutes les valeurs d'une collection (où de quelque chose d'assimilable à une
collection). Ce premier exemple vous montre comment parcourir toutes les valeurs d'une liste Python.
1 2 3 |
data = [10, 20, 30, 40, 50] for value in data: print(value) |
Et voici le résultat produit par cet exemple.
$> python sample.py 10 20 30 40 50 $>
while
. Mais du coup vous auriez du gérer un index de positionnement.
L'intérêt de la boucle while
est de faire abstraction de cet index, tant que cela reste possible, bien entendu.
Il n'y a pas que les listes qui peuvent être parcourues avec un for
. Cela marche aussi avec les tuples, les sets,
les strings (on peut voir une chaîne comme étant une collection de caractères), ...
Ce nouvel exemple de code montre quelques autres possibilités.
1 2 3 4 5 6 7 8 9 10 |
# Exempple de parcours d'un set data = {10, 20, 30, 10, 20, 30, 4} print(type(data), data) for value in data: print(value) # Exemple de parcours d'une chaîne de caractères for char in "Hello": print(char) |
Et voici le résultat produit par cet exemple.
$> python sample.py <class 'set'> {10, 20, 4, 30} 10 20 4 30 H e l l o $>
Un range en Python est un mécanisme intégré extrêmement utile pour générer des séquences de nombres. L'intérêt principal d'un range réside dans sa simplicité d'utilisation : voici un premier exemple.
1 2 |
for i in range(10): print(i) |
Dans ce premier exemple, une unique valeur est précisé en paramètre du range. Il s'agit de la valeur maximale exclusive : le range va donc parcourir les valeurs de 0 à 9. Voici le résultat produit par cet exemple.
$> python sample.py 0 1 2 3 4 5 6 7 8 9 $>
Il est important de comprendre une chose : un range est efficace en termes de mémoire. Au lieu de générer tous les éléments en une fois, range agit comme une séquence algorithmique paresseuse. Cela signifie que les nombres sont générés à la demande, ce qui économise la mémoire, surtout dans les grandes séquences. C'est un avantage notable par rapport à l'utilisation de listes explicites qui peuvent devenir très gourmandes en mémoire pour de grandes plages de nombres.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import sys print("--- Utilisation d'un range ------------------------------") r = range(1_000_000) print(f"Type : {type(r)}") print(f"Place mémoire occupée en octets : {sys.getsizeof(r)}") counter = 0 for i in r: counter += 1 print(f"Nombre d'itérations effectuées : {counter}") print("--- Utilisation d'une list ------------------------------") l = list(r) print(f"Type : {type(l)}") print(f"Place mémoire occupée en octets : {sys.getsizeof(l)}") counter = 0 for i in l: counter += 1 print(f"Nombre d'itérations effectuées : {counter}") |
Et voici les résultats produits par cet exemple de code.
$> python sample.py --- Utilisation d'un range ------------------------------ Type : <class 'range'> Place mémoire occupée en octets : 48 Nombre d'itérations effectuées : 1000000 --- Utilisation d'une list ------------------------------ Type : <class 'list'> Place mémoire occupée en octets : 8000056 Nombre d'itérations effectuées : 1000000 $>
Pour être plus précis, un range peut prendre jusqu'à trois paramètres : range(start, stop, step)
.
np.arange
qui fonctionne un peu pareil (sauf que cela produit une collection),
mais avec la possibilité d'utiliser des valeurs entières ou flottantes.
Voici quelques exemples d'utilisation.
1 2 3 4 5 6 7 8 9 10 11 |
print("--- on spécifie start et end ------------") for i in range(1, 11): print(i) print("--- on spécifie start, end et un step ---") for i in range(0, 10, 2): print(i) print("--- Un step négatif ---------------------") for i in range(8, -1, -2): print(i) |
Et voici les résultats produits par cet exemple de code.
$> python sample.py --- on spécifie start et end ------------ 1 2 3 4 5 6 7 8 9 10 --- on spécifie start, end et un step --- 0 2 4 6 8 --- Un step négatif --------------------- 8 6 4 2 0 $>
TODO : (enumerate / zip)
Exercice 1 : l'exemple de code ci-dessous définit une liste de listes de valeurs numériques (dit autrement une matrice de valeurs).
Veuillez calculer la somme de toutes less valeurs contenues dans cette matrice en utilisant deux boucles for
: le résultat devrait être 662.
Puis écrire une autre version différente du programme (au choix).
1 2 3 4 5 6 7 |
data = [ [10, 15, 20, 15, 5], [12, 13, 25, 35, 40], [37, 27, 20, 18, 19], [10, 40, 50, 30, 20], [60, 55, 45, 33, 8] ] |
Exercice 2 : en considérant les trois tuples ci-dessous, veuillez afficher ces données sous formes d'un tableau, comme le montre l'exemple
proposé. Nous avions déjà travaillé sur des exemples similaires dans les chapitres précédents : il vous est maintenant demandé d'utiliser l'outil
zip
.
1 2 3 |
city_names = ("Andon", "Caille", "Séranon", "Valderoure") city_latitudes = (43.77348, 43.77887, 43.77435, 43.79629) city_longitudes = (6.78596, 6.72979, 6.70415, 6.70749) |
Et voici l'affichage souhaité :
+---------------+---------------+---------------+ | Ville | Latitude | Longitude | +---------------+---------------+---------------+ | Andon | 43.77348 | 6.78596 | | Caille | 43.77887 | 6.72979 | | Séranon | 43.77435 | 6.70415 | | Valderoure | 43.79629 | 6.70749 | +---------------+---------------+---------------+
Comme toujours, essayez de faire ces exercices sans regarder directement la correction ci-dessous. ;-)
Exercice 1 : voici deux techniques pour sommer les valeurs numériques comprises dans une liste de listes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
data = [ [10, 15, 20, 15, 5], [12, 13, 25, 35, 40], [37, 27, 20, 18, 19], [10, 40, 50, 30, 20], [60, 55, 45, 33, 8] ] # Une première version en utilisant deux boucles for. total = 0 for line in data: for value in line: total += value print("Total =", total) # Une seconde version en utilisant la fonction sum et une liste en compréhension. total = sum([sum(line) for line in data]) print("Total =", total) |
Et voici le résultat produit par cet exemple.
Total = 662 Total = 662
Exercice 2 : voici comment traiter les données contenues dans nos trois tuples de manière cohérente en utilisant l'outil zip
.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
city_names = ("Andon", "Caille", "Séranon", "Valderoure") city_latitudes = (43.77348, 43.77887, 43.77435, 43.79629) city_longitudes = (6.78596, 6.72979, 6.70415, 6.70749) separator = f"+{'-' * 15}+{'-' * 15}+{'-' * 15}+" header = f"| {'Ville':13s} | {'Latitude':>13s} | {'Longitude':>13s} |" print(separator) print(header) print(separator) for city, lat, long in zip(city_names, city_latitudes, city_longitudes): print(f"| {city:13s} | {lat:13.5f} | {long:13.5f} |") print(separator) |
Améliorations / Corrections
Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.
Emplacement :
Description des améliorations :