Boucles Python - Pour, While, boucles imbriquées avec des exemples

python loops while

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Ce didacticiel vidéo explique le rôle des boucles en Python, leurs types: For, While, Nested Loops avec syntaxe et exemples de programmation pratiques:

Nous avons appris les quatre différents Instructions conditionnelles en Python dans notre tutoriel précédent.

Les boucles sont des concepts de programmation puissants pris en charge par presque tous les langages de programmation modernes. Il permet à un programme d'implémenter des itérations, ce qui signifie essentiellement exécuter le même bloc de code deux fois ou plus.

Bien qu'ils soient pris en charge par tous les langages de programmation modernes et fournissent des fonctionnalités de base similaires, leurs implémentations et leur syntaxe peuvent différer.

Le Série de formation complète sur Python vous donnera une brève idée de ce qu'est Python.

Boucles en Python

Ce que vous apprendrez:

Tutoriel vidéo sur les boucles Python

Que sont les boucles Python

En Python, les instructions sont exécutées de manière séquentielle, c'est-à-dire que si notre code est composé de plusieurs lignes de code, l'exécution commencera à la première ligne, suivie de la seconde, et ainsi de suite.

Cependant, il y aura des cas où nous souhaitons qu'un bloc de code s'exécute plusieurs fois jusqu'à ce qu'une condition soit remplie. Grâce aux instructions de boucle, nous pouvons le faire.

Vous trouverez ci-dessous un organigramme qui illustre le fonctionnement d'une instruction de boucle.

Organigramme d'une instruction de boucle

Sur la base du diagramme ci-dessus, un programme Python démarrera à Début (cercle), et l'exécution passera à l'instruction de condition (Diamond), si la condition est TRUE, alors le programme exécutera le bloc de code.

L'exécution continuera à l'instruction de condition et le même processus se poursuit chaque fois que la condition est VRAI. Il ne sort de la boucle ou arrête d'exécuter le bloc de code que si la condition est FAUX, et dans ce cas, le programme continuera l'exécution séquentiellement.

Python a deux types de boucles.

#	Type de boucle	Description
1	pour boucle	Est une boucle basée sur un itérateur, qui parcourt les éléments des objets itérables tels que les listes, les tuples, les chaînes et exécute un morceau de code à plusieurs reprises plusieurs fois, en fonction du nombre d'éléments dans cet objet itérable.
deux	boucle while	Exécute un bloc d'instructions à plusieurs reprises tant que la condition est TRUE.

Ces deux types de boucles peuvent être utilisées l'une à l'intérieur de l'autre pour générer boucles imbriquées (plus à ce sujet plus tard).

Utilisation générale des boucles Python

En Python, les boucles peuvent être utilisées pour résoudre des problèmes impressionnants et complexes. Vous rencontrerez probablement des problèmes qui vous obligeraient à répéter une action jusqu'à ce qu'une condition soit remplie (alors que la boucle fonctionne mieux ici) ou un problème qui vous oblige à effectuer une action sur un groupe d'éléments (la boucle for fonctionne mieux ici).

Boucle For en Python

Le pour boucle fonctionne bien avec des objets itérables comme listes , tuples , cordes , etc. De cette façon, nous pouvons parcourir les éléments de ces objets et manipuler leurs valeurs en fonction de nos liens.

Le pour boucle est indexé à zéro et a la syntaxe suivante.

for in n:

La condition dans le pour boucle reste VRAI uniquement s'il n'a pas parcouru tous les éléments de l'objet itérable (n). Pour mieux comprendre pour boucle , nous aborderons plusieurs exemples et enfin, nous travaillerons sur un exemple pratique.

Exemple 1:Numéros d'impression allant du début à la fin

Pour y parvenir, nous utiliserons le Python gamme fonction.

Voici à quoi ressemblera l'organigramme:

Organigramme de la boucle for

def range_from_start_to_end(start, end): for i in range(start, end+1): print(i) if __name__ == '__main__': start = int(input('Enter a start number: ')) end = int(input('Enter an end number: ')) # Call our function to print the ranges range_from_1_to_20(start, end)

