Exercice Corrigé: Boucle For en Python

# Demande à l'utilisateur de saisir le nombre de répétitions
n = int(input("Entrez un nombre:"))

# Répète la boucle n fois
for i in range(n):

    # Affiche le message "Hello"
    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.

# Initialise la somme à 0
somme = 0

# Parcourt les nombres de 1 à 10
for i in range(1, 11):

    # Ajoute le nombre actuel à la somme
    somme = somme + i

# Affiche la somme des nombres de 1 à 10
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.

# Initialise la somme à 0
somme = 0

# Demande à l'utilisateur de saisir un nombre entier
n = int(input("Entrer un nombre: "))

# Parcourt tous les nombres de 1 jusqu'à n
for i in range(1, n + 1):

    # Ajoute le nombre actuel à la somme
    somme = somme + i

# Affiche la somme des nombres de 1 à n
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.

# Demande à l'utilisateur de saisir la base
b = float(input("Entrer la base: "))

# Demande à l'utilisateur de saisir l'exposant
e = int(input("Entrer l'exposant: "))

# Initialise la puissance à 1
puissance = 1

# Répète la multiplication e fois
for i in range(e):

    # Multiplie progressivement la puissance par la base
    puissance = puissance * b

# Affiche le résultat de la puissance
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.

# Parcourt les nombres de 1 à 10
for i in range(1, 11):

    # Affiche le résultat de la multiplication de 3 par i
    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é.

# Demande à l'utilisateur de saisir un nombre entier
n = int(input("Entrer un nombre: "))

# Parcourt les nombres de 1 à 10
for i in range(1, 11):

    # Affiche le résultat de la multiplication de n par i
    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é.

# Demande à l'utilisateur de saisir un nombre entier
n = int(input("Entrer un nombre: "))

# Affiche un message indiquant la recherche des nombres pairs
# compris entre 1 et n
print("Les nombres pairs de 1 à {0} sont:".format(n))

# Parcourt tous les nombres de 0 à n
for i in range(0, n + 1):

    # Vérifie si le nombre est pair
    # Un nombre est pair lorsque son reste de division par 2 est 
    # égal à 0
    if i % 2 == 0:

        # Affiche le nombre pair
        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.

# Demande à l'utilisateur de saisir un nombre entier
n = int(input("Entrer un nombre: "))

# Initialise la somme à 0
s = 0

# Parcourt les nombres impairs de 1 jusqu'à n
# Le troisième paramètre de range() indique un pas de 2
for i in range(1, n + 1, 2):

    # Ajoute le nombre impair actuel à la somme
    s += i

# Affiche la somme des nombres impairs
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.

# Demande à l'utilisateur de saisir un nombre entier
n = int(input("Saisir un nombre: "))

# Initialise la factorielle à 1
f = 1

# Vérifie si le nombre est négatif
if n < 0:

    # La factorielle n'est pas définie pour les nombres négatifs
    print("Désolé, la factorielle n'existe pas pour les nombres négatifs.")

# Vérifie si le nombre est égal à 0
elif n == 0:

    # Par définition, la factorielle de 0 est égale à 1
    print("La factorielle de 0 est 1")

