Introduction

Une boucle while est une instruction de flux de contrôle fondamentale en Python qui vous permet d'exécuter à plusieurs reprises un bloc de code tant qu'une certaine condition est vraie. Il fournit un moyen d'automatiser les tâches répétitives et de parcourir une séquence de valeurs. Cet article explorera la syntaxe, l'utilisation et diverses applications des boucles while en Python.

Syntaxe et structure d'une boucle While

La syntaxe d'une boucle while en Python est la suivante :

while condition:
    # code to be executed

La condition est une expression booléenne déterminant si la boucle doit continuer ou se terminer. Si la condition est considérée comme vraie, le bloc de code à l'intérieur de la boucle sera exécuté à plusieurs reprises. Une fois que la condition devient fausse, la boucle se terminera et le programme continuera avec l'instruction suivante après la boucle.

Utilisation de base et exemples

Commençons par un exemple simple pour comprendre l’utilisation de base d’une boucle while. Supposons que nous voulions imprimer les nombres de 1 à 5. Nous pouvons y parvenir en utilisant une boucle while, comme indiqué ci-dessous :

num = 1
while num <= 5:
    print(num)
    num += 1

Sortie

1

2

3

4

5

Dans cet exemple, nous initialisons la variable `num` à 1. La boucle while continue si `num` est inférieur ou égal à 5. A l'intérieur de la boucle, nous imprimons la valeur de `num` puis l'incrémentons de 1 en utilisant le Opérateur `+=`. Ce processus se répète jusqu'à ce que « num » devienne 6, lorsque la condition devient False et que la boucle se termine.

Contrôler le flux avec des instructions de contrôle de boucle

Python fournit trois instructions de contrôle de boucle, « break », « continue » et « pass », pour vous permettre de contrôler le flux d'une boucle while.

La déclaration « pause »

L'instruction `break` est utilisée pour quitter la boucle prématurément, même si la condition de la boucle est toujours vraie. Il est souvent utilisé lorsqu'une certaine condition est remplie et que vous souhaitez terminer la boucle immédiatement. Voici un exemple :

num = 1
while num <= 10:
    if num == 6:
        break
    print(num)
    num += 1

Sortie

1

2

3

4

5

Dans cet exemple, la boucle se termine lorsque « num » devient 6 car nous avons utilisé l'instruction « break » dans la condition if. De ce fait, seuls les chiffres de 1 à 5 sont imprimés.

La déclaration « continuer »

L'instruction « continue » est utilisée pour ignorer le reste du bloc de code à l'intérieur de la boucle et passer à l'itération suivante. C'est utile lorsque vous souhaitez ignorer certaines valeurs ou conditions et passer à l'itération suivante. Voici un exemple :

num = 1
while num <= 5:
    if num == 3:
        num += 1
        continue
    print(num)
    num += 1

Sortie

1

2

4

5

Dans cet exemple, la boucle ignore la valeur 3 car nous avons utilisé l'instruction « continue » dans la condition if. En conséquence, le chiffre 3 n'est pas imprimé et la boucle continue avec l'itération suivante.

La déclaration « réussite »

L'instruction `pass` est un espace réservé lorsque vous ne voulez rien faire à l'intérieur de la boucle. Il est souvent utilisé comme espace réservé temporaire pendant le développement ou lorsque vous souhaitez créer une boucle vide. Voici un exemple :

num = 1
while num <= 5:
    pass
    num += 1

Dans cet exemple, l'instruction « pass » ne fait rien et la boucle incrémente la valeur de « num » jusqu'à ce qu'elle devienne 6.

Cas d'utilisation et applications courants

Les boucles While ont un large éventail d'applications en Python. Explorons quelques cas d'utilisation courants :

Itérer jusqu'à ce qu'une condition soit remplie

Les boucles While sont couramment utilisées lorsque vous souhaitez itérer jusqu'à ce qu'une certaine condition soit remplie. Par exemple, nous voulons trouver la première puissance de 2 supérieure à 1000. Nous pouvons utiliser une boucle while pour y parvenir :

num = 1
while num <= 1000:
    num *= 2
print(num)

Sortie

1024

Dans cet exemple, la boucle continue jusqu'à ce que « num » dépasse 1000. Pour chaque itération, « num » est multiplié par 2 et la valeur finale est imprimée.

Validation des entrées utilisateur

Les boucles While sont utiles pour valider les entrées de l'utilisateur et garantir que l'entrée répond à certains critères. Par exemple, nous souhaitons inviter l'utilisateur à saisir un entier positif. Nous pouvons utiliser une boucle while pour demander une entrée jusqu'à ce qu'un entier valide soit saisi à plusieurs reprises :