Production

for_loop

Dans l'exemple ci-dessus, nous avons utilisé la plage Python, qui est une fonction qui renvoie une séquence de nombres, à partir d'un début nombre (0 par défaut), incrémenté d'un étape (1 par défaut) et s'arrête avant un finir numéro.

Pour cet exemple, nous avons les éléments suivants:

Paramètres et valeurs de la fonction de plage Python

Paramètres	Évaluer
début	1
finir	vingt
étape	1 (valeur par défaut)

Donc notre pour boucle itérera à travers une séquence de nombres de 1 à 20, et pour chaque itération, il imprimera le nombre. L'itération s'arrête lorsque tous les numéros de la séquence ont été visités.

Exemple 2:Déterminez si un nombre est un nombre premier.

Dans cet exemple, nous verrons pourquoi le pour boucle est si puissant et utile. Ici, nous allons parcourir une séquence de nombres, et pour chaque nombre, nous allons effectuer un calcul pour déterminer si une condition est VRAI ou FAUX.

Il peut être utile de connaître les conditions pour qu'un nombre soit premier.

Le nombre est toujours positif, supérieur à 1.
N'a pas de diviseurs positifs autres que 1 et lui-même.

def isPrime(number): # rule 1: number should be positive, and greater than 1. if number > 1: # iterate over a range from 2 to half the number. for i in range(2, number//2): # rule 2: shouldn't have any positive divisor # order than 1 and itself. if(number % i) ==0: return False return True else: return False if __name__ == '__main__': number = int(input('Enter number to check if it's prime: ')) if isPrime(number): print('{} is a prime number'.format(number)) else: print('{} is not a prime number'.format(number))

Sortie lorsque l'entrée est 13

vérifier si c

Sortie lorsque l'entrée est 10

vérifier si ce n

Remarque: Le sinon utilisé dans l'exemple ci-dessus est une instruction conditionnelle et non une boucle. Mais tout comme le boucle while (que nous aborderons bientôt), il utilise les opérateurs de comparaison pour sa condition.

Exemple - Rechercher le nombre de mots dans un texte à l'aide de la boucle for

Cet exemple consiste à compter le nombre de fois où chaque mot apparaît dans un texte. Il y a tellement de façons dont cela peut être réalisé, mais pour cet exemple, nous utiliserons le pour boucle .

Nous compterons les mots du texte ci-dessous.

Bonjour, bienvenue dans l'aide de Software Testing. Dans cet article: 'Boucles en Python', vous découvrirez les boucles avec des exemples pratiques. Super non? Assurez-vous de suivre pendant que nous apprenons ensemble.

Bon codage!

La première chose que nous allons faire est de supprimer les ponctuations, les espaces et toutes les lettres minuscules. Nous supprimerons la ponctuation de la manière traditionnelle en identifiant les ponctuations qui existent dans notre texte, puis utiliserons le pour boucle pour les remplacer par une chaîne vide.

