Exercice Corrigé Python pour Débutant – Partie 4

x = 30
y = 20
print("\n%d+%d=%d" % (x, y, x+y))

Solution 2:

x = 30
y = 20
print("{0}+{1}={2}".format(x, y, x + y))

Solution 3:

x = 30
y = 20
print("{}+{}={}".format(x, y, x + y))

Explication:

La méthode format() formate la ou les valeurs spécifiées et les insère dans l’espace réservé de la chaîne. L’espace réservé est défini à l’aide de crochets : {}

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

    # Affiche plusieurs fois la même lettre sur chaque ligne
    # Le nombre de répétitions augmente à chaque 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 valeur ASCII suivante
    # pour utiliser 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 en ordre décroissant
# Si nbrLignes vaut 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 sur la même 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: "))

# Initialise le compteur d'étoiles à 0
k = 0

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

    # Affiche les espaces nécessaires pour centrer les étoiles
    # Le nombre d'espaces diminue à chaque ligne
    for espace in range(1, (nbrLignes - i) + 1):
        print(end="  ")

    # Affiche les étoiles de la ligne actuelle
    # Chaque ligne contient un nombre impair d'étoiles :
    # 1, 3, 5, 7, ...
    while k != (2 * i - 1):
        print("* ", end="")
        k += 1

    # Réinitialise le compteur pour la prochaine ligne
    k = 0

    # Passe à la ligne suivante
    print()

Explication:

Ce type de pyramide est un peu plus compliqué que celles que nous avons vues précédemment.

• La boucle extérieure commence à partir de i = 1 jusqu’à i = nbrLignes + 1.
• Parmi les deux boucles intérieures, la boucle for affiche les espaces requis pour chaque ligne en utilisant la formule (nbrLignes-i)+1, où nbrLignes représentent le nombre total de lignes et i le numéro de la ligne actuelle.
• La boucle while affiche le nombre d’étoiles requis en utilisant la formule 2 * i – 1. Cette formule donne le nombre d’étoiles pour chaque ligne, où ligne est i.

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

# Initialise le compteur utilisé pour contrôler la position
k = 0

# Initialise le compteur des positions déjà parcourues
count = 0

# Initialise le compteur utilisé pour la partie décroissante des nombres
count1 = 0

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

    # Affiche les espaces nécessaires pour centrer la pyramide
    # Le nombre d'espaces diminue à chaque ligne
    for espace in range(1, (nbrLignes - i) + 1):
        print("  ", end="")

        # Compte les espaces affichés
        count += 1

    # Affiche les nombres de la ligne
    # Chaque ligne contient (2 * i) - 1 nombres
    while k != ((2 * i) - 1):

        # Vérifie si nous sommes encore dans la partie
        # croissante de la ligne
        if count <= nbrLignes - 1:

            # Affiche les nombres dans l'ordre croissant
            print(i + k, end=" ")

            # Augmente le compteur de position
            count += 1

        else:
            # Passe à la partie décroissante de la ligne
            count1 += 1

            # Affiche les nombres dans l'ordre décroissant
            print(i + k - (2 * count1), end=" ")

        # Passe au nombre suivant
        k += 1

    # Réinitialise les compteurs avant de passer à la ligne suivante
    count1 = count = k = 0

    # Passe à la ligne suivante
    print()

Explication:

Comme dans l'exercice précédent, cet exemple utilise également deux boucles à l'intérieur d'une boucle for.

• La boucle for externe parcourt chaque ligne.
• Nous utilisons ici deux compteurs, count et count1, pour afficher respectivement les espaces et les nombres.
• La boucle for interne affiche les espaces requis en utilisant la formule (nbrLignes-i)+1, où nbrLignes est le nombre total de lignes et i le numéro de la ligne actuelle.
• La boucle while affiche les nombres où 2 * i - 1 donne le nombre d'éléments dans chaque ligne.

# 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
for i in range(nbrLignes, 1, -1):

    # Affiche les espaces nécessaires 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
    # Le nombre d'étoiles dépend de la valeur de i
    for j in range(i, 2 * i - 1):
        print("* ", end="")

    # Affiche la deuxième partie des étoiles
    # afin de compléter la forme de 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 lignes de 1 jusqu'à nbrLignes
for i in range(1, nbrLignes + 1):

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

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

        # Le premier élément de chaque ligne vaut toujours 1
        if j == 0 or i == 0:
            coef = 1

        else:
            # Calcule le coefficient suivant à partir du précédent
            # Cette formule permet de construire le triangle
            #  de Pascal
            coef = coef * (i - j) // j

        # Affiche le coefficient
        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 de chaque ligne
    # Le nombre d'éléments augmente à chaque ligne
    for j in range(1, i + 1):

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

# Demande à l'utilisateur de saisir la distance totale parcourue en kilomètres
distance = int(input("Entrer la distance totale en km: "))

# Demande à l'utilisateur de saisir la quantité totale de carburant consommée en litres
carburant = int(input("Entrer le carburant total dépensé en litres: "))

# Calcule la consommation moyenne en kilomètres par litre
# Formule : consommation = distance / carburant
print("Consommation moyenne (km/litre) = ", distance / carburant)

Explication:

Ce programme permet de calculer la consommation moyenne d'un véhicule en kilomètres par litre.

• distance → contient la distance totale parcourue en kilomètres.
• carburant → contient la quantité de carburant consommée en litres.
• distance / carburant → calcule le nombre de kilomètres parcourus avec un litre de carburant.
• print() → affiche la consommation moyenne.