Introduction
En programming, un Pour boucle est connue comme une boucle avec un nombre connu de répétitions. Mais en Python, cette boucle est une déclaration plus générale. Cela signifie que la boucle For est utilisée lorsque le nombre d'itérations est connu avant d'entrer dans la boucle, contrairement à la Tandis que boucle, qui est basée sur des conditions.
Préparatifs avant de commencer
Avant de pouvoir commencer, nous devons effectuer deux étapes :
- Installer OC en cours d'exécution sur Ubuntu/Debian/CentOS et faire une première configuration de système ;
- Installer et configurer environnement virtuel on Python.
Boucle "Pour"
La Pour la construction de la boucle ressemble à ceci :
for 'variable' in 'sequence':
'action'Regardons sur une exécution une boucle à l'intérieur du Python interpréteur de commandes.
Nous allons écrire un petit programmeramm, la variable n est assigné après lui et il va imprimer des nombres de 6 à 11 et en utilisant le imprimer().
for n in range(6,11):
print(n)
En programming, l'indexation des nombres commence par 0, pour cette raison, en conséquence, nous voyons 5 valeurs différentes qui vont de six à onze.
Utiliser range() dans une boucle "For"
L'une des séquences intégrées est range() pour contrôler le nombre de fois que notre boucle va itérer.
range() a trois paramètres :
- Start – est le début de la séquence (optionnel parammètre et valeur par défaut 0)
- Stop - est le point d'arrêt de la séquence (obligatoire)
- Étape - est une étape de séquence (optionnel parammètre et valeur par défaut 1).
Considérons le code avec une boucle for dans laquelle on affecte la variable n et la valeur 15 (l'arrêt parameter) à range() pour que la séquence soit dans cette plage :
for n in range(15):
print(n)Pour arrêter la boucle, parameter 15 a été spécifié, nous avons donc obtenu 15 valeurs de 0 à 14, à l'exclusion du nombre 15.
Regardons le code en utilisant la plage(start/stop) parameters, définissez une boucle for, affectez la variable n et fournissez les valeurs comme début et fin paramètres.
for n in range(10,15):
print(n)
Lorsque nous avons déterminé le point de départ et d'arrêt, nous avons obtenu un résultat compris entre 10 et 15, à l'exclusion du nombre 15.
L'étape parameter est utilisé pour spécifier le pas entre les valeurs de départ et d'arrêt. Considérez l'utilisation d'étapes dans la plage dans le code suivant, déclarez la boucle for et la variable n dans celle-ci, attribuez des valeurs au start/step/stop paramètres :
for n in range(25,50,5):
print(n)
Le résultat est 5 valeurs différentes dans la plage 25-50 en utilisant la valeur 5 comme étapes.
Vous pouvez spécifier un nombre négatif comme étape parameter, comme illustré dans l'exemple suivant. Déclarons une boucle for et une variable, affectons les valeurs 1000,900,-10 à la plage parameters. Pour itérer dans l'ordre inverse :
for n in range(1000,900,-10):
print(n)
Nous avons regardé un programmeram où le point de départ est 1000 et l'utilisation de l'itération inverse a obtenu des valeurs allant jusqu'à 910.
Utilisation d'une liste dans une boucle
Dans les boucles, vous pouvez utiliser une liste comme itération parameters. Au lieu de range(), vous pouvez concevoirnatea variable avant la boucle for et utilisez la variable après in.
Considérez le code avec une variable de liste qui accepte plusieurs mots, puis déclarez une boucle for avec une variable de liste et parcourez les données de cette liste :
list = ['one', 'two', 'three', 'four']
for list in list:
print(list)
Dans cet exemple, nous avons envisagé d'appeler des données à partir d'une liste designated à l'avance. Au lieu de la variable de liste, nous pourrions utiliser une autre variable, mais le résultat serait le même.
Étant donné que les listes et autres types de données sont itérables, ils peuvent être combinés avec la fonction range().
Sélectionnons une variable dans l'exemple ci-dessus, déclarons une boucle for avec la variable item , spécifions la longueur de la liste list dans la plage() parameters. Dans la ligne suivante, en utilisant append, ajoutez le mot cinq à la liste de la liste des variables :
list = ['one', 'two', 'three', 'four', 'five']
for item in range(len(list):
list.append('six')
print(list)
Dans cet exemple, nous avons ajouté 5 mots six égaux au nombre de mots de la liste.
Nous pouvons également utiliser la boucle for pour créer une liste avec différentes valeurs. Dans l'exemple suivant, notons la variable nombres, dans laquelle nous allons déclarer une liste. Ajoutons une boucle for et parameter 25 à la fonction range(). Dans la ligne suivante, nous écrivons une fonction pour initialiser notre liste vide avec la valeur n, qui viendra compléter la liste :
numbers = [ ]
for n in range(25):
numbers.append(n)
print(numbers)
Dans l'exemple, nous avons considéré une variable sans liste, puis ajouté une boucle dans laquelle la plage est de 0 à 25 et en utilisant append, la valeur +1 est ajoutée à 0 et au-delà.
De la même manière, nous pouvons parcourir une chaîne de caractères.
Déclarons le mot variable et assignons-lui rapidement le mot, en utilisant la boucle for, parcourons le mot :
word = 'quickly'
for letter in word:
print(letter)
Dans l'exemple ci-dessus, la boucle for a parcouru rapidement le mot et l'a divisé en lignes.
Vous pouvez utiliser un dictionnaire dans une boucle for. Comme vous le savez, le dictionnaire utilise la clé, le premier mot avant les deux-points, suivi du mot affecté à la clé. Pour appeler correctement une valeur de clé via deux-points, considérez l'exemple suivant :
list_dict = {'name': 'ServerSpace', 'year': '2022'}
for key in list_dict:
print(key + ':' + list_dict[key])
Dans l'exemple ci-dessus, la variable key a été utilisée pour représenter la clé et list_dict[key] a été utilisée pour représenter les valeurs.
Boucles For imbriquées
Une boucle imbriquée est une boucle à l'intérieur d'une boucle for et la construction de boucle imbriquée est la suivante :
for 'first variable to iterate' in 'source loop'
'action'
for 'second variable to iterate' in 'nested loop'
'action'Le programmeram exécute d'abord la première itération de la boucle d'origine, puis passe à la boucle externe et exécute toutes les itérations, revient à la boucle d'origine et exécute l'itération suivante, et ainsi de suite jusqu'à la fin de l'itération de la boucle d'origine. Considérons dans l'exemple suivant, nous allons déclarer une variable num avec des types de données entiers et let avec des caractères.
Dans la boucle d'origine, déclarez la boucle for et la variable num, dans le let externe :
num = [10, 15, 25]
let = ['w', 's', 'x']
for number in num:
print(number)
for letter in let:
print(letter)
Compliquons le problème avec une liste dans une liste. Essayons d'extraire les informations dans des lignes séparées :
- Déclarons la variable list_in_list et ajoutons notre liste à l'intérieur de la variable ;
- Ajoutons la boucle d'origine avec la variable list et list_in_list ;
- Dans la boucle, déclarez l'élément dans la liste ;
- Appelons article.
list_in_list = [['one', 'two', 'three'], [25,50,75], [0.25, 0.50, 0.75]]
for list in list_in_list:
for item in list:
print(item)
Conclusions
Nous venons de parcourir :
- Gamme de séquences();
- Listes et dictionnaires ;
- Boucles imbriquées dans la boucle d'origine.
