Explication détaillée des instructions while et for dans les instructions de boucle Python

Ce qui suit est une explication détaillée des instructions while et for des instructions de boucle Python. Il a une bonne valeur de référence et j'espère qu'il sera utile à tout le monde. Jetons un coup d'oeil ensemble

Il existe deux types de boucles en Python, à savoir : la boucle for et la boucle while. Une boucle for peut parcourir n'importe quelle séquence d'éléments, telle qu'une liste ou une chaîne. L'instruction while est utilisée pour exécuter un programme en boucle, c'est-à-dire, sous certaines conditions, exécuter un certain programme en boucle pour gérer la même tâche qui doit être traitée à plusieurs reprises.

Instruction de boucle (il existe deux types) :

instruction while
instruction for

instruction while :

Problème : saisissez un entier n et laissez le programme afficher n lignes :

bonjour 1
bonjour 2
....
bon sang n

instruction while :

Fonction : Répéter une ou plusieurs instructions selon certaines conditions

Syntaxe :

tandis que expression de vérité :

bloc d'instructions 1...
sinon :
bloc d'instructions 2...

Explication :

1, exécutez d'abord l'expression de vérité, testez que la valeur booléenne est vraie ou fausse
2, si l'expression de vérité est testée Si la valeur est vraie, exécutez l'instruction 1, puis revenez à la première étape et répétez le test
3, si la valeur de test de l'expression de vérité est Faux. Exécutez ensuite le bloc d'instructions 2 dans la clause else, puis terminez l'exécution de l'instruction while. S'il n'y a pas de clause else, terminez directement l'exécution de l'instruction while.
4, la partie de la clause else peut être omise (similaire à l'instruction if).

Par exemple : imprimer 10 lignes de bonjour

i = 1 #Créer et initialiser une variable i qui contrôle la boucle while
while i < ;= 10 :
                                                                                                                                                                                                                                                               bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour



Notes sur l'instruction while :

1 Il est nécessaire de contrôler la valeur de l'expression de vérité de la boucle pour éviter une boucle infinie.
2, les variables de boucle dans les expressions de vérité sont généralement utilisées pour contrôler les conditions de boucle.

3. Habituellement, la boucle doit être modifiée dans le bloc d'instructions de boucle pour contrôler le nombre de boucles et la direction des variables

L'imbrication des boucles while :

l'instruction while elle-même C'est une instruction, et comme d'autres instructions, elle peut être imbriquée dans d'autres instructions composées (telles que : l'instruction if, l'instruction while, l'instruction for... à l'intérieur)

l'instruction while diagramme d'imbrication :

tandis que expression de vérité :

.....
tandis que expression de vérité 2 :

......

sinon :
. .. .....
else :
.....
Par exemple :


Entrez un nombre et imprimez un carré avec la largeur spécifiée :
Par exemple : Entrée : 5

n = int(input("Entrez un nombre :"))
j = 1

tandis que j <= n:

i = 1

while i <= n :
Résultat :
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5


instruction break :


Fonction : utilisée dans les instructions de boucle (while, for) pour terminer l'exécution de l'instruction de boucle en cours.

Remarque :

1. Lorsque l'instruction break est exécutée, les instructions après la pause de cette instruction de boucle ne seront plus exécutées

2. combinaison avec l'instruction if.
3. Lorsque l'instruction break termine la boucle, la clause else de l'instruction de boucle ne sera pas exécutée.

4. L'instruction break ne peut terminer l'exécution de la boucle actuelle, elle ne sautera pas hors du nid. Boucle lourde externe

5, l'instruction break ne peut être utilisée qu'à l'intérieur d'une instruction de boucle (while ou for)
Par exemple :

i = 1
while i < 10 :
print ("La boucle démarre i=",i)
if i == 5 : #Terminer la boucle quand i = 5
break
i += 1
#Run result : [root@localhost data ]# ./test.py

Début de la boucle i= 1

Début de la boucle i= 2
Début de la boucle i= 3
Début de la boucle i= 4
Début de la boucle i= 5


Boucle de la mort :


1 Une boucle infinie fait référence à une boucle dans laquelle la condition de boucle est. toujours vrai
2. Une boucle infinie utilise généralement l'instruction break pour terminer la boucle
3 , la clause else de la boucle infinie ne sera jamais exécutée
Par exemple : utilisez input pour saisir du texte Quand trois. Les signes * sont saisis, cela signifie que la saisie est terminée, sinon elle continuera à tourner en boucle.

s = ""
while True :
a = input("Veuillez saisir le texte (***end)")
if a == '***':
BREAK <> S ​​​​+ = A + 'N'
## Exécuter les résultats : [root@localhost data]#./test.py
Veuillez saisir le texte (*** fin) a
Veuillez saisir le texte (*** se termine)b
Veuillez saisir le texte (*** se termine)v
Veuillez saisir le texte (*** se termine)c
Veuillez saisir le texte (*** se termine)d
Veuillez saisir du texte (***end)*** #Entrez trois *** pour terminer et quitter la boucle
[root@localhost data]#

2 : pour la déclaration (instruction de boucle)

Fonction : utilisée pour parcourir les éléments de données des objets itérables

Syntaxe :

pour la liste de variables dans un objet itérable :

Bloc d'instructions 1...

else :
Bloc d'instructions 2...

Description de la syntaxe :

1, itérable Chaque fois que l'objet fournit un élément, il est attribué tour à tour aux variables de la liste de variables. Une fois l'affectation terminée, exécutez le bloc d'instructions 1 et répétez cette étape

2. Lorsque l'objet itérable ne peut pas fournir de données, exécutez les instructions dans else. clause Bloc 2, puis quittez la boucle.

Par exemple :

s = 'ABCDE'

pour x dans s :
imprimer(x)
sinon :
imprimer ("Continuer à exécuter cet élément") #Lorsque l'objet d'itération ne peut pas fournir de données, continuez à exécuter cet élément dans else
##Résultats d'exécution : [root@localhost data]# ./test.py
A
B
C
D
E
Continuez à exécuter cet article

3, la partie de la clause else peut être omise (similaire à l'instruction while)

4, lorsque vous utilisez break pour terminer la boucle à l'intérieur de l'instruction, le bloc d'instructions de la partie 2 de la clause else ne sera pas exécuté 🎜>Quatre : for imbrication de la boucle :

Identique à. while imbrication de boucles

Par exemple :

pour x dans "ABC":

pour y dans "123":

print(x + y)

##Exécuter le résultat :

[root@localhost data]# ./test.py

A1
A2
A3
B1
B2
B3
C1
C2
C3



Exemple d'imbrication classique sans boucle

Utilisez une boucle for imbriquée pour imprimer les graphiques suivants :

( Entrez un nombre n (moins de 10) pour représenter la largeur et la hauteur du rectangle)

Par exemple : Entrée : 5

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8

5 6 7 8 9

n = int(input( "Entrez un nombre :"))
pour i in range(1, n +1):
for j in range(i, i + n):

print(j,end=' ')

else:

print()
4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9



Cinq : Instruction continue :


Fonction : Utilisée dans les instructions de boucle (tandis que les instructions for), les instructions après continue dans cette boucle ne seront plus exécutées et une nouvelle boucle sera redémarrée.


Explication :

1. Exécutez l'instruction continue dans l'instruction while et passez directement à l'expression de la valeur de vérité de l'instruction while pour réévaluer la condition de boucle.
2. L'exécution de l'instruction continue dans l'instruction for supprimera un élément de l'objet itérable, liera la variable, puis bouclera à nouveau.

Par exemple :

pour i dans la plage(5) :

Si i == 3 : #Quand i est égal à 3, ignorez l'impression et passez à la boucle suivante.
Continuer

PRINT (i)

# Exécuter les résultats
[root@localhost data]# ./test.py
0

1

2

4



Exemple :
Écrivez un programme pour trouver la somme des nombres compris entre 1 et 100 qui ne sont pas divisibles par 5,7,11.


s = 0
pour i dans la plage(1,101) :
si (i % 5) == 0 ou (i % 7) == 0 ou (i % 11) == 0 :

continuer

s += i

imprimer(s)
#Run result :

[root@localhost data]# ./test.py

3007

6 : fonction plage :

Fonction : utilisée pour créer un objet itérable qui génère une série d'entiers (également appelé générateur de séquence d'entiers.)
Format d'appel :
plage (arrêt)
Commencer à zéro, chaque génération ajouter 1 après un entier et fonctionne jusqu'à l'arrêt (hors stop)
plage (start, stop[, step]) commence à partir du début et se déplace d'un pas après avoir généré un entier à chaque fois jusqu'à l'arrêt (hors stop, et le pas peut être un nombre négatif . )
Remarque : si vous imprimez range(5) ou (print(range(5))) directement, vous obtiendrez range(5) au lieu d'une liste. Ceci permet d'économiser de l'espace et d'éviter qu'une liste trop longue soit. généré.
Par exemple :

>>> range(5)
range(0, 5)
>>>
Si vous souhaitez l'insérer en mode interactif Liste, vous pouvez ajouter une liste au premier plan, comme suit :
Exemple :

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> liste(plage(1,6))
[1, 2, 3, 4, 5]
>>> (10, 0,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> 2))
[1, 3, 5, 7, 9]
>>> list(range(5,0,-2))
[5, 3, 1]
> >>

Recommandations associées :

Résumé de l'utilisation de else dans les instructions de boucle Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!