Exercice Corrigé: Boucle For en Python

Avec des exercices corrigés en Python, vous pratiquerez divers concepts du langage Python. Vous commencerez par des exercices Python de base à des exercices plus avancés. La solution est fournie pour chaque exercice. Vous devez essayer de résoudre chaque problème par vous-même avant de vérifier la solution. Si vous avez des questions concernant chaque problème, nous vous encourageons à les poster sur notre forum.
 
 

Exercice 1:

Écrire un programme en Python qui affiche n fois « Hello ». En utilisant la boucle « for ».

Exemple de sortie:

Entrez un nombre: 2
Hello
Hello
Solution:

#saisir le nombre d'itération
n = int(input("Entrez un nombre:"))

for i in range(n):
    print('Hello')

Explication:

La fonction range() de Python est principalement utilisée pour travailler avec des boucles for – vous pouvez l’utiliser pour parcourir certains blocs de code un nombre spécifié de fois. La fonction range() accepte trois arguments – l’un est obligatoire, les deux autres sont facultatifs. L’argument stop est obligatoire.

 

Exercice 2:

Ecrivez un programme en Python qui calcule la somme de 1 à 10. En utilisant la boucle « for ».

Indication:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

Exemple de sortie:

La somme de 1 à 10 est 55
Solution:

somme = 0
for i in range(1,11):
    somme = somme + i
print("La somme de 1 à 10 est:",somme)

Explication:

Dans la boucle for ci-dessus, la variable i est initialisée à 1 et la boucle se poursuit tant que i est inférieur à 11. À chaque itération de la boucle, la variable somme s’additionne à la valeur de i.

 

Exercice 3:

Ecrivez un programme en Python qui calcule la somme de 1 à N, où N est saisi par l’utilisateur. En utilisant la boucle « for ».

Indication:

1 + 2 + 3 + 4 + 5 + 6 + 7 = 28

Exemple de sortie:

Entrer un nombre: 7
La somme de 1 à 7 est 28
Solution:

somme = 0
n=int(input("Entrer un nombre:"))
for i in range (1,n+1):
    somme = somme + i
print("La somme de",1,"à",n,"est",somme)

Explication:

La boucle for est itérée n fois. À chaque itération, la valeur de i est ajoutée à la somme somme et i est incrémenté de 1.

 

Exercice 4:

Écrire un programme en Python qui prend deux entiers de l’utilisateur (un nombre de base et un exposant) et calcule la puissance.

Exemple: Dans le cas de 23

  • 2 est le nombre de base
  • 3 est l’exposant
  • Et la puissance est égale à 2*2*2

Exemple de sortie:

Entrer la base: 2
Entrer l'exposant: 3
2 ^ 3 = 8
Solution:

b = float(input("Entrer la base: "))
e = int(input("Entrer l'exposant: "))
puissance = 1
  
for i in range(e): 
	puissance = puissance * b
 
print("{0} ^ {1} = {2}".format(b,e,puissance))

Explication:

Voici la logique descriptive étape par étape:

  • L’utilisateur entre la base et les exposants. Les stocker dans deux variables, b et e.
  • Déclarer et initialiser une autre variable pour stocker la puissance, puissance = 1.
  • Exécutez une boucle de 1 à l’exposant, en incrémentant le compteur de la boucle de 1 à chaque itération. La structure de la boucle doit ressembler à for i in range(e): .
  • Pour chaque itération à l’intérieur de la boucle, multipliez la puissance par la base, c’est-à-dire puissance = puissance * b.
  • Enfin, à la fin de la boucle, il ne reste plus que la puissance dans la variable puissance.
 
 

Exercice 5:

Écrire un programme en Python qui affiche la table de multiplication de 3. En utilisant la boucle « for ».

Exemple de sortie:

3 x 0 = 0
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
3 x 10= 30  
Solution:

for i in range (1,11):
    print("3 *",i,"=",i*3)

Explication:

Nous utilisons la boucle for pour afficher la table de multiplication de 3. La boucle s’exécute jusqu’au 11. À chaque itération de la boucle, i * 3 est affiché.

 
 

Exercice 6:

Écrire un programme en Python qui affiche la table de multiplication d’un entier saisi par l’utilisateur, en utilisant la boucle « for ».

Exemple de sortie:

Entrer un nombre: 7
7 x 0 = 0
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10= 70
Solution:

n=int(input("Entrer un nombre:"))
for i in range (1,11):
    print(n," * ",i,"=",i*n)

Explication:

L’utilisateur est d’abord invité à saisir un nombre. Le nombre saisie est analysé à l’aide de la fonction Python input() et stocké dans la variable n. Nous utilisons la boucle for pour afficher la table de multiplication de n. La boucle s’exécute jusqu’au 11. À chaque itération de la boucle, i * n est affiché.

 
 

Exercice 7:

Écrire un programme en Python pour afficher les nombres pairs entre 0 et N, où N est saisi par l’utilisateur.

Exemple de sortie:

Entrer un nombre :  9
Les nombres pairs de 1 à 9 sont: 0  2  4  6  8 
Solution:

n = int(input("Entrer un nombre: "))
print("Les nombres pairs de 1 à {0} sont:".format(n))
for i in range(0, n+1):
    if (i % 2 == 0):
        print(i)

Explication:

Description pas à pas de la logique permettant d’afficher tous les nombres pairs compris entre 1 et n+1:

  • L’utilisateur doit saisir la limite supérieure des nombres pairs. Stockez-la dans la variable N.
  • Exécutez la boucle « for » à partir de 1, jusqu’à n+1.
  • À l’intérieur du corps de la boucle, vérifiez la condition pair/impair. Si le nombre actuel i est divisible par 2, alors i est pair. Autrement dit, if (i%2 == 0), la valeur de i est affichée.
 
 

Exercice 8:

Ecrivez un programme en Python qui calcule la somme des nombres impairs compris entre 1 et un nombre entier N saisi par l’utilisateur. Exemple N=10 Somme=1+3+5+7+9=25

Exemple de sortie:

Entrer un nombre :  10
La somme des nombres impairs est: 25
Solution:

n = int(input("Entrer un nombre: "))

s = 0 
for i in range(1,n+1,2): 
    s+=i 
	
print("La somme des nombres impairs est: ", s)

Explication:

Dans ce programme:

  • L’utilisateur doit saisir la limite supérieure des nombres impairs. Stockez-la dans la variable N.
  • Exécutez la boucle « for » à partir de 1, jusqu’à n+1 de 1 à n, avec un pas de 2.
  • N’oubliez pas que range prend des paramètres tels que : range(start, end, incrementor). N’oubliez donc pas le 2 pour sauter les nombres pairs, sinon vous les additionnerez tous !
  • Ensuite nous ajoutons le nombre actuel i à la variable s.
  • Enfin nous affichons la somme des nombres impairs.
 

Exercice 9:

Écrire un programme en Python pour calculer la factorielle d’un nombre entier saisi par l’utilisateur. (Remarque: le factoriel de 5, qui s’écrit 5! = 5 × 4 × 3 × 2 × 1).

Exemple de sortie:

Saisir un nombre : 5
Le factoriel de 5 est 120
----------------------------
Saisir un nombre : 0
La factorielle de 0 est 1
----------------------------
Saisir un nombre : -5
Désolé, la factorielle n'existe pas pour les nombres négatifs.
Solution:

# Prendre les données de l'utilisateur
n = int(input("Saisir un nombre: "))

f = 1

# vérifier si le nombre est négatif, positif ou nul
if n < 0:
   print("Désolé, la factorielle n'existe pas pour les nombres négatifs.")
elif n == 0:
   print("La factorielle de 0 est 1")
else:
   for i in range(1,n + 1):
       f = f*i
   print("Le factoriel de",n,"est",f)

Explication:

Ici, le nombre dont la factorielle doit être trouvée est stocké dans n, et nous vérifions si le nombre est négatif, nul ou positif en utilisant l'instruction if...elif...else. Si le nombre est positif, nous utilisons la boucle for et la fonction range() pour calculer la factorielle.

 

Exercice 10:

Écrire un programme Python qui accepte un mot de l'utilisateur et l'inverse.

Exemple:

Saisir un mot à inverser: waytolearnx
xnraelotyaw
Solution:

# Inviter l'utilisateur à saisir un mot
word = input("Saisir un mot à inverser:")

# Parcourir les caractères du mot dans l'ordre inverse
for char in range(len(word) - 1, -1, -1):
    # Afficher chaque caractère du mot dans l'ordre inverse sans nouvelle ligne (end="")
    print(word[char], end="")

# Afficher une nouvelle ligne pour séparer le mot inversé de la sortie suivante.
print("\n")
 

Exercice 11:

Écrire un programme Python pour compter le nombre de nombres pairs et impairs dans une série de nombres.

Exemple:

nombres = (1, 2, 3, 4, 5, 6, 7, 8, 9) 
Résultat attendu: 
Nombre de nombres pairs : 5
Nombre de nombres impairs : 4
Solution:

# Créer un tuple nommé 'nbrs' contenant des valeurs entières de 1 à 9.
nbrs = (1, 2, 3, 4, 5, 6, 7, 8, 9)

# Initialisation des compteurs pour le calcul des nombres pairs et impairs
impaire = 0
paire = 0

# Parcourir chaque élément « x “ dans le tuple 'nbrs'.
for x in nbrs:
    # Vérifier si le nombre actuel 'x' est pair en évaluant 'not x%2'.
    if not x % 2:  # Si 'x' modulo 2 est égal à 0, il est pair
        # Incrémenter le nombre de nombres pairs
        paire += 1
    else:
        # Si 'x' modulo 2 n'est pas égal à 0, il est impair ; incrémenter le nombre de nombres impairs
        impaire += 1

# Afficher le nombre total de nombres pairs et impairs
print("Nombre de nombres pairs:", paire)
print("Nombre de nombres impairs:", impaire) 
 

Exercice 12:

Écrivez un programme Python qui affiche chaque élément et son type correspondant dans la liste suivante.

Exemple:

Exemple de liste: 
liste = [5, 5.2, 1+2j, True, 'str', (0, 1), [0, 1], {"a":1, "b":1}]

Type de 5 est <class 'int'>
Type de 5.2 est <class 'float'>
Type de (1+2j) est <class 'complex'>
Type de True est <class 'bool'>
Type de str est <class 'str'>
Type de (0, 1) est <class 'tuple'>
Type de [0, 1] est <class 'list'>
Type de {'a': 1, 'b': 1} est <class 'dict'>
Solution:

# Créer une liste contenant différents types de données (int, float, complex, bool, string, tuple, list, dictionary).
liste = [5, 5.2, 1+2j, True, 'str', (0, 1), [0, 1], {"a":1, "b":1}]

# Parcourir chaque élément de la liste
for i in liste:
    # Afficher le type de chaque élément de la liste ainsi que l'élément lui-même.
    print("Type de", i, "est", type(i)) 
 

Exercice 13:

Ecrivez un programme Python qui affiche tous les nombres de 0 à 6 à l'exception de 3 et 6.

Exemple:

0 1 2 4 5 
Solution:

# Parcourir les nombres de 0 à 5 à l'aide de la fonction range
for x in range(6):
    # Vérifier si la valeur actuelle de 'x' est égale à 3 ou 6
    if (x == 3 or x == 6):
        # Si 'x' est 3 ou 6, passez à l'itération suivante sans exécuter le code ci-dessous
        continue
    # Afficher la valeur de 'x' avec un espace et sans nouvelle ligne (end=' ')
    print(x, end=' ')

# Afficher une nouvelle ligne après affichage de tous les nombres satisfaisant à la condition.
print("\n")
 

Exercice 14:

Ecrivez un programme Python qui accepte une chaîne de caractères et calcule le nombre de chiffres et de lettres.

Exemple:

Exemple: Python 3.2
Résultat attendu :
Lettres 6
Chiffres 2
Solution:

# Inviter l'utilisateur à saisir une chaîne de caractères et la stocker dans la variable 'str'.
str = input("Saisir une chaîne de caractères")

# Initialiser les variables 'd' (pour compter les chiffres) et 'l' (pour compter les lettres) avec les valeurs 0
d = l = 0

