Table des matières
Les boucles sont l'un des principaux outils de n'importe quel langage. Il existe deux boucles de base en Python, dont l'une est while. Considérez-le, et aussi pour une meilleure compréhension de l'image, un de plus. En effet, en comparaison avec quelque chose de similaire, il est beaucoup plus facile de comprendre n'importe quel matériau, n'est-ce pas ?
La notion de cycle
Une boucle est nécessaire lorsqu'une certaine action doit être effectuée plusieurs fois. C'est très simpliste, car en réalité le champ d'application des cycles est beaucoup plus large. Il existe deux principaux types de boucles en Python : for et while. Le plus populaire est pour.
En plus des actions spécifiques, vous pouvez boucler différents morceaux de code jusqu'à un certain point. Cela peut être un certain nombre de fois, ou tant qu'une condition particulière est vraie.
Avant de commencer à comprendre les types de boucles et pendant, en particulier, nous devons encore comprendre ce qu'est l'itération. Il s'agit d'une répétition d'une action ou d'une séquence d'actions pendant le cycle en cours dans l'exécution de l'application en cours.
Cycle pour
Notre boucle For n'est pas un compteur, comme dans beaucoup d'autres langages. Sa tâche est d'énumérer une certaine séquence de valeurs. Qu'est-ce que ça veut dire? Disons que nous avons une liste d'éléments. Tout d'abord, la boucle prend le premier, le deuxième, le troisième, etc.
L'avantage de cette boucle en Python est que vous n'avez pas besoin de déterminer l'index de l'élément pour savoir quand sortir de la boucle. Tout se fera automatiquement.
>>> spisok = [10, 40, 20, 30]
>>> pour l'élément dans spisok :
… imprimer(élément + 2)
...
12
42
22
32
Dans notre exemple, nous avons utilisé la variable élément après la commande for. En général, le nom peut être n'importe quoi. Par exemple, une désignation populaire est i. Et à chaque itération, cette variable se verra attribuer un objet spécifique de la liste, que nous avons appelé le mot approprié.
Dans notre cas, la liste est une suite de nombres 10,40,20,30. A chaque itération, la valeur correspondante apparaît dans la variable. Par exemple, dès que la boucle commence, la variable élément la valeur 10 est attribuée. A l'itération suivante, le dix se transforme en nombre 40, la troisième fois il se transforme en nombre 20, et enfin, à la dernière itération de la boucle, il se transforme en 30.
Le signal de fin de cycle est la fin des éléments de la liste.
Si vous avez besoin de la boucle pour effectuer une énumération classique de valeurs, comme dans d'autres langages de programmation, vous devez créer une liste avec une séquence de nombres naturels jusqu'à la valeur dont nous avons besoin.
>>> spisok = [1,2,3,4,5]
Ou utilisez la fonction ln(), pour déterminer la longueur de la liste. Mais dans ce cas il vaut mieux utiliser une boucle tandis que, car il n'est pas nécessaire d'utiliser une variable.
Si vous avez besoin de changer la séquence de valeurs dans la liste, bouclez en et voici venir à la rescousse. Pour cela, à chaque itération, chaque élément de la liste doit se voir attribuer une valeur appropriée.
Alors que la boucle
Contrairement au cycle en, qui itère simplement sur les valeurs de la séquence, la boucle tout en a plus d'utilisations. Le nom de ce type de cycles est traduit par « encore ». C'est-à-dire "jusqu'à".
C'est une boucle universelle que l'on retrouve dans tous les langages de programmation. Et à certains égards, il ressemble à un opérateur conditionnel if, qui effectue une vérification pour voir si une certaine condition est remplie. Contrairement à l'opérateur conditionnel, tout en effectue la vérification à chaque itération, pas une seule fois. Et seulement si la condition est fausse, la boucle se termine et la commande qui la suit est exécutée. En termes simples, si la situation dans laquelle il travaille n'est plus valable.
Si nous dessinons un cycle tout en de manière simpliste, cela se fait en utilisant un tel schéma.
La branche principale du programme (qui s'exécute en dehors de la boucle) est représentée sur cette figure par des rectangles bleus. La turquoise représente le corps du cycle. À son tour, un losange est une condition qui est vérifiée à chaque itération.
Cycle tout en peut entraîner deux exceptions :
- Si au début de la boucle l'expression logique ne renvoie pas vrai, alors elle ne commence tout simplement pas, ayant terminé avant l'exécution. En général, cette situation est normale, car dans certaines circonstances, l'application peut ne pas prévoir la présence d'expressions dans le corps de la boucle.
- Si l'expression est toujours vraie, cela peut conduire à une boucle. C'est-à-dire au défilement sans fin du cycle. Par conséquent, dans de tels programmes, il devrait toujours y avoir une instruction de sortie de la boucle ou du programme. Cependant, cette situation se produira si le programme a pu déterminer la vérité ou la fausseté d'une condition particulière. Si elle n'a pas réussi à le faire, une erreur est renvoyée à la fin du programme. Ou vous pouvez gérer l'erreur, puis, si elle se produit, un certain code sera exécuté.
Il peut y avoir un grand nombre d'options pour gérer une erreur. Par exemple, le programme peut demander à l'utilisateur de saisir correctement les données. Ainsi, si une personne a indiqué un nombre négatif là où il ne peut être que positif, ou a saisi des lettres là où seuls des chiffres devraient être, le programme peut en parler.
Exemples de boucle While
Voici un exemple de code qui gère une erreur dans ce cas.
n = input("Entrez un entier : ")
tandis que type(n) != int :
essayez:
n = entier(n)
sauf ValueError:
print("Entrée erronée !")
n = input("Entrez un entier : ")
si n % 2 == 0 :
print("Pair")
autre:
imprimer("Impair")
Gardez à l'esprit que Python utilise les deux-points pour déclarer des constructions de code complexes.
Dans le code ci-dessus, nous avons défini comme condition que nous devrions vérifier si le nombre est un entier. Si oui, alors false est retourné. Si non, alors vrai.
Dans la deuxième partie du code, où l'opérateur est utilisé if, nous avons utilisé l'opérateur % pour trouver le reste après l'opération de division. L'étape suivante consiste à vérifier si le nombre est pair. Sinon, le reste est un dans ce cas. En conséquence, le nombre est impair.
En termes simples, le code ci-dessus vérifie d'abord si la chaîne saisie par l'utilisateur est un nombre. Si oui, alors une deuxième vérification est faite pour voir s'il y a un reste de la division par deux. Mais le deuxième bloc ne sera exécuté que lorsque la valeur saisie par l'utilisateur sera numérique.
Autrement dit, la boucle sera exécutée régulièrement jusqu'à ce que la condition se produise. Dans cette situation, cela fonctionne comme ceci.
Autrement dit, vous pouvez partir de l'inverse : boucler une certaine action jusqu'à ce que l'événement devienne faux.
Analyse de code
Voyons maintenant plus en détail comment fonctionne ce code. Pour ce faire, nous allons l'analyser étape par étape.
- Tout d'abord, l'utilisateur saisit une chaîne, qui est acceptée par la variable n.
- Utilisation d'une boucle tout en le type de cette variable est vérifié. A la première entrée, ce n'est pas égal int. Par conséquent, à la suite du test, il s'avère que cette condition est vraie. Par conséquent, le corps de la boucle est entré.
- Avec l'aide d'un opérateur Essai nous essayons de convertir une chaîne en un nombre. Si cela est fait, aucune erreur ne se produit. En conséquence, il n'est pas nécessaire de le traiter. Par conséquent, l'interpréteur revient au début de la boucle et, selon les résultats de la vérification, il s'avère qu'il est devenu un entier. Passons donc à l'étape 7
- Si la conversion a échoué, une ValueError est renvoyée. Dans ce cas, le déroulement du programme est envoyé au gestionnaire except.
- L'utilisateur saisit une nouvelle valeur, qui est affectée à la variable n.
- L'interpréteur revient à l'étape 2 et vérifie à nouveau. S'il s'agit d'une valeur entière, passez à l'étape 7. Sinon, la conversion est retentée selon l'étape 3.
- Avec l'aide d'un opérateur if Détermine s'il y a un reste après avoir divisé un nombre par 2.
- Sinon, le texte "pair" est renvoyé.
- Sinon, le texte « impair » est renvoyé.
Considérons maintenant un tel exemple. Essayez de déterminer combien de fois ce cycle se déroulera ?
somme = 100
i = 0
tant que je < 5 :
n = int(entrée())
totale = totale — n
i = i + 1
print("Restant", total)
La bonne réponse est 5. Initialement, la valeur de la variable i - zéro. L'interpréteur vérifie si la variable est égale i 4 ou moins. Si oui, la valeur est renvoyée. oui, et la boucle est exécutée en conséquence. La valeur est augmentée de un.
Après la première itération, la valeur de la variable devient 1. Une vérification est effectuée, et le programme comprend que ce nombre est à nouveau inférieur à 5. En conséquence, le corps de la boucle est exécuté une deuxième fois. Comme les étapes sont similaires, la valeur est également augmentée de un et la variable est maintenant égale à 2.
Cette valeur est également inférieure à cinq. Puis la boucle est exécutée une troisième fois, ajoutée à la variable i 1 et on lui attribue la valeur 3. C'est à nouveau moins de cinq. Et on arrive donc à la sixième itération de la boucle, à laquelle la valeur de la variable i est égal à 5 (après tout, c'était à l'origine zéro, pour autant que nous nous en souvenions). En conséquence, cette condition ne réussit pas le test, et la boucle est automatiquement terminée et la transition vers l'étape suivante, qui est en dehors de celle-ci (ou la fin du programme, si les étapes suivantes ne sont pas fournies), est effectuée.
Le cycle peut également se produire dans le sens opposé. Voici un exemple de code où, à chaque itération suivante, un est soustrait de la valeur courante de la variable.
somme = 100
tant que somme > 0 :
n = int(entrée())
totale = totale — n
print("Ressource épuisée")
Essayez de deviner ce que fait ce programme ! Imaginez que dans une variable la totalité de votre cycle de coaching doit être payée avant votre dernière session. des informations sur la ressource de programme sont stockées. A chaque fois l'interpréteur vérifie si la ressource existe. Si ce n'est pas le cas, le texte "Ressource épuisée" s'affiche et le programme se ferme. Et à chaque itération de la boucle, la ressource diminue du nombre spécifié par l'utilisateur.
Et maintenant les devoirs. Essayez de modifier le code ci-dessus afin que la variable ne puisse pas physiquement devenir négative.
si code ahaan usoo gudbi
иси
Bonjour
lol