Participer au site avec un Tip
Rechercher
 

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 :

La boucle for et les instructions break et continue

La boucle while L'instruction assert


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

La vidéo

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.


La boucle for et les instructions break et continue.

Parcours d'une collection via l'instruction for

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)
Utilisation d'un for sur une liste Python

Et voici le résultat produit par cet exemple.

$> python sample.py
10
20
30
40
50
$>
vous pourriez, bien entendu, faire la même chose avec la boucle 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)
Utilisation d'un for sur d'autres collections

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
$>

Utilisation du for conjointement avec un range

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)
Un premier exemple d'utilisation d'un range

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}")
Comparaison entre le parcours d'une range et d'une liste

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
$>
regardez bien le gain mémoire relatif à l'utilisation du range. Un range est fondamentalement un algorithme alors qu'une liste est à proprement parler un ensemble de valeurs.

Pour être plus précis, un range peut prendre jusqu'à trois paramètres : range(start, stop, step).

la valeur de départ, celle d'arrivée ainsi que le pas doivent impérativement être des valeurs numériques entières. Il est impossible de spécifier des valeurs flottantes ! Si vous avez besoin de manipuler des valeurs flottantes, sachez que la librairie « Numpy » fournie la fonction 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)
Quelques autres exemples d'utilisation de ranges

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
$>

Quelques outils bien utiles

TODO : (enumerate / zip)

Utilisation de l'instruction break dans une boucle for

TODO

Utilisation de l'instruction continue dans une boucle for

TODO

Travaux pratiques

Les énoncés

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]
]
Une liste de listes de valeurs numériques

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)
Les tuples de données à utiliser

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. ;-)

Les corrections

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)
Correction de l'exercice 1

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)
Correction de l'exercice 2


La boucle while L'instruction assert