Boucles Python

Types de boucles en Python

Python propose deux principaux types de boucles : la boucle "for" et la boucle "while". Chaque type de boucle a ses propres cas d'utilisation et sert des objectifs différents dans ton code. Comprendre les principales différences entre ces boucles te permettra de prendre la meilleure décision au moment de choisir celle que tu utiliseras dans tes programmes.

La boucle for en Python

Une boucle "for" en Python est utilisée pour itérer sur une séquence, telle qu'une liste, un tuple, une chaîne de caractères ou d'autres objets itérables. À chaque itération, la variable de la boucle prend la valeur de l'élément suivant de la séquence. La boucle "for" est extrêmement utile lorsque tu connais le nombre exact de fois que tu veux exécuter un bloc de code.

fruits = ['pomme', 'banane', 'cerise'] for fruit in fruits : print(fruit)

Outre l'itération directe sur des séquences, tu peux également utiliser la fonction intégrée "range()" pour créer une plage de nombres sur laquelle itérer. La fonction 'range()' prend trois arguments : start, end et step, avec les valeurs par défaut 0, valeur requise et 1, respectivement.

La boucle while en Python

La boucle "while" en Python est utilisée pour exécuter de façon répétée un bloc de code tant qu'une condition spécifique est "vraie". Ce type de boucle est plus souple que la boucle "for" car elle ne repose pas sur une séquence itérable prédéfinie. Au lieu de cela, elle s'appuie sur une condition dynamique qui peut changer à chaque itération de la boucle.

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

Il est essentiel de se rappeler que la condition de la boucle 'while' doit finir par devenir 'False', sinon la boucle continuera à s'exécuter indéfiniment. Cela peut provoquer une boucle infinie, entraînant un plantage ou un programme qui ne répond pas. Assure-toi toujours que ta boucle "while" a une condition de fin appropriée.

Les deux types de boucles Python, 'for' et 'while', constituent des moyens puissants et flexibles d'effectuer des tâches répétitives et de travailler sur des séquences. En comprenant leurs cas d'utilisation et leurs différences, tu pourras prendre des décisions plus éclairées lorsque tu mettras en place des boucles dans tes programmes Python.

Boucle dans une liste en Python

Lorsque l'on travaille avec des listes en Python, il est courant d'itérer sur chaque élément de la liste et d'effectuer des opérations ou de manipuler les données. Python propose plusieurs options pour effectuer des boucles dans une liste, ce qui permet de travailler de manière pratique et efficace avec cette structure de données populaire.

Itérer sur les éléments d'une liste avec une boucle for

L'une des façons les plus courantes de parcourir une liste en Python est d'utiliser une boucle "for". Comme nous l'avons déjà mentionné, la boucle "for" est conçue pour fonctionner avec des séquences telles que les listes. Elle te permet d'accéder à chaque élément de la liste et de le manipuler de manière propre et efficace. Tu peux effectuer diverses tâches, telles que filtrer, transformer ou simplement imprimer les éléments de la liste, à l'aide d'une boucle "for".

nombres = [1, 2, 3, 4, 5] nombres doublés = [] pour num dans nombres : nombres doublés.append(num * 2) print(nombres doublés)

Lorsque tu utilises une boucle "for", tu peux accéder directement à chaque élément de la liste, sans avoir besoin de te référer à leur index. Cependant, si tu veux parcourir une liste en utilisant des indices, tu peux combiner la boucle "for" avec la fonction "range()" et la fonction "len()", qui renvoie la longueur d'une liste.

fruits = ['pomme', 'banane', 'cerise'] for i in range(len(fruits)) : print(f "L'élément {i} est {fruits[i]}")

Lorsque tu dois parcourir plusieurs listes simultanément, tu peux utiliser la fonction intégrée 'zip()' avec une boucle 'for'. La fonction 'zip()' combine plusieurs itérables, tels que des listes, en tuples qui contiennent un seul élément de chaque itérable.

first_names = ['John', 'Jane', 'Mark'] last_names = ['Doe', 'Smith', 'Collins'] for first_name, last_name in zip(first_names, last_names) : print(f"{first_name} {last_name}")

En résumé, la boucle "for" constitue un moyen souple et efficace de parcourir les éléments d'une liste. Elle convient à un large éventail de tâches, de la simple manipulation aux opérations plus complexes impliquant plusieurs listes. Avec la bonne combinaison de fonctions intégrées et de techniques, tu pourras créer un code Python puissant et efficace pour travailler avec des listes.

Interrompre et continuer dans les boucles Python

Lorsque l'on travaille avec des boucles Python, il est essentiel de contrôler le flux d'exécution. Deux mots-clés importants dans ce contexte sont "break" et "continue", qui te permettent de contrôler le comportement de la boucle pendant l'exécution. Ces deux mots-clés peuvent être utilisés dans les boucles "for" et "while". Comprendre comment utiliser 'break' et 'continue' te permettra d'écrire un code plus efficace et plus propre.

Comment utiliser break dans une boucle Python ?

Le mot clé 'break' dans une boucle Python est utilisé pour sortir prématurément d'une boucle avant sa fin naturelle. Lorsque l'exécution atteint une instruction 'break', la boucle se termine immédiatement et le programme continue d'exécuter l'instruction suivante après la boucle.

Voici quelques cas d'utilisation courants du mot-clé "break" :

• Recherche d'un élément spécifique dans une liste ou une autre table itérative.
• Arrêter une boucle lorsqu'une certaine condition est remplie
• Sortir d'une boucle dans un scénario de boucle imbriquée.

fruits = ['pomme', 'banane', 'cerise', 'orange'] cible = 'cerise' for fruit in fruits : if fruit == cible : print(f"{target} found") break