# Si n est positif
else:

    # Parcourt tous les nombres de 1 jusqu'à n
    for i in range(1, n + 1):

        # Multiplie progressivement les nombres
        # pour calculer la factorielle
        f = f * i

    # Affiche la factorielle calculée
    print("La factorielle 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.

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

# Parcourt les positions des caractères du mot
# en commençant par le dernier caractère jusqu'au premier
for char in range(len(word) - 1, -1, -1):

    # Affiche le caractère correspondant à la position actuelle
    # end="" permet d'afficher les caractères sur la même ligne
    print(word[char], end="")

# Passe à la ligne suivante après l'affichage du mot inversé
print()

# Crée un tuple contenant les nombres entiers de 1 à 9
nbrs = (1, 2, 3, 4, 5, 6, 7, 8, 9)

# Initialise les compteurs pour les nombres pairs et impairs
paire = 0
impaire = 0

# Parcourt chaque nombre du tuple
for x in nbrs:

    # Vérifie si x est pair
    # x % 2 donne le reste de la division de x par 2
    # Si le reste est 0, le nombre est pair
    if not x % 2:

        # Incrémente le compteur des nombres pairs
        paire += 1

    else:

        # Si le nombre n'est pas pair, il est impair
        # Incrémente le compteur des nombres impairs
        impaire += 1

# Affiche le nombre total de nombres pairs
print("Nombre de nombres pairs:", paire)

# Affiche le nombre total de nombres impairs
print("Nombre de nombres impairs:", impaire)

# 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)) 

# Parcourt les nombres de 0 à 5
for x in range(6):

    # Vérifie si x est égal à 3 ou à 6
    if x == 3 or x == 6:

        # Ignore l'itération actuelle et passe directement
        # au nombre suivant
        continue

    # Affiche la valeur de x sur la même ligne
    print(x, end=" ")

# Passe à la ligne suivante après la boucle
print()

# Demande à l'utilisateur de saisir une chaîne de caractères
str = input("Saisir une chaîne de caractères: ")

# Initialise les compteurs
# 'd' compte le nombre de chiffres
# 'l' compte le nombre de lettres
d = l = 0

# Parcourt chaque caractère de la chaîne
for c in str:

    # Vérifie si le caractère est un chiffre
    if c.isdigit():

        # Incrémente le compteur des chiffres
        d = d + 1

    # Vérifie si le caractère est une lettre
    elif c.isalpha():

        # Incrémente le compteur des lettres
        l = l + 1

    else:

        # Ne fait rien si le caractère n'est
        # ni une lettre ni un chiffre
        pass

# Affiche le nombre total de lettres
print("Lettres:", l)

# Affiche le nombre total de chiffres
print("Chiffres:", d)

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".

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Parcourt les lignes de 0 jusqu'à nbrLignes - 1
for i in range(nbrLignes):

    # Affiche les étoiles de la ligne actuelle
    # Le nombre d'étoiles augmente à chaque ligne
    for j in range(i + 1):

        # Affiche une étoile sans passer à la ligne
        print("* ", end="")

    # Passe à la ligne suivante
    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.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Parcourt les différentes lignes
for i in range(nbrLignes):

    # Affiche les nombres de 1 jusqu'au numéro de la ligne
    for j in range(i + 1):

        # Affiche le nombre j + 1 sans passer à la ligne
        print(j + 1, end=" ")

    # Passe à la ligne suivante
    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.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Initialise la valeur ASCII à 65, qui correspond à la lettre 'A'
valeur_ascii = 65

# Parcourt les différentes lignes
for i in range(nbrLignes):

    # Répète l'affichage de la lettre selon le numéro de la ligne
    for j in range(i + 1):

        # Convertit la valeur ASCII en caractère
        alphabet = chr(valeur_ascii)

        # Affiche la lettre sans passer à la ligne
        print(alphabet, end=" ")

    # Passe à la lettre suivante
    valeur_ascii += 1

    # Passe à la ligne suivante
    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

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Parcourt les lignes dans l'ordre décroissant
# Exemple pour nbrLignes = 5 : 5, 4, 3, 2, 1
for i in range(nbrLignes, 0, -1):

    # Affiche i étoiles sur la ligne actuelle
    for j in range(0, i):

        # Affiche une étoile sans passer à la ligne
        print("* ", end=" ")

    # Passe à la ligne suivante
    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.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Parcourt les lignes dans l'ordre décroissant
# Exemple pour nbrLignes = 5 : 5, 4, 3, 2, 1
for i in range(nbrLignes, 0, -1):

    # Parcourt les nombres de 1 jusqu'à i
    for j in range(1, i + 1):

        # Affiche le nombre j sans passer à la ligne
        print(j, end=" ")

    # Passe à la ligne suivante
    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.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Parcourt les lignes dans l'ordre décroissant
# Exemple pour 5 : 5, 4, 3, 2
for i in range(nbrLignes, 1, -1):

    # Affiche les espaces au début de chaque ligne
    # pour décaler progressivement les étoiles vers la droite
    for espace in range(0, nbrLignes - i):
        print("  ", end="")

    # Affiche la première partie des étoiles
    for j in range(i, 2 * i - 1):
        print("* ", end="")

    # Affiche la deuxième partie des étoiles
    # afin de compléter la ligne
    for j in range(1, i - 1):
        print("* ", end="")

    # Passe à la ligne suivante
    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é.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Initialise le coefficient à 1
coef = 1

# Parcourt les différentes lignes du triangle
for i in range(1, nbrLignes + 1):

    # Affiche les espaces nécessaires pour centrer la ligne
    for espace in range(1, nbrLignes - i + 1):
        print(" ", end="")

    # Parcourt les coefficients de la ligne actuelle
    for j in range(0, i):

        # Le premier coefficient de chaque ligne est toujours égal 
        # à 1
        if j == 0 or i == 0:
            coef = 1

        else:
            # Calcule le coefficient suivant à partir du précédent
            coef = coef * (i - j) // j

        # Affiche le coefficient sans passer à la ligne
        print(coef, end=" ")

    # Passe à la ligne suivante
    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.

# Demande à l'utilisateur de saisir le nombre de lignes
nbrLignes = int(input("Entrer le nombre de lignes: "))

# Initialise le premier nombre à afficher
n = 1

# Parcourt les différentes lignes
for i in range(1, nbrLignes + 1):

    # Affiche les nombres nécessaires pour la ligne actuelle
    for j in range(1, i + 1):

        # Affiche le nombre actuel sans passer à la ligne
        print(n, end=" ")

        # Passe au nombre suivant
        n += 1

    # Passe à la ligne suivante
    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.