Boucles while

Énoncé

Dans ce premier exercice sur les itérations, on va utiliser uniquement des boucles while.

Factorielle

Écrire une fonction fact(val) qui calcule et renvoie val!, ainsi que le programme principal permettant de la tester en demandant à l'utilisateur de saisir un entier naturel. On pensera bien à vérifier que l'entier saisi est supérieur ou égal à zéro : dans le cas contraire on lancera une exception ValueError pour signaler une erreur (on pourra par exemple écrire raise ValueError("l'entier saisi doit être positif ou nul !")).

PGCD

Écrire une fonction pgcd(val1, val2) qui renvoie le Plus Grand Commun Diviseur (PGCD) de deux entiers strictement positifs, ainsi que le programme principal permettant de la tester en demandant à l'utilisateur de saisir deux entiers. Là-encore, pensez bien à tester les valeurs fournies et à lancer une exception ValueError si les entiers saisis ne sont pas valides.

On rappelle l'algorithme classique de calcul du PGCD par soustractions successives :

tant que val1 ≠ val2 faire
    si val1 < val2 alors
        val2 = val2 - val1
    sinon
        val1 = val1 - val2
    fin si
fin faire
renvoyer val1

Parcours de structures de données classiques

Écrivez un programme while.py affichant un à un les éléments (caractère ou nombre), avec retour à la ligne après chaque élément, contenus dans les variables ci-dessous. Vous utiliserez une boucle, contenant éventuellement une ou deux sous boucle, pour chaque variable.

une_chaine = "123"
une_list = [1, 2, 3]
un_tuple = (1, 2, 3)
un_tuple_2D = ([1, 2, 3], [4, 5, 6])
une_list_3D = [[[1, 2], [3, 4]], [[5, 6]]]

On attend donc un affichage comme ci-dessous :

Éléments de une_chaine :
  1
  2
  3
Éléments de une_list :
  1
  2
  3
Éléments de un_tuple :
  1
  2
  3
Éléments de un_tuple_2D :
  1
  2
  3
  4
  5
  6
Éléments de une_list_3D :
  1
  2
  3
  4
  5
  6

Correction

Cliquez ici pour révéler la correction.

fact.py :

#!/usr/bin/env python3

"""
  Factorielle avec une boucle while
"""


def fact(val):
    """
    Renvoie val!
    """
    res = 1
    idx = 2
    while idx <= val:
        res *= idx
        idx += 1
    return res


def main():
    """
    Fonction principale
    """
    val = int(input("N = "))
    if val < 0:
        raise ValueError("N doit être positif ou nul !")
    print(f"{val}! = {fact(val)}")


main()

pgcd.py :

#!/usr/bin/env python3

"""
  Calcul du PGCD de deux entiers
"""


def pgcd(val1, val2):
    """
    Renvoie le PGCD de val1 et val2
    """
    while val1 != val2:
        if val1 < val2:
            val2 -= val1
        else:
            val1 -= val2
    return val1


def lire_entier(nom):
    """
    Lit un entier strictement positif
    """
    val = int(input(f"{nom} = "))
    if val <= 0:
        raise ValueError(f"{nom} doit être strictement positif !")
    return val


def main():
    """
    Fonction principale
    """
    val1 = lire_entier("A")
    val2 = lire_entier("B")
    print(f"PGCD({val1}, {val2}) = {pgcd(val1, val2)}")


main()

while.py :

#!/usr/bin/env python3

"""Exemples d'utilisation de boucle while"""

# Les variables que l'on souhaite parcourir
une_chaine = "123"
une_list = [1, 2, 3]
un_tuple = (1, 2, 3)
un_tuple_2D = ([1, 2, 3], [4, 5, 6])
une_list_3D = [[[1, 2], [3, 4]], [[5, 6]]]

# Variables à une dimension --> une seule boucle
print("éléments de une_chaine :")
idx = 0
while idx < len(une_chaine):
    print(f"  {une_chaine[idx]}")
    idx += 1

print("éléments de une_list :")
idx = 0
while idx < len(une_list):
    print(f"  {une_list[idx]}")
    idx += 1

print("éléments de un_tuple :")
idx = 0
while idx < len(un_tuple):
    print(f"  {un_tuple[idx]}")
    idx += 1

# Variables à deux dimensions --> deux boucles
print("éléments de un_tuple_2D :")
idx = 0
while idx < len(un_tuple_2D):
    idy = 0
    while idy < len(un_tuple_2D[idx]):
        print(f"  {un_tuple_2D[idx][idy]}")
        idy += 1
    idx += 1

# Variable à trois dimensions --> trois boucles
print("éléments de une_list_3D :")
idx = 0
while idx < len(une_list_3D):
    idy = 0
    while idy < len(une_list_3D[idx]):
        idz = 0
        while idz < len(une_list_3D[idx][idy]):
            print(f"  {une_list_3D[idx][idy][idz]}")
            idz += 1
        idy += 1
    idx += 1