while True:
    try:
        num = int(input("Enter a positive integer: "))
        if num > 0:
            break
        else:
            print("Invalid input. Please enter a positive integer.")
    except ValueError:
        print("Invalid input. Please enter a valid integer.")

Dans cet exemple, la boucle continue indéfiniment jusqu'à ce qu'un entier positif valide soit saisi. Le bloc `try-sauf` gère les erreurs potentielles lors de la conversion de l'entrée en entier.

Créer des boucles infinies

Les boucles While peuvent être utilisées pour créer des boucles infinies, qui continuent indéfiniment jusqu'à ce qu'une certaine condition soit remplie. Par exemple, créons une simple boucle infinie qui imprime « Hello, World ! » à plusieurs reprises:

while True:
    print("Hello, World!")

Dans cet exemple, la condition de boucle est toujours True, donc la boucle continue indéfiniment. Pour terminer la boucle, vous pouvez utiliser l'instruction `break` ou interrompre l'exécution du programme.

Une boucle infinie peut être utile dans le contexte d'un système de surveillance ou de journalisation en temps réel. Imaginez une situation dans laquelle vous devez surveiller en permanence un système ou un réseau pour détecter des événements ou des changements spécifiques et enregistrer les informations. Une boucle infinie pourrait être utilisée pour vérifier ces conditions et prendre constamment les mesures appropriées.

Implémentation de boucles de jeu

Les boucles While sont couramment utilisées dans le développement de jeux pour implémenter des boucles de jeu, qui contrôlent le déroulement du jeu et gèrent les entrées de l'utilisateur. Une boucle de jeu se compose généralement de trois composants principaux : la mise à jour de l'état du jeu, le rendu des graphiques du jeu et la gestion des entrées de l'utilisateur. Voici un exemple simplifié :

game_running = True
while game_running:
    # Update game state
    # Render game graphics
    # Handle user input

Dans cet exemple, la boucle continue tant que la variable `game_running` est True. À l'intérieur de la boucle, vous mettriez à jour l'état du jeu, restituerez les graphiques du jeu et gérerez les entrées de l'utilisateur. Ce processus se répète jusqu'à la fin du jeu ou jusqu'à ce que le joueur choisisse de quitter.

Lisez aussi : Un didacticiel Python complet pour apprendre la science des données à partir de zéro

Boucles While imbriquées et imbrication de boucles

Python vous permet d'imbriquer des boucles while, ce qui signifie que vous pouvez avoir une boucle while dans une autre boucle while. Ceci est utile lorsque vous devez effectuer des tâches répétitives au sein de tâches répétitives. Voici un exemple :

outer_num = 1
while outer_num <= 3:
    inner_num = 1
    while inner_num <= 3:
        print(outer_num, inner_num)
        inner_num += 1
    outer_num += 1

Sortie

+1 (1)XNUMX XNUMX

+1 (2)XNUMX XNUMX

+1 (3)XNUMX XNUMX

+2 (1)XNUMX XNUMX

+2 (2)XNUMX XNUMX

+2 (3)XNUMX XNUMX

+3 (1)XNUMX XNUMX

+3 (2)XNUMX XNUMX

+3 (3)XNUMX XNUMX

Dans cet exemple, nous avons une boucle while externe qui itère de 1 à 3 et une boucle while interne qui itère de 1 à 3 pour chaque itération de boucle externe. L'instruction print à l'intérieur de la boucle interne affiche les valeurs des deux variables de boucle.

Conseils et bonnes pratiques pour l’utilisation des boucles While

Bien que les boucles soient des constructions puissantes, elles peuvent également être sujettes à des erreurs si elles ne sont pas utilisées correctement. Voici quelques conseils et bonnes pratiques à garder à l’esprit lors de l’utilisation des boucles while :

Initialiser correctement les variables

Avant d'entrer dans une boucle while, initialisez toutes les variables de la boucle à leurs valeurs initiales. Cela garantit que la condition de boucle est évaluée correctement et évite tout comportement inattendu. Par exemple:

count = 0
while count < 10:
    print(count)
    count += 1

Dans cet exemple, nous initialisons la variable `count` à 0 avant d'entrer dans la boucle.

Assurer la terminaison de la boucle

Pour éviter les boucles infinies, assurez-vous toujours que la condition de boucle finira par devenir fausse. Ceci peut être réalisé en mettant à jour les variables de boucle ou en utilisant des instructions de contrôle de boucle comme « break ». Par exemple:

num = 1
while num <= 10:
    if num == 6:
        break
    print(num)
    num += 1

Dans cet exemple, la boucle se termine lorsque « num » devient 6 à cause de l'instruction « break ».

Éviter les boucles infinies

Soyez prudent lorsque vous utilisez des boucles while pour éviter de créer des boucles infinies qui ne se terminent jamais. Des boucles infinies peuvent entraîner des plantages de programmes et consommer des ressources système excessives. Vérifiez toujours les conditions de votre boucle et assurez-vous qu'elles peuvent devenir fausses à un moment donné.

Écrire du code lisible et maintenable

Les boucles while peuvent devenir complexes et difficiles à comprendre si elles ne sont pas écrites correctement. Utilisez des noms de variables significatifs, ajoutez des commentaires pour expliquer le but de la boucle et divisez les tâches complexes en sous-tâches plus petites. Cela rend votre code plus lisible et maintenable.

Techniques et astuces avancées

Les boucles While peuvent être utilisées de manière avancée pour accomplir des tâches spécifiques. Voici quelques techniques et astuces avancées :

Boucler avec des instructions Else

En Python, vous pouvez utiliser une instruction else avec une boucle while pour exécuter un bloc de code lorsque la condition de boucle devient False. L'autre bloc n'est exécuté que si la boucle se termine normalement sans aucune instruction break. Voici un exemple :

num = 1
while num <= 5:
    print(num)
    num += 1
else:
    print("Loop completed")

Sortie

1

2

3

4

5

Boucle terminée

Dans cet exemple, le bloc else est exécuté une fois la boucle terminée normalement.

Utiliser des boucles While avec des listes et des chaînes

Les boucles While peuvent être utilisées pour parcourir des listes et des chaînes à l'aide d'une variable d'index. Voici un exemple :

fruits = ["apple", "banana", "cherry"]
index = 0
while index < len(fruits):
    print(fruits[index])
    index += 1

Sortie

pomme

banane

cerise

Dans cet exemple, la boucle while parcourt les éléments de la liste « fruits » en utilisant la variable d'index.

Lisez également : Tout ce que vous devez savoir sur les structures de données intégrées en Python – Guide du débutant !

Comparaison avec d'autres constructions de boucle en Python

Les boucles While ne sont que l'une des nombreuses constructions de boucles disponibles en Python. Comparons les boucles while avec les boucles for et la récursivité :

Boucles While et boucles For

Bien que les boucles et les boucles soient toutes deux utilisées pour l'itération, elles ont des cas d'utilisation différents. Les boucles While sont plus flexibles et peuvent gérer des conditions complexes, tandis que les boucles for sont mieux adaptées pour itérer sur une séquence de valeurs. Les boucles While sont utiles lorsque vous ne connaissez pas le nombre exact d'itérations à l'avance ou que vous devez effectuer des calculs complexes. Les boucles sont utiles lorsque vous souhaitez parcourir une séquence de valeurs, telle qu'une liste ou une chaîne.

Boucles While vs récursivité

La récursivité est une technique dans laquelle une fonction s'appelle pour résoudre un problème. Il peut être utilisé pour réaliser des tâches répétitives similaires aux boucles while, mais il présente quelques différences. Les boucles While sont plus adaptées aux tâches itératives pour lesquelles vous avez une condition de fin claire et devez effectuer un nombre fixe d'itérations. La récursivité est plus adaptée à la résolution de problèmes divisés en sous-problèmes plus petits, tels que les algorithmes de recherche, de tri et de traversée d'arbres.

Conclusion

Dans cet article, nous avons exploré le concept des boucles while en Python. Nous avons découvert leur syntaxe, leur utilisation de base et diverses applications. Nous avons également discuté de conseils, de bonnes pratiques, d'erreurs courantes et de techniques avancées d'utilisation des boucles while. Enfin, nous avons comparé les boucles while avec d'autres constructions de boucles en Python. Grâce à ces connaissances, vous pouvez désormais utiliser efficacement les boucles while pour automatiser les tâches répétitives et parcourir des séquences de valeurs dans vos programmes Python.

Libérez la puissance de l’excellence en IA et en ML ! Inscrivez-vous maintenant à notre Programme certifié AI & ML BlackBelt Plus et élevez vos compétences vers de nouveaux sommets. Ne manquez pas l'opportunité de maîtriser les dernières technologies – Transformez votre carrière dès aujourd'hui !

De plus, si vous recherchez un cours Python en ligne, explorez notre – Introduction au programme Python dès aujourd'hui !

Services Connexes

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.analyticsvidhya.com/blog/2024/01/python-while-loop-with-examples/