Comme le texte n'est pas grand-chose, on voit que les ponctuations sont virgules (,), point final (.), point d'interrogation (?), côlon (:), guillemet double (') et apostrophe («).

Vous trouverez ci-dessous le code pour les remplacer par une chaîne vide. Notez que nous ne remplacerons pas l'apostrophe.

# replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower()

Production

Comptez le mot

Ensuite, nous diviserons le texte en une liste de mots séparés par des espaces.

# Split text into list of words separated by whitespaces(tab, newline) text = text.split()

Production

diviser le texte

Enfin, nous compterons et verrons combien de fois chaque mot apparaît dans le texte fractionné.

# initialize a dictionary to hold words:count wordsCount = {} # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1

Production

Practical_WordCount_count

Nous pouvons clairement voir certains mots apparaître deux fois, et certains une seule fois. Trions ce dictionnaire en fonction de sa valeur par ordre décroissant afin que nous puissions clairement le différencier. Ici, nous avons utilisé le Python fonction triée , expression lambda , et compréhension du dictionnaire .

qu'est-ce que la gestion des données de test dans les tests logiciels

# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)}

Enfin, nous avons utilisé le pour boucle pour nettoyer, compter et trier les mots de notre texte.

Le code complet est donné ci-dessous.

def word_count(text): # initialize a dictionary to hold words:count wordsCount = {} # replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(') text = text.split() # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1 # Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)} print(wordsCount) if __name__ == '__main__': text = 'Hello, welcome to Software Testing Help. In this article: 'Loops in Python',  you'll learn about loops with practical examples.  Great right? Make sure to follow along as we learn together. 
  Happy coding!' word_count(text)

Sortie finale

Comptage de mots pratique - Sortie finale

La boucle While

Le Python boucle while exécute un bloc d'instructions à plusieurs reprises tant que la condition est TRUE. On remarque que c'est un peu similaire au si déclaration . Cependant, contrairement au boucle while , l'instruction if s'exécute une seule fois si sa condition est TRUE.

La boucle while a la syntaxe suivante:

While condition: expression(block of code)

Contrairement au pour boucle , le boucle while n'itère pas sur une séquence. Il utilise les opérateurs de comparaison et les booléens pour sa condition.

Examinons quelques exemples pour mieux comprendre comment il est utilisé.

Exemple 1:Imprimer «Hello World!» un nombre de fois

Le boucle while vérifie la condition (compteBonjour le monde! »Et incrémente le décompte.

Voici à quoi ressemblera l'organigramme:

Organigramme de la boucle while

def print_count_times(n): # set count to 0 count = 0 while count  Production: 
  
  Exemple 2:Trouver la factorielle d'un nombre 
 La factorielle d'un nombre est représentée par n! et il a la formule
1*2*...*(n-1)Le programme vérifie si le nombre est 0 et renvoie 1 (la factorielle de 0 est 1). Puis le boucle while vérifie la condition (n> = 1) pour voir si notre n est égal à 1 ou supérieur à 1. Chaque fois que cette condition est TRUE, notre programme calcule la formule dans le bloc de boucle
  Utilisons la boucle while pour résoudre le problème factoriel 
def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))  Production 
  
 Exemple - Trouver une séquence de Fibonacci jusqu'au nième terme à l'aide de la boucle While
 Une séquence de Fibonacci a la formule.
0,1,1,...((n-1)th + (n-2)th)Les deux premiers nombres sont 0 et 1, puis les nombres suivants sont la somme des deux nombres précédents (n-1) th et (n-2) th.
 La séquence de Fibonacci de 8 sera 0,1,1,2,3,5,8,13
def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count Production 
  
 Notre programme définit d'abord la première nième valeur (n1 = 0), puis il vérifie si le n_term passé en argument est égal à 1. Si TRUE, il renvoie 0.
  Sinon, il définit deux variables: 
  count = 0: Ceci sera utilisé dans le boucle while pour vérifier la condition si le nombre est inférieur à n_term (count 
n2 = 1: C'est notre deuxième nième valeur.
 
  Jusqu'à présent, nous avons 0,1 dans notre séquence (n1, n2). Tant que la condition est VRAIE: 
  La valeur de n2 est affectée à une variable temporaire (temp = n2).
 La somme des deux nombres précédents est calculée et attribuée à n2 (n2 = n1 + n2).
 Notre valeur temporaire (ancienne valeur n2) est affectée à n1 (n1 = temp).
 Notre décompte est incrémenté (décompte + = 1) et la condition est à nouveau vérifiée.
 
 À la fin de la première itération, nous avons 0,1,1 où:
  n1 = 1 (le premier 1)
 n2 = 1 (le deuxième 1)
 
 Cette opération se répétera jusqu'à ce que la condition compte 
Boucle imbriquée
 Ce qui est cool avec les boucles Python, c'est qu'elles peuvent être imbriquées, c'est-à-dire que nous pouvons utiliser une ou plusieurs boucles dans une autre boucle. Cela nous permet de résoudre des problèmes encore plus complexes.
 # 1) Nesting pour les boucles
 les boucles for peuvent être imbriquées en elles-mêmes. La syntaxe ci-dessous montre une boucle for imbriquée à 1 niveau.
for in n: # piece of code goes here for in n: # piece of code goes here  Exemple 1:Utilisez la boucle imbriquée pour pour imprimer des nombres dans des motifs 
  Utilisons la boucle for imbriquée pour imprimer le modèle suivant: 
 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 Chaque numéro est imprimé un certain nombre de fois correspondant à son numéro lui-même.
  Voici à quoi ressemblera l'organigramme: 
  Organigramme d'une boucle for imbriquée
def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print('
') if __name__ == '__main__': print_numbers()  Production 
  
  Notre programme fonctionne comme suit: 
  La boucle externe parcourt la plage de 1 à 6 et pour chaque élément de cette séquence.
 Il entre dans la boucle interne où il itère sur une plage de cet élément.
 Pour chaque itération de cet élément, il imprime l'élément.
 Il ne quitte la boucle interne que lorsqu'il a complètement parcouru une plage de cet élément.
 Lorsqu'il quitte la boucle interne, il retourne à la boucle externe et le processus se poursuit jusqu'à ce qu'il soit complètement itéré sur sa séquence.
 
  Exemple 2:Manipuler les éléments d'une liste imbriquée à l'aide d'une boucle for imbriquée 
 Une situation que nous rencontrerons probablement en Python est d'accéder aux éléments d'une liste imbriquée.
  Par exemple, prenez la liste imbriquée ci-dessous. 
>>> ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) Pour cet exemple, écrivons un programme qui comptera le nombre d'entiers et de flottants dans cette liste imbriquée.
def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) float_n, int_n = float_and_int_count(nested_list) print('Float count: {} 
Integer count: {}'.format(float_n, int_n))  Production 
  
  Notre programme fonctionne de cette façon: 
  La boucle externe accède aux premières listes internes (3,4.0,2,8.4,6) de notre liste imbriquée.
 La boucle interne accède à chaque élément de cette première liste interne. Pour chaque élément, il vérifie s'il s'agit d'un flottant ou d'un entier. S'il s'agit d'un entier, il incrémente le nombre d'entiers (int_count). Sinon, s'il s'agit d'un float, il incrémente le nombre de float (float_count).
 Une fois qu'il a fini d'itérer à travers cette première liste interne, il revient alors à la boucle externe et accède à la deuxième liste (0,2,0.2,4,6) et le même processus continue jusqu'à ce qu'il ait accédé à toutes les listes internes.
 
 # 2) Imbrication pendant les boucles
 Les boucles While peuvent être imbriquées en elles-mêmes.
  La syntaxe ci-dessous montre une boucle while imbriquée à 1 niveau. 
comment sélectionner le bouton radio dans sélénium webdriver
while condition: # piece of code goes here while condition: # piece of code goes here  Exemple 3:Utilisez une boucle while imbriquée pour imprimer des étoiles (*) dans des motifs 
  Utilisons une boucle while imbriquée pour construire le modèle suivant: 
* * * * * * * * * * * * * * * def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)  Production 
  
  Notre programme fonctionne comme suit: 
  Les variables sont initialisées (i = 0, j = 0, n = 5)
 Notre boucle externe vérifie la condition (0<= 5) which is obviously TRUE.
 Notre boucle interne vérifie la condition (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
 i est incrémenté et la boucle externe vérifie à nouveau sa condition (1<= 5) which is TRUE.
 Notre boucle interne vérifie la condition (0<1) which is TRUE. So a star( * ) est imprimé et j est incrémenté et la condition de la boucle interne est vérifiée avec (1<1) which is FALSE, thus breaks out of the inner loop.
 
 Le processus ci-dessus se poursuit jusqu'à ce que la condition de la boucle externe devienne FAUX.
 Exemple - Jeu d'orthographe des nombres
 Pour arrondir avec un boucle imbriquée , nous allons créer un jeu passionnant pour aider à évaluer la capacité de l’enfant à reconnaître et à épeler des nombres.
 Le programme affiche des nombres aléatoires à l'écran et demande l'orthographe de ce nombre. Il vérifie si l'entrée est correcte, puis il affiche un autre numéro. Si l'entrée est erronée, il enverra un message d'erreur et demandera une autre réponse.
import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME.
') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS
') print('-----------------------------------------------
') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count  Production 
  
  Les principales fonctionnalités de nos boucles for et while sont: 
  Le pour boucle parcourt une liste de nombres qui sont présentés à l'utilisateur pour épeler.
 Le boucle while vérifie si le nombre d'essais a été dépassé. De cette manière, un utilisateur reçoit un nombre maximum d'essais pour bien faire les choses.
 
 Nous avons vu deux nouveaux concepts while-else , Pause (plus à ce sujet plus tard). Le boucle while et pour boucle ont à l'origine un autre déclaration qui ne s'exécute qu'une seule fois lorsque la condition est FALSE.
 Boucles infinies Python
 Si nous ne faisons pas attention à la façon dont nous implémentons nos boucles, cela peut conduire à un boucle infinie c'est-à-dire que le programme exécutera un bloc de code pour toujours jusqu'à ce que notre ordinateur soit à court de ressources comme la mémoire du processeur.
  Exemple 1:Boucle while infinie 
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()  Production 
  
  Noter : Pour arrêter ce programme de s'exécuter, utilisez Ctrl + z ou Ctrl + c sur le terminal que vous avez utilisé pour exécuter le code.
 Notre code ci-dessus implémente un boucle while infinie . Cependant, c'est par erreur parce que notre boucle while vérifie la condition numb<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.
 Donc, le moyen de résoudre ce problème est de fournir un moyen d’augmenter la valeur de numb.
def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()  Production 
  
 Une question peut se poser telle quelle boucles infinies vraiment nécessaire? Alerte spoiler: Oui, ils le sont. Un serveur peut être programmé pour fonctionner en continu tout en répondant aux besoins des clients. Dans le jeu, un événement peut s'exécuter jusqu'à ce que l'utilisateur sélectionne une action pour quitter ou rompre la boucle.
 Croyez-le ou non, nous avons en fait utilisé un boucle infinie dans le dernier exemple pratique ci-dessus. Alors, comment traitons-nous boucles infinies ?
 Instructions Python Break And Continue
 Comme nous l'avons expliqué ci-dessus, il y a des cas où nous devrons écrire intentionnellement boucles infinies . Dans ces cas, nous verrons que le Pause et Continuez les mots clés sont la colonne vertébrale de boucles infinies .
 Le Pause et Continuez les mots-clés sont couramment utilisés dans un Python si déclaration où l'instruction if vérifie une condition et si c'est VRAI, nous sortons de la boucle dans laquelle notre instruction if a été appelée ou continuons en sautant tout le code en dessous et revenons au début de la boucle.
 Exemple - Accumuler des nombres jusqu'à ce qu'un seuil soit atteint
 Considérons un programme qui obtient des nombres à partir d'une source générée aléatoirement et accumule les nombres jusqu'à ce qu'un seuil soit atteint.
 La raison pour laquelle cet exemple nécessite une boucle infinie est que nous ne savons pas exactement combien d'itérations notre programme devra effectuer pour que les nombres accumulés atteignent le seuil.
 Notre seul sauveur est le Python si déclaration avec la déclaration break . Notre instruction if vérifie si le seuil est atteint, puis elle sort de la boucle si TRUE.
 Notre programme exige également que certains numéros restreints ne soient pas cumulés. Donc, si notre programme rencontre ces nombres, il devrait sauter tous les codes et retourner au début de la boucle. Ceci est réalisable avec le continue déclaration .
import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = (4,0,1) # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()  Production 
  
 Questions fréquemment posées
  Q # 1) Comment contrôlez-vous une boucle en Python? 
   Répondre:   En Python, vous pouvez contrôler une boucle avec les instructions de contrôle suivantes:
  Le Pause Le mot clé sort d'une boucle.
 Le Continuez Le mot-clé ignore tous les codes en dessous et revient au début de la boucle.
 
 Ces mots-clés sont principalement utilisés dans un si déclaration qui vérifie d'abord si une condition est TRUE ou FALSE.
  Q # 2) Quelle est la différence entre la boucle for et la boucle while? 
  Répondre: À pour boucle est un boucle basée sur un itérateur , qui parcourt les éléments des objets itérables comme listes , tuples , etc. Pendant qu'un boucle while est un boucle basée sur des conditions , qui exécute un bloc d'instructions à plusieurs reprises tant que sa condition est TRUE.
  Q # 3) Python prend-il en charge la boucle jusqu'à? 
  Répondre: Malheureusement, Python ne prend pas en charge le boucle do-while .
  Q # 4) Quels sont les deux types de boucles en Python? 
logiciel de téléchargement de vidéos youtube pour pc
  Répondre: Python prend généralement en charge deux types de boucles: pour boucle et boucle while . Cependant, une troisième boucle ( boucle imbriquée ) peut être généré en imbriquant deux ou plusieurs de ces boucles.
 En savoir plus sur les boucles Python
 Les instructions de bouclage en python sont utilisées pour exécuter un bloc d'instructions ou de code à plusieurs reprises plusieurs fois comme spécifié par l'utilisateur.
  Python nous fournit 2 types de boucles comme indiqué ci-dessous: 
  Alors que la boucle
 Pour boucle
 
 # 1) Boucle While:
 La boucle While en python est utilisée pour exécuter plusieurs instructions ou codes à plusieurs reprises jusqu'à ce que la condition donnée soit vraie.
 Nous utilisons une boucle while lorsque nous ne connaissons pas le nombre d'itérations.
  Syntaxe: 
 while (expression): block of statements Increment or decrement operator Dans la boucle while, nous vérifions l'expression, si l'expression devient vraie, alors seulement le bloc d'instructions présent à l'intérieur de la boucle while sera exécuté. Pour chaque itération, il vérifiera la condition et exécutera le bloc d'instructions jusqu'à ce que la condition devienne fausse.
  Exemple: 
 number = 5 sum = 0 i = 0 while (i Production: 
 dix
  
  Production: 
  
 # 2) Pour la boucle:
 La boucle For en python est utilisée pour exécuter un bloc d'instructions ou de code plusieurs fois jusqu'à ce que la condition donnée devienne fausse.
 Nous utilisons la boucle for lorsque nous connaissons le nombre d'itérations.
  Syntaxe: 
 for var in sequence: Block of code Ici, var prendra la valeur de la séquence et l'exécutera jusqu'à ce que toutes les valeurs de la séquence soient terminées.
  Exemple: 
 language = (‘Python’, ‘Java’, ‘Ruby’) for lang in language: print(“Current language is: “, lang)  Production: 
 La langue actuelle est: Python
 La langue actuelle est: Java
 La langue actuelle est: Ruby
  
  Production: 
  
  Boucle For utilisant la fonction range (): 
 La fonction Range () est utilisée pour générer une séquence de nombres.
  Par exemple, range (5) générera des nombres de 0 à 4 (5 nombres).
  Exemple: 
 language = (‘Python’, ‘Java’, ‘Ruby’) for lang in range(len(language)): print(“Current language is: “, language(lang))  Production: 
 La langue actuelle est: Python
 La langue actuelle est: Java
 La langue actuelle est: Ruby
  
  Production: 
  
 Conclusion
 Dans ce tutoriel, nous avons vu la définition des boucles, les types de boucles Python, l'utilisation de pour boucle, et boucle while avec quelques exemples.
 Nous avons également appris comment boucles imbriquées sont générés et boucles finies aussi et nous avons appris à utiliser le Pause et Continuez mots clés.
  => Vérifiez TOUS les didacticiels Python ici  
   Tutoriel PREV | Tutoriel SUIVANT  
  lecture recommandée
    Instructions de contrôle Python (Python Continue, Break et Pass)  
  Variables Python  
  Tutoriel Python pour les débutants (formation pratique gratuite sur Python)  
  Instructions conditionnelles Python: instructions if_else, elif, imbriquées if  
  Opérateurs Python  
  Fonctions de chaîne Python  
  Tutoriel Python DateTime avec des exemples  
  Fonctions Python