Boucles

Boucle for¶

Une boucle for permet de répéter des instructions un certain nombre de fois :

In [1]:

for i in range(5):
    print(i)  # affiche i pour i variant de 0 à 4

for i in range(5): print(i) # affiche i pour i variant de 0 à 4

0
1
2
3
4

Remarque : on utilise souvent i comme nom de variable, mais on aurait pu l'appeler autrement. Par exemple le code suivant fait exactement la même chose :

for variable in range(5):
    print(variable)

Attention : une boucle for i in range(n) commence à 0 et finit à $n - 1$ (l'indice de fin est toujours exclu en Python).

Exercice

Combien de fois s'exécute une boucle for i in range(n)?

Solution

$n$ fois (c'est aussi le nombre d'entiers dans $\{0, ..., n - 1\}$.

L'exemple suivant permet de calculer la somme des 100 premiers entiers ($0 + 1 + 2 + ... + 99$) :

In [1]:

somme = 0
for k in range(100):
    somme += k  # même chose que somme = somme + k
somme

somme = 0 for k in range(100): somme += k # même chose que somme = somme + k somme

Out[1]:

4950

Exercice

Quelle formule connaissez-vous pour la somme précédente? L'utiliser pour vérifier votre résultat.

Solution

In [8]:

n = 100
n*(n-1)/2  # formule de Gauss

n = 100 n*(n-1)/2 # formule de Gauss

Out[8]:

4950.0

Une variante du range permet de parcourir les entiers de $a$ à $b - 1$ : for i in range(a, b).

In [12]:

for i in range(3, 6):
    print(i)

for i in range(3, 6): print(i)

3
4
5

Exercice

Calculer $\sum_{k = 5}^{20} \sqrt{k}$ (= $\sqrt{5} + \sqrt{6} + ... + \sqrt{20}$).

Solution

In [18]:

somme_racine = 0
for i in range(5, 21):
    somme_racine += i**0.5
somme_racine

somme_racine = 0 for i in range(5, 21): somme_racine += i**0.5 somme_racine

Out[18]:

55.519713441477826

Exercice

Écrire une fonction fact telle que fact(n) renvoie $n!$ ($n$ factorielle), c'est à dire $n\times(n-1)\times ... \times 2 \times1$.

Solution

In [19]:

def fact(n):
    res = 1
    for i in range(2, n+1):
        res *= i  # pareil que res = res * i
    return res

fact(6)

def fact(n): res = 1 for i in range(2, n+1): res *= i # pareil que res = res * i return res fact(6)

Out[19]:

720

Une boucle for est utile pour calculer les termes d'une suite récurrente $u_n$. Pour cela, on définie une variable un valant initialement $u_0$ que l'on remplace par la valeur suivante de la suite dans uen boucle for. Ainsi un prend la valeur de $u_0$, puis $u_1$, $u_2$...

Exercice

Calculer $u_{10}$, où $u_n$ est définie par $u_0 = 42$ et $u_{n+1} = \sqrt{u_n} + 3u_n$.

Solution

In [22]:

un = 42
for _ in range(10):
    un = un**.5 + 3*un
un

un = 42 for _ in range(10): un = un**.5 + 3*un un

Out[22]:

2787204.895558157

Exercice

Calculer $v_n$ défini par : $$v_0 = v_1 = 1$$ $$v_{n + 2} = v_{n + 1} + v_{n}$$

for et liste¶

Pour énumérer les éléments d'une listes, on peut parcourir ses indices :

In [9]:

L = [2, 3, 5, 7, 11]
for i in range(len(L)):  # les indices de L vont de 0 à len(L) - 1
    print(L[i])

L = [2, 3, 5, 7, 11] for i in range(len(L)): # les indices de L vont de 0 à len(L) - 1 print(L[i])

2
3
5
7
11

Lorsqu'on n'a pas besoin des indices, on peut utiliser for e in L (attention toutefois à ne pas confondre indice et élément):

In [5]:

for e in L:
    print(e)

for e in L: print(e)

2
3
5
7
11

Exercice

Écrire une fonction pour calculer la somme des éléments d'une liste.

Solution

In [ ]:

def somme(L):
    res = 0
    for e in L:
        res += e
    return res

def somme(L): res = 0 for e in L: res += e return res

Exercice

Écrire une fonction appartient telle que appartient(x, L) renvoie True si x appartient à la liste L, False sinon.

Solution

In [1]:

def appartient(x, L):
    for e in L:
        if x == e:
            return True
    return False

def appartient(x, L): for e in L: if x == e: return True return False

Exercice

1. Écrire une fonction pour déterminer si une liste est triée par ordre croissant.
2. En déduire une fonction pour savoir si la liste est triée par ordre décroissant. On pourra utiliser not pour la négation.

Solution

In [27]:

# 1.
def croissant(L):
    for i in range(len(L) - 1): # ici on est obligé de parcourir les indices pour comparer 2 éléments consécutifs
        if L[i] > L[i+1]:
            return False
    return True

# 2.
def decroissant(L):
    return not croissant(L)

# 1. def croissant(L): for i in range(len(L) - 1): # ici on est obligé de parcourir les indices pour comparer 2 éléments consécutifs if L[i] > L[i+1]: return False return True # 2. def decroissant(L): return not croissant(L)

  File "<ipython-input-27-2b0e512eade5>", line 1
    (* 1. *)
           ^
SyntaxError: invalid syntax

Par défaut, une boucle for i in range(n) fait augmenter i de un à chaque passage. Il est possible de changer ce pas :

In [23]:

for i in range(0, 10, 2):  # entier de 0 à 9 en allant de 2 en 2
    print(i)

for i in range(0, 10, 2): # entier de 0 à 9 en allant de 2 en 2 print(i)

0
2
4
6
8

Boucle while¶

La boucle while répète des instructions tant qu'une condition est vraie :

In [26]:

i = 3
while i >= 0:
    print(i)
    i -= 1

i = 3 while i >= 0: print(i) i -= 1

3
2
1
0

Attention : si la condition est toujours vraie, il y a "boucle infinie" et il faut l'arrêter avec le bouton stop :

Exercice

Définir un entier $n$ égal à 29568. Puis écrire une boucle while permettant de connaître la plus grande puissance de 2 divisant 29568, c'est à dire le plus grand $k$ tel que $2^k$ divise 29568.

n = 29568
k = 0
while ...:
    ... # à compléter