Si l'instruction "break" n'était pas utilisée dans la boucle, celle-ci continuerait à parcourir toute la liste même après avoir trouvé l'élément cible, ce qui serait une opération inutile. L'instruction "break" améliore l'efficacité en arrêtant la boucle dès que l'élément cible est trouvé.

Comment utiliser continue dans une boucle Python ?

Le mot clé 'continue' dans une boucle Python est utilisé pour sauter le code restant à l'intérieur d'une itération de boucle et passer à l'itération suivante. Lorsque l'exécution atteint une instruction 'continue', la boucle passe immédiatement à l'itération suivante, sans exécuter aucune instruction subséquente à l'intérieur de l'itération en cours.

Voici quelques cas d'utilisation courants du mot-clé "continue" :

• Sauter des éléments spécifiques d'une liste ou d'une autre table itérative.
• Passer à l'itération suivante lorsqu'une certaine condition est remplie
• Filtrer ou traiter des éléments dans une boucle

nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9] pour num dans nombres : si num % 2 == 0 : continue print(num)

Dans cet exemple, l'instruction "continue" permet à la boucle de sauter les nombres pairs. Dès qu'un nombre pair est rencontré, l'instruction 'continue' est exécutée et la boucle commence avec l'itération suivante sans exécuter l'instruction 'print()', n'affichant effectivement que les nombres impairs.

En conclusion, les mots-clés "break" et "continue" permettent de mieux contrôler le flux d'exécution des boucles en Python. En utilisant ces mots-clés à bon escient, tu pourras écrire un code plus efficace, plus propre et plus facile à déboguer pour tes applications Python.

Exemples pratiques de boucles Python

Dans cette section, nous allons approfondir les exemples pratiques d'utilisation des boucles Python pour diverses tâches telles que les calculs, la manipulation de données et la validation des données saisies par l'utilisateur.

Utilisation de la boucle for en Python pour les calculs et la manipulation de données

Les boucles "for" de Python sont incroyablement polyvalentes lorsqu'il s'agit d'effectuer des calculs et de manipuler des données. Nous allons explorer des exemples pratiques d'utilisation des boucles 'for' dans ces scénarios, notamment :

• Calculer la factorielle d'un nombre
• Inverser une chaîne de caractères
• Calculer la somme d'une liste de nombres

Calculer la factorielle d'un nombre : La factorielle d'un entier non négatif n, notée n !, est le produit de tous les entiers positifs inférieurs ou égaux à n. Dans cet exemple, nous calculons la factorielle à l'aide d'une boucle 'for'.

def factorial(n) : result = 1 for i in range(1, n + 1) : result *= i return result number = 5 print(f "La factorielle de {nombre} est {factorielle(nombre)}")

Inversion d'une chaîne de caractères : Une autre utilisation pratique des boucles "for" consiste à inverser une chaîne de caractères. Dans cet exemple, nous utilisons une boucle 'for' pour itérer sur les caractères de la chaîne originale et construire une nouvelle chaîne avec les caractères dans l'ordre inverse.

def reverse_string(s) : result = '' for char in s : result = char + result return result input_string = 'hello' print(f "L'inverse de '{chaîne_d'entrée}' est '{reverse_string(chaîne_d'entrée)}'")

Calculer la somme d'une liste de nombres : Lorsqu'on a affaire à des listes de nombres, il est souvent nécessaire de calculer la somme de tous les éléments. Dans cet exemple, nous utilisons une boucle "for" pour parcourir la liste et additionner les nombres.

def sum_of_list(numbers) : total = 0 for num in numbers : total += num return total number_list = [1, 2, 3, 4, 5] print(f "La somme des éléments de {number_list} est {sum_of_list(number_list)}")

Ces exemples pratiques démontrent la puissance et la polyvalence des boucles "for" de Python dans l'exécution d'une variété de calculs et de tâches de manipulation de données.

Mise en œuvre de la boucle while en Python pour la validation des données saisies par l'utilisateur

Un cas d'utilisation courant des boucles "while" en Python est la validation des données saisies par l'utilisateur. Nous allons explorer des exemples pratiques d'utilisation des boucles 'while' à cette fin, notamment :

• Vérification de la saisie d'un nombre entier
• Validation d'une entrée dans une plage spécifiée

Vérification de la saisie d'un nombre entier : Lorsque l'entrée de l'utilisateur doit être un nombre entier, une boucle 'while' peut être utilisée pour s'assurer que l'utilisateur fournit un nombre entier valide avant de continuer.

def get_integer_input(message) : while True : user_input = input(message) if user_input.isdigit() : return int(user_input) else : print("Please enter a valid integer.") number = get_integer_input("Enter a number : ") print(f "The entered number is {number}")

Validation d'une entrée dans une plage spécifiée : Parfois, les données saisies par l'utilisateur doivent se situer dans une plage spécifique. Dans cet exemple, nous utilisons une boucle "while" pour demander à l'utilisateur d'entrer des données jusqu'à ce qu'un nombre compris dans la plage spécifiée soit fourni.

def get_number_in_range(min_value, max_value) : message = f "Entrez un nombre entre {min_value} et {max_value} : " while True : user_input = input(message) if user_input.isdigit() and min_value <= int(user_input) <= max_value : return int(user_input) else : print(f "Invalid input. Veuillez entrer un nombre entre {valeur_min} et {valeur_max}.") number = get_number_in_range(1, 5) print(f "Le nombre sélectionné est {nombre}")

Dans ces exemples, les boucles "while" sont utilisées pour s'assurer que les données saisies par l'utilisateur sont valides avant de procéder à d'autres traitements ou calculs. Cela démontre la polyvalence et l'aspect pratique des boucles 'while' en Python pour la validation des entrées de l'utilisateur.