# Parcourir chaque caractère 'c' de la chaîne d'entrée 'str'.
for c in str:
    # Vérifier si le caractère courant 'c' est un chiffre
    if c.isdigit():
        # Si 'c' est un chiffre, incrémenter le nombre de chiffres ('d')
        d = d + 1
    # Vérifier si le caractère courant 'c' est une lettre de l'alphabet
    elif c.isalpha():
        # Si 'c' est une lettre de l'alphabet, incrémenter le nombre de lettres ('l')
        l = l + 1
    else:
        # Si 'c' n'est ni un chiffre ni une lettre de l'alphabet, ne rien faire ('pass')
        pass

# Affiche le nombre total de lettres ('l') et de chiffres ('d') dans la chaîne entrée 'str'
print("Lettres", l)
print("Chiffres", d)
 

Exercice 15:

Écrire un programme en Python permettant de calculer le plus grand commun diviseur (PGCD) entre deux nombres entiers entrés par l'utilisateur.

Exemple de sortie:

Entrer le 1er nombre: 18  
Entrer le 2éme nombre: 45
Le PGCD de 18 et 45 = 9
Solution:

n1 = int(input("Entrer le 1er nombre: "))
n2 = int(input("Entrer le 2éme nombre: "))

# chercher la plus petite des deux valeurs n1 et n2
min = n1 if (n1 < n2) else n2

# Itérer de 1 jusqu'à min+1.
for i in range(1, min+1):
    # Vérifier si n1 et n2 sont divisibles par i.
    if (n1 % i == 0 and n2 % i == 0):
        # Mettre à jour le PGCD avec la valeur actuelle de i
        pgcd = i
		
print("PGCD de {0} et {1} = {2}".format(n1, n2, pgcd))

Explication:

Dans ce programme, deux nombres entiers entrés par l'utilisateur sont stockés dans les variables n1 et n2. Ensuite, nous utilisons if-else pour rechercher la plus petite valeur entre n1 et n2 et affecter le résultat à une variable appelée min (le diviseur).

Dans la boucle for a chaque itération, si n1 et n2 sont exactement divisibles par i, c'est-à-dire si le reste est égal à zéro pour n1 et n2, nous savons que le diviseur actuel est le PGCD. La valeur de i est affectée à la variable "pgcd".

Lorsque la boucle for est terminée, le plus grand diviseur commun de deux nombres est stocké dans la variable "pgcd".

 
 

Exercice 16:

Écrire un programme en Python qui affiche une demi-pyramide en utilisant *, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
*
* *
* * *
* * * *
* * * * *
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

for i in range(nbrLignes):
    for j in range(i+1):
        print("* ", end="")
    print()

Explication:

  • Pour commencer, nous obtenons le nombre de lignes de la pyramide de la part de l'utilisateur.
  • Dans la première boucle, nous itérons de i = 0 à i = nbrLignes.
  • La deuxième boucle va de j = 0 à i + 1. À chaque itération de cette boucle, nous affichons i + 1 nombre de * sans nouvelle ligne. Ici, le numéro de ligne donne le nombre de * à afficher sur cette ligne. Par exemple, à la deuxième ligne, nous affichons deux *. Pareillement, à la 3e ligne, nous affichons trois *.
  • Une fois la boucle interne terminée, nous affichons une nouvelle ligne et commençons à afficher les * sur une nouvelle ligne.
 

Exercice 17:

Écrire un programme en Python qui affiche une demi-pyramide en utilisant des nombres, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

for i in range(nbrLignes):
    for j in range(i+1):
        print(j+1, end=" ")
    print()

Explication:

  • Pour commencer, nous obtenons le nombre de lignes de la pyramide de la part de l'utilisateur.
  • Dans la première boucle, nous itérons de i = 0 à i = nbrLignes.
  • Dans la deuxième boucle, nous affichons des nombres allant de 1 à j, où j est compris entre 0 et i.
  • Après chaque itération de la première boucle, nous affichons une nouvelle ligne.
 
 

Exercice 18:

Écrire un programme en Python qui affiche une demi-pyramide en utilisant des alphabets, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
A
B B
C C C
D D D D
E E E E E
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

valeur_ascii = 65

for i in range(nbrLignes):
    for j in range(i+1):
        alphabet = chr(valeur_ascii)
        print(alphabet, end=" ")
    
    valeur_ascii += 1
    print()

Explication:

La méthode utilisée dans l'exercice ci-dessus est également similaire aux autres exercices présentés ci-dessus, à l'exception des valeurs ascii qui sont affichées ici. La valeur ascii des alphabets commence à 65 (c'est-à-dire A). Par conséquent, à chaque itération, nous incrémentant la valeur de ascii_value et nous affichons l'alphabet correspondant. Voir aussi: Fonction chr() en Python

Exercice 19:

Écrire un programme en Python qui affiche une demi-pyramide inversée en utilisant des *, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
* * * * *
* * * *
* * *
* *
*
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

for i in range(nbrLignes, 0, -1):
    for j in range(0, i):
        print("* ", end=" ")
    
    print()

Explication:

Cet exemple est similaire à celui d'une pyramide verticale, sauf qu'ici nous partons du nombre total de lignes et qu'à chaque itération, nous décrémentons le nombre de lignes de 1.

Exercice 20:

Écrire un programme en Python qui affiche une demi-pyramide inversée en utilisant des nombres, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

for i in range(nbrLignes, 0, -1):
    for j in range(1, i+1):
        print(j, end=" ")
    
    print()

Explication:

La seule différence entre une pyramide verticale et une pyramide inversée utilisant des nombres est que la première boucle commence à partir du nombre total de lignes à 0.

Exercice 21:

Écrire un programme en Python qui affiche une Pyramide complète inversée avec des *, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 5
* * * * * * * * *
  * * * * * * *
    * * * * *
      * * *
        *
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

for i in range(nbrLignes, 1, -1):
    for espace in range(0, nbrLignes-i):
        print("  ", end="")
    for j in range(i, 2*i-1):
        print("* ", end="")
    for j in range(1, i-1):
        print("* ", end="")
    print()

Explication:

Dans cet exemple, nous avons utilisé un total de 4 boucles for.

  • La boucle for externe itère de i = nbrLignes à i = 1.
  • La première boucle for interne affiche les espaces requis dans chaque ligne.
  • La deuxième boucle for interne affiche la première moitié de la pyramide (coupée verticalement), tandis que la dernière boucle for interne affiche l'autre moitié.
 

Exercice 22:

Écrire un programme en Python qui affiche le triangle de Pascal, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 6
           1
         1   1
       1   2   1
     1   3   3    1
   1  4    6   4   1
 1  5   10   10  5   1
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

coef = 1

for i in range(1, nbrLignes+1):
    for espace in range(1, nbrLignes-i+1):
        print(" ",end="")
    for j in range(0, i):
        if j==0 or i==0:
            coef = 1
        else:
            coef = coef * (i - j)//j
        print(coef, end = " ")
    print()

Explication:

Dans cet exemple, nous avons utilisé trois boucles for.

  • La boucle externe itère de 1 à nbrLignes + 1.
  • La première boucle interne affiche les espaces.
  • La deuxième boucle interne commence par trouver le nombre à afficher à l'aide de l'instruction coef = coef * (i - j) // j, puis l'affiche. Ici, i est le numéro de ligne et j est la valeur comprise entre 0 et i.
Exercice 23:

Écrire un programme en Python qui affiche le triangle de Floyd, en fonction d'un entier N saisi par l'utilisateur.

Exemple de sortie:

Entrer le nombre de lignes: 4
1
2 3
4 5 6
7 8 9 10
Solution:

nbrLignes = int(input("Entrer le nombre de lignes: "))

n = 1

for i in range(1, nbrLignes+1):
    for j in range(1, i+1):
        print(n, end=" ")
        n += 1
    print()

Explication:

Il s'agit de l'un des types de schéma les plus faciles à réaliser.

  • La variable n est initialisée à la valeur 1.
  • La boucle for externe itère de 1 au nombre total de lignes.
  • La boucle for interne commence de 1 à i + 1, où i est le numéro de la ligne. Après chaque itération, la valeur de n est incrémentée.
 

Éditeur de code Python: Testez votre code en ligne!


 
QCM Python

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *