Boucles - while - while True, while if, while else
Bonjour a tous.
j'apprends doucement a utiliser ce que j'ai appris et a me faire comprendre par l'interpreteur.
La boucle while a ce stade m'interesse car elle est proche de la langue parlee et du comportement de l'homme quand il calcule "a la main".
Cependant la peinture a la "while" c'est bien difficile meme si ce n'est pas ce qu'il y a de plus" for"!
J'ai un trou dans "while True".
Voici un extrait de wikipedia sur les boucles:
In fact, what you will see a lot of in Python is the following -
Code:
1
2
3
4
5
| while True:
n = raw_input("Please enter 'hello':")
if n.strip() == 'hello':
break |
As you can see, this compacts the whole thing into a piece of code managed entirely by the while loop. Having True as a condition ensures that the code runs until it's broken by n.strip() equalling 'hello'. The only problem with this is that it slows things down a lot - this is due to first testing the True condition for the while, then again testing the n.strip() value compared to the string 'hello'. Another version you may see of this type of loop uses 1 instead of True - this is exactly the same, though in Python 2.*, using while 1 is minutely faster, due to the ability to reassign True to a different value - the interpretor needs to look up the value of the variable, as opposed to loading a constant.
As a programmer, it is up to you which style to use - but always remember that readability is important, and that speed is also important.
Je ne comprends pas ce que veut dire "while True", c'est quoi qui doit être vrai?
Ici on voit l'utilisation de while / if au lieu de while / else
Allez, c'est pas en ayant peur de se ridiculiser qu'on apprend @marco056
voici.
Tu as l'air de savoir manipuler les indentations en repartant a gauche apres les sous-boucles. C'est la que je n'ai rien compris:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| # Un nombre premier est divisible uniquement par 1 et par
# lui-meme.
somme = 2
total = 0
while total < 1000:
total = 1
for x in range (3, 1000000):
for d in range (2, x):
if x % d == 0:
break
else:
somme = somme + x
""" ici la console va me dire" File "somme_de_nombres_premiers.py", line 15
total += 1
^
IndentationError: unindent does not match any outer indentation level
" """
total += 1 #
print(x, " est un nombre premier!", somme, " est la somme actuellement.", total, " est le total de nombres premiers trouves." )
else:
print("La somme totale est ", somme) |
Pourtant je pensais qu'ayant fini avec les "for" ca incrementerait la variable "total".
Quel est le principe que j'ai compris de travers?
Essayer de comprendre les boucles imbriquees NESTED WHILE LOOPS. Demande de clarte
Je me sens un peu mal a l'aise de reflechir a ca en ce triste jour...
bonjours mes chers amis.
Je suis en train de lire un tutoriel qui fait remarquer un phenomene etonnant
Je copie le passage sur lequel je m'interroge:
Code:
1
2
3
4
5
6
7
8
| x = -20
y = 20
while x <= y:
print ("X is now: ", x)
x = x + 1
while x <= 0:
print ("X is negative")
x = x + 1 |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| RESULTAT:
>>>
X is now: -20
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is negative
X is now: 1
X is now: 2
X is now: 3
X is now: 4
X is now: 5
X is now: 6
X is now: 7
X is now: 8
X is now: 9
X is now: 10
X is now: 11
X is now: 12
X is now: 13
X is now: 14
X is now: 15
X is now: 16
X is now: 17
X is now: 18
X is now: 19
X is now: 20
>>> |
Thus, Python will print the count only once X is more than 0. Fin de citation.
La vraie vérité, je ne comprends pas pourquoi. J'étais sur que l'on devait obtenir a chaque fois les deux phrases x is now et x is négative.
Comment se fait-il que quand on rentre dans l'indentation de la sous-boucle on élide l'ordre de la boucle première.
Je pressens que ca a a voir avec les variables globales et locales mais ce n'est pas clair et je ne veux pas me contenter du fait que c'est comme ca et pus c'est tout car un langage de programmation est un langage logique et donc il y a surement un truc évident qui me passe sous le nez.
@(wiztricks, marco 056, lpaxtor)
Donc:
1- énoncés et logique des prédicats != instruction pour faire œuvrer la machine.
2- La machine travaille linéairement c'est a dire point après point et pas deux points a la fois
3- Donc, dixit wiztricks, quand la machine œuvre a la deuxième boucle elle n'a que faire de la grande boucle (le grand bloc)
4- Me fait remarquer paxtor, la deuxième boucle ne commence qu'a partir de - 19, car avec le - 20 elle a déjà fini avant de faire entrer le - 20 dans la deuxième boucle.
J'ai trouve un petit cas ou la constatation 3- ne s'applique pas:
Citation:
Wiztricks a dit: Si Python doit exécuter un bloc "tant que x <= y", il le fait sans se poser de question que ce bloc soit à l'intérieur d'un autre bloc ou pas.
Oui mais regardez cet exemple:
Code:
1
2
3
4
5
6
7
8
| x = 2
y = 3
while x < 20:
print (x)
x += 1
while x % 9 == 0:
print (str(x), "a la coque")
x += 2 |
et le resultat:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 2
3
4
5
6
7
8
('9', 'a la coque')
11
12
13
14
15
16
17
('18', 'a la coque')
------------------
(program exited with code: 0)
Press return to continue |
on y voit clairement que dans la sous boucle l'ordinateur continue a surveiller la condition de la premiere boucle donc python sait pertinament qu'il est a l'interieur d'un autre bloc. J'ai besoin de comprendre encore un peu.
pour ce qui est du quatrieme point pourquoi la deuxieme boucle (dans l'exemple precedent n'ecrit pas a propos de -20 qu'il est negatif. la deuxieme instruction est dans le scope de la boucle)
http://www.developpez.net/forums/ima...ilies/ptdr.gif
Merci a tous. J'essaie de faire a la main
