Exercice Corrigé: Boucle For en Python

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

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.

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.

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.

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

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

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.

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.

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

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

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

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

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

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

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

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.

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.

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

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.

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.

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

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.

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.