Comment faire des itérations en python
5.1 Mise à jour des variables
Un modèle commun dans les déclarations d'affectation est une instruction d'affectation qui met à jour une variable - où la nouvelle valeur de la variable dépend de l'ancien. Cela signifie « obtenir la valeur actuelle de x. Ajouter un, puis mettre à jour x avec la nouvelle valeur. »
Si vous essayez de mettre à jour une variable qui n'existe pas, vous obtenez une erreur, parce que Python évalue le côté droit avant qu'il attribue une valeur à x. Avant de pouvoir mettre à jour une variable, vous devez l'initialiser, le plus souvent avec une simple affectation:
5.2 L'instruction while
Les ordinateurs sont souvent utilisés pour automatiser des tâches répétitives. La répétition des tâches identiques ou similaires sans faire des erreurs est quelque chose que les ordinateurs font bien et les gens font mal. Parce que l'itération est si commune, Python offre plusieurs fonctionnalités de langage pour le rendre plus facile.
Une forme d'itération en Python est l'instruction while. Voici un programme simple qui compte à rebours de cinq ans et dit alors « précèderont! ». Vous pouvez presque lire la déclaration de tout comme si elle était l'anglais. Cela signifie, « Bien que n est supérieur à 0, afficher la valeur de n et réduire la valeur de n par 1. Lorsque vous arrivez à 0, quittez l'instruction while et d'afficher le mot précèderont! »
De manière plus formelle, voici le flux d'exécution pour une instruction while:- Évaluer l'état, ce qui donne Vrai ou Faux.
Le corps de la boucle doit changer la valeur d'une ou plusieurs variables de sorte que finalement la condition devient fausse et la boucle se termine. Nous appelons la variable qui change chaque fois que la boucle exécute et contrôle lorsque la boucle se termine la variable d'itération. S'il n'y a pas de variable d'itération, la boucle se répète jamais, ce qui entraîne dans une boucle infinie.
5.3 Les boucles infinies
Une source inépuisable d'amusement pour les programmeurs est l'observation que les instructions sur le shampooing, « Lather, rincer, répéter, » sont une boucle infinie parce qu'il n'y a pas de variable d'itération vous dire combien de fois pour exécuter la boucle.
Dans le cas du compte à rebours. nous pouvons prouver que la boucle se termine parce que nous savons que la valeur de n est fini, et nous pouvons voir que la valeur de n rapetisse chaque fois dans la boucle, donc finalement nous devons arriver à 0. D'autres fois, une boucle est évidemment infini parce qu'il n'a pas variable d'itération du tout.
5.4 « boucles infinies » et rupture
Parfois, vous ne savez pas qu'il est temps de mettre fin à une boucle jusqu'à ce que vous obtenez à mi-chemin à travers le corps. Dans ce cas, vous pouvez écrire une boucle infinie sur le but et ensuite utiliser l'instruction break pour sauter hors de la boucle.
Cette boucle est évidemment une boucle infinie, car l'expression logique sur l'instruction while est simplement la constante logique vrai. Si vous faites l'erreur et exécutez ce code, vous apprendrez rapidement comment arrêter un processus Python emballement sur votre système ou de trouver où le bouton de mise hors tension est sur votre ordinateur. Ce programme fonctionnera toujours ou jusqu'à ce que votre batterie est parce que l'expression logique en haut de la boucle est toujours vrai en vertu du fait que l'expression est la valeur constante True.
Bien que ce soit une boucle infinie dysfonctionnel, on peut encore utiliser ce modèle pour construire des boucles utiles aussi longtemps que nous ajoutons soigneusement le code pour le corps de la boucle pour sortir explicitement la boucle en utilisant pause lorsque nous avons atteint la condition de sortie.
Par exemple, supposons que vous voulez prendre l'entrée de l'utilisateur jusqu'à ce qu'ils tapent fait. Vous pouvez écrire: La condition de la boucle est vrai. qui est toujours vrai, de sorte que la boucle exécute de façon répétée jusqu'à ce qu'elle touche l'instruction break.
A chaque fois par le biais, il demande à l'utilisateur avec une équerre. Si les types d'utilisateurs fait. l'instruction break sort de la boucle. Sinon, le programme fait écho quels que soient les types d'utilisateurs et remonte au sommet de la boucle. Voici une série d'échantillons: De cette façon, l'écriture en boucles est commune parce que vous pouvez vérifier l'état ne importe où dans la boucle (et pas seulement en haut) et vous pouvez exprimer la condition d'arrêt affirmatif ( « stop quand cela arrive ») plutôt que négativement ( « continuer jusqu'à ce que cela arrive. »).
5.5 Finition itérations avec continuer
Parfois, vous êtes dans une itération d'une boucle et que vous voulez terminer l'itération en cours et passer immédiatement à la prochaine itération. Dans ce cas, vous pouvez utiliser l'instruction de continuer à passer à la prochaine itération sans finir le corps de la boucle pour l'itération courante.
5.6 boucles Definite à l'aide de
Parfois, nous voulons faire une boucle à travers un ensemble de choses comme une liste de mots, les lignes dans un fichier ou une liste de numéros. Lorsque nous avons une liste de choses à boucle à travers, on peut construire une boucle définie en utilisant une instruction for. Nous appelons l'instruction while une boucle indéfinie car il boucle simplement jusqu'à ce qu'une condition devient fausse alors que la boucle est une boucle à travers un ensemble d'éléments connus pour qu'il fonctionne à travers autant d'itérations que il y a des éléments dans l'ensemble.
La syntaxe d'une boucle est similaire à la boucle while en ce qu'il est une pour déclaration et un corps en boucle: En ce qui concerne Python, les amis variables est une liste 1 des trois chaînes et la boucle passe par la liste et exécute le corps une fois pour chacune des trois chaînes de la liste résultant de cette sortie: la traduction de cette boucle vers l'anglais n'est pas aussi direct que le temps. mais si vous pensez d'amis comme un ensemble. il va comme ceci: « Exécutez les déclarations contenues dans le corps de la boucle une fois pour chaque ami dans l'ensemble nommé amis. ».
En regardant la boucle, et en sont des mots réservés Python, et amis et amis sont des variables.
pour ami amis:
print 'Happy New Year', ami
En particulier, un ami est la variable d'itération pour la boucle. L'ami de variable change pour chaque itération de la boucle et le contrôle lorsque la boucle se termine. L'itération des étapes variables successivement par les trois chaînes stockées dans la variable d'amis.
5.7 modèles de boucle
Souvent, nous utilisons pour ou en boucle pour parcourir une liste d'éléments ou le contenu d'un fichier et que nous cherchons quelque chose comme la plus grande ou la plus petite valeur des données que nous parcourons.
Ces boucles sont généralement construites par:- Initialisation une ou plusieurs variables avant que la boucle commence.
5.7.1 comptage et boucles sommateurs
Par exemple, pour compter le nombre d'éléments dans une liste, nous écrivions ce qui suit pour boucle: Nous avons fixé le nombre variable de zéro avant que la boucle commence, nous écrivons une boucle à parcourir la liste des numéros. Notre variable d'itération est nommé itervar et alors que nous ne itervar utilisons pas dans la boucle, il ne contrôle la boucle et provoquer le corps de la boucle à exécuter une fois pour chacune des valeurs de la liste.
Dans le corps de la boucle, on ajoute un à la valeur actuelle de comptage pour chacune des valeurs de la liste. Alors que la boucle est en cours d'exécution, la valeur du compte est le nombre de valeurs que nous avons vu « jusqu'à présent ».
Une fois la boucle terminée, la valeur du compte est le nombre total d'éléments. Le nombre total « tombe dans notre tour » à la fin de la boucle. Nous construisons la boucle pour que nous avons ce que nous voulons quand la boucle se termine.
Une autre boucle similaire qui calcule le total d'un ensemble de nombres est la suivante: Dans cette boucle, nous utilisons la variable d'itération. Au lieu d'ajouter simplement un au nombre que dans la boucle précédente, on ajoute le nombre réel (3, 41, 12, etc.) au total en cours d'exécution au cours de chaque itération de la boucle. Si vous pensez à la variable total. il contient le « total cumulé des valeurs jusqu'à présent ». Donc, avant que la boucle commence au total est égal à zéro, parce que nous avons pas encore vu aucune valeur, au cours du total de la boucle est le total en cours d'exécution, et à la fin du total de la boucle est le total global de toutes les valeurs de la liste.
Comme la boucle est exécutée, le total accumule la somme des éléments; une variable utilisée de cette façon est parfois appelé un accumulateur.
Ni la boucle de comptage ni la boucle de sommation sont particulièrement utiles dans la pratique parce qu'il ya des fonctions intégrées LEN () et somme () qui calcule le nombre d'éléments dans une liste et le total des éléments de la liste, respectivement.
5.7.2 boucles maximales et minimales
Avant la boucle commence, la plus grande valeur que nous avons vu jusqu'à présent aucun puisque nous avons pas encore vu aucune valeur. Alors que la boucle est en cours d'exécution, si la plus grande est None nous prenons la première valeur que nous considérons comme le plus grand à ce jour. Vous pouvez le voir dans la première itération lorsque la valeur de itervar est 3, puisque la plus grande est None. nous plus d'être 3 fixé immédiatement.
Après la première itération, le plus important est plus Aucun. de sorte que la deuxième partie du composé expression logique qui vérifie itervar> déclenche plus grand que lorsque nous voyons une valeur qui est plus grande que le « plus grand jusqu'à présent ». Quand on voit une nouvelle valeur « encore plus » nous prenons cette nouvelle valeur pour le plus grand. Vous pouvez le voir dans la sortie du programme que le plus grand progresse 3-41 à 74 ans.
A la fin de la boucle, nous avons scanné toutes les valeurs et les plus grandes ne contiennent désormais la plus grande valeur de la variable dans la liste.
Pour calculer le plus petit nombre, le code est très similaire avec un petit changement: Encore une fois, le plus petit est le « plus petit jusqu'à présent » avant, pendant et après exécution de la boucle. Lorsque la boucle est terminée, contient la plus petite la valeur minimale dans la liste.
Là encore, comme dans le comptage et la sommation, les fonctions intégrées max () et min () faire de l'écriture de ces boucles exactes inutiles.
Ce qui suit est une version simple du Python fonction intégrée min (): Dans la version fonction du code le plus petit, nous avons supprimé toutes les déclarations d'impression de manière à être équivalente à la fonction min qui est déjà intégré à Python .
5.8 Mise au point
Comme vous commencez à écrire des programmes plus importants, vous pourriez vous retrouver dépenser plus de temps de débogage. Plus le code signifie plus de chances de faire une erreur et plus d'endroits pour les bugs à cacher.
Une façon de réduire votre temps de débogage est « mise au point par bissectrice. » Par exemple, s'il y a 100 lignes dans votre programme et vous les vérifier un à la fois, il faudrait 100 pas.
Au lieu de cela, essayer de briser le problème en deux. Regardez au milieu du programme, ou à proximité, pour une valeur intermédiaire, vous pouvez vérifier. Ajoutez une instruction d'impression (ou autre chose qui a un effet vérifiable) et exécuter le programme.
Si le contrôle point médian est incorrect, le problème doit être dans la première moitié du programme. Si elle est correcte, le problème est dans la deuxième moitié.
Chaque fois que vous effectuez un contrôle comme celui-ci, vous réduire de moitié le nombre de lignes que vous avez à la recherche. Après six étapes (ce qui est beaucoup inférieur à 100), vous seriez vers le bas à une ou deux lignes de code, au moins en théorie.
Dans la pratique, il est pas toujours clairement ce que le « milieu du programme » est et pas toujours possible de le vérifier. Il ne fait pas de sens de compter les lignes et trouver le point médian exact. Au lieu de cela, pensez à des endroits dans le programme où il pourrait y avoir des erreurs et des endroits où il est facile de mettre un chèque. Ensuite, choisissez un endroit où vous pensez que les chances sont à peu près les mêmes que le bogue est avant ou après la vérification.
5.9 Glossaire
accumulateur: Une variable utilisée dans une boucle pour ajouter ou accumuler un résultat.
Compteur: Une variable utilisée dans une boucle pour compter le nombre de fois quelque chose est arrivé. Initialisant un compteur à zéro et incrémenter le compteur à chaque fois que nous voulons quelque chose de « compter ».
Incrément: Une mise à jour qui augmente la valeur d'une variable (souvent par une).
boucle infinie: une boucle dans laquelle la condition de terminaison est jamais satisfait ou pour lesquels il n'y a pas de condition de terminaison.
itération: l'exécution répétée d'un ensemble d'états en utilisant soit un appel de fonction récursive ou une boucle.
5.10 Exercices
Exercice 1Write un programme qui lit à plusieurs reprises des numéros jusqu'à ce que l'utilisateur entre « fait ». Une fois « fait » est entré, imprimez le total, compter, et la moyenne des chiffres. Si l'utilisateur entre autre chose qu'un numéro, détecter leur erreur en utilisant try et except et imprimer un message d'erreur et passez au numéro suivant.
Exercice 2Write un autre programme qui invite à entrer une liste de numéros comme ci-dessus et aux imprimés finaux à la fois le maximum et le minimum des numéros au lieu de la moyenne.
1 Nous examinerons des listes plus en détail dans un chapitre ultérieur