Skip to content

TP5. Boucles for

Énoncé

Contrairement à une boucle tant que qui s'arrête sur une condition, une boucle pour en python permet de parcourir un ensemble d'éléments. Bien que ce type de boucle soit tout à fait intuitif, de nombreuses opérations ont lieu dans notre dos dès lors que l'on l'utilise la construction for X in Y en python.

Ce sont ces opérations cachées qui nous permettent de parcourir à l'aide d'une simple boucle for :

  • un ensemble de nombres (range dans la terminologie python) pour obtenir les nombres un à un ;
  • une chaîne de caractères pour obtenir les caractères un à un ;
  • un tuple pour obtenir les éléments qui le composent un à un ;
  • un vecteur (c'est-à-dire une list dans la terminologie python) pour obtenir les éléments qui la composent un à un ;
  • un fichier ouvert avec open pour obtenir les lignes qu'il contient une par une.

Nous ne rentrerons pas dans le détail des opérations cachées pour le moment. L'objectif de cet exercice est simplement d'utiliser des boucles for pour afficher un à un les éléments (caractère ou nombre) contenus dans les variables ci-dessous :

1
2
3
4
5
6
7
var1 = "123"
var2 = [1, 2, 3]
var3 = (1, 2, 3)
var4 = range(1, 4)
var5 = ["toto", range(3), ["t", "o", "t", "o"]]
var6 = ([1, 2, 3], [4, 5, 6])
var7 = [[[1, 2], [3, 4]], [[5, 6]]]

Difficulté

star star

Correction

Cliquez ici pour révéler la correction de l'exercice. ### Corrigé du fichier `for.py`
 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#!/usr/bin/env python3
"""exemples d'utilisation de boucle for"""

# Les variables que l'on souhaite parcourir
var1 = "123"
var2 = [1, 2, 3]
var3 = (1, 2, 3)
var4 = range(1, 4)
var5 = ["toto", range(3), ["t", "o", "t", "o"]]
var6 = ([1, 2, 3], [4, 5, 6])
var7 = [[[1, 2], [3, 4]], [[5, 6]]]

# Variables à une dimension --> une seule boucle
print("éléments de var1 :")
for car in var1:
    print("  " + car)

print("éléments de var2 :")
for nb in var2:
    print("  " + str(nb))

print("éléments de var3 :")
for nb in var3:
    print("  " + str(nb))

print("éléments de var4 :")
for nb in var4:
    print("  " + str(nb))

# Variables à deux dimensions --> deux boucles
print("éléments de var5 :")
for sous_ensemble in var5:
    for element in sous_ensemble:
        print("  " + str(element)) # l'appel à str est nécessaire, pourquoi ?

print("éléments de var6 :")
for sous_ensemble in var6:
    for element in sous_ensemble:
        print("  " + str(element))

# Variable à trois dimensions --> trois boucles
print("éléments de var7 :")
for sous_ensemble in var7:
    for sous_sous_ensemble in sous_ensemble:
        for element in sous_sous_ensemble:
            print("  " + str(element))

# Pour factoriser notre code, grace au typage dynamique
# du langage python, nous pourrions définir des fonctions
# de parcours de dimension donnée

def parcourt_une_dimension(a_parcourir):
    """Parcourt une variable de dimension 1"""
    for elem in a_parcourir:
        print("  " + str(elem))

def parcourt_deux_dimensions(a_parcourir):
    """Parcourt une variable de dimension 2"""
    for sous_ens in a_parcourir:
        for elem in sous_ens:
            print("  " + str(elem))

def parcourt_trois_dimensions(a_parcourir):
    """Parcourt une variable de dimension 3"""
    for sous_ens in a_parcourir:
        for sous_sous_ens in sous_ens:
            for elem in sous_sous_ens:
                print("  " + str(elem))

# Et ensuite utiliser ces fonctions pour afficher à nouveau
# nos variables

# Variables à une dimension --> une seule boucle
print("éléments de var1 :")
parcourt_une_dimension(var1)
print("éléments de var2 :")
parcourt_une_dimension(var2)
print("éléments de var3 :")
parcourt_une_dimension(var3)
print("éléments de var4 :")
parcourt_une_dimension(var4)

# Variables à deux dimensions --> deux boucles
print("éléments de var5 :")
parcourt_deux_dimensions(var5)
print("éléments de var6 :")
parcourt_deux_dimensions(var6)

# Variables à trois dimensions --> trois boucles
print("éléments de var7 :")
parcourt_trois_dimensions(var7)