Que signifie «while True» en Python?

def play_game(word_list):
    hand = deal_hand(HAND_SIZE) # random init
    while True:
        cmd = raw_input('Enter n to deal a new hand, r to replay the last hand, or e to end game: ')
        if cmd == 'n':
            hand = deal_hand(HAND_SIZE)
            play_hand(hand.copy(), word_list)
            print
        elif cmd == 'r':
            play_hand(hand.copy(), word_list)
            print
        elif cmd == 'e':
            break
        else:
            print "Invalid command."

Alors que QUOI est vrai?

Je pense que dire «tant que vrai» est un raccourci, mais pour quoi faire? Pendant que la variable «main» reçoit une valeur? Et si la variable «main» ne reçoit pas de valeur?

while Truesignifie boucle pour toujours. L' whileinstruction prend une expression et exécute le corps de la boucle tandis que l'expression prend la valeur (booléen) "true". Trueévalue toujours la valeur booléenne «true» et exécute ainsi indéfiniment le corps de la boucle. C'est un idiome auquel vous vous habituerez finalement! La plupart des langues que vous êtes susceptible de rencontrer ont des idiomes équivalents.

Notez que la plupart des langages ont généralement un mécanisme pour sortir prématurément de la boucle. Dans le cas de Python, c'est la breakdéclaration dans le cmd == 'e'cas de l'exemple dans votre question.

ma question: alors que ce qui est vrai?

Tant que Truec'est True.

La boucle while s'exécutera tant que l'expression conditionnelle sera évaluée True.

Puisque Truetoujours évalué à True, la boucle s'exécutera indéfiniment, jusqu'à ce que quelque chose dans la boucle returns ou breaks.

ma question: alors que ce qui est vrai?

Tout ce qui se trouve à l'intérieur du () de l'instruction while va être évalué comme un booléen. Cela signifie qu'il est converti en vrai ou faux.

Considérez dans la déclaration while(6 > 5)

Il évalue d'abord l'expression 6 > 5qui est trueainsi équivaut à direwhile(true)

Tout ce qui n'est pas FALSE, 0, une chaîne vide "", null ou undefined est susceptible d'être évalué comme vrai.

Quand j'ai commencé à programmer, j'avais l'habitude de faire des choses comme if(foo == true), je ne savais pas que c'était pratiquement la même chose que if(foo).

Alors quand tu dis c'est while(true)comme direwhile(true == true)

Donc, pour répondre à votre question: alors que VRAI est Vrai.

tandis que Truec'est vrai - c'est-à-dire toujours. C'est une boucle infinie

Notez la distinction importante ici entre Truelequel est un mot-clé dans la langue indiquant une valeur constante d'un type particulier, et «vrai» qui est un concept mathématique.

Dans ce contexte, je suppose que cela pourrait être interprété comme

do
...
while cmd  != 'e' 

Trueest toujours True, donc while Trueboucle pour toujours.

Le whilemot clé prend une expression et effectue une boucle tant que l'expression est vraie. Trueest une expression qui est toujours vraie.

À titre d'exemple éventuellement clarifiant, considérons ce qui suit:

a = 1
result = a == 1

Ici, a == 1reviendra True, et donc mis Trueen result. Par conséquent,

a = 1
while a == 1:
  ...

est équivalent à:

while True:
  ...

à condition de ne pas modifier la valeur de l' aintérieur de la whileboucle.

Formellement, Trueest une constante intégrée Python de type booléen .

Vous pouvez utiliser des opérations booléennes sur des types booléens (à l'invite interactive python par exemple) et convertir des nombres en types booléens:

>>> print not True
False
>>> print not False
True
>>> print True or False
True
>>> print True and False
False
>>> a=bool(9)
>>> print a
True
>>> b=bool(0)
>>> print b
False
>>> b=bool(0.000000000000000000000000000000000001)
>>> print b
True

Et il y a potentiellement des "gotcha" avec ce que vous voyez et ce que voit le compilateur Python:

>>> n=0
>>> print bool(n)
False
>>> n='0'
>>> print bool(n)
True
>>> n=0.0
>>> print bool(n)
False
>>> n="0.0"
>>> print bool(n)
True

Pour savoir comment Python stocke les types booléens en interne, vous pouvez convertir les types booléens en nombres entiers et True sera 1 et False 0:

>>> print True+0
1
>>> print True+1
2
>>> print False+0
0
>>> print False+1
1

En fait, le booltype Python est une sous-classe du inttype de Python :

>>> type(True)
<type 'bool'>
>>> isinstance(True, int)
True

La partie la plus importante de votre question est "Qu'est-ce que c'est while True?" est «ce qui est vrai», et un corollaire important: qu'est-ce qui est faux?

Tout d'abord, pour chaque langue que vous apprenez, apprenez ce qu'elle considère comme «véridique» et «faux». Python considère Truth légèrement différemment de Perl Truth par exemple. D'autres langages ont des concepts légèrement différents de vrai / faux. Sachez ce que votre langage considère comme vrai et faux pour différentes opérations et contrôle de flux pour éviter de nombreux maux de tête plus tard!

Il existe de nombreux algorithmes dans lesquels vous souhaitez traiter quelque chose jusqu'à ce que vous trouviez ce que vous recherchez. D'où la boucle infinie ou la boucle indéfinie. Chaque langage a tendance à avoir son propre idiome pour ces constructions. Voici les boucles infinies courantes en C, qui fonctionnent également pour Perl:

for(;;) { /* loop until break */ }

/* or */

while (1) {
   return if (function(arg) > 3);
}

La while True:forme est courante en Python pour les boucles indéfinies avec un moyen de sortir de la boucle. Apprenez le contrôle de flux Python pour comprendre comment vous sortez des while Trueboucles. Contrairement à la plupart des langages, par exemple, Python peut avoir une elseclause sur une boucle. Il y a un exemple dans le dernier lien.

Une whileboucle prend un argument conditionnel (ce qui signifie quelque chose qui est généralement vrai ou faux, ou qui peut être interprété comme tel), et ne s'exécute que lorsque la condition cède True.

Quant à while True? Eh bien, le vrai conditionnel le plus simple est Truelui - même! Il s'agit donc d'une boucle infinie, généralement bonne dans un jeu qui nécessite beaucoup de boucles. (De mon point de vue, cependant, il est plus courant de définir une sorte de variable "done" sur false, puis de la rendre vraie pour terminer le jeu, et la boucle ressemblerait plus while not done:ou autre.)

Dans certaines langues, True est juste et alias pour le nombre. Vous pouvez en savoir plus sur la raison en en lisant davantage sur la logique booléenne .

Pour répondre directement à votre question: tant que la condition de boucle est True. Ce qui est toujours le cas, dans ce bit de code particulier.

whileles boucles continuent à boucler jusqu'à ce que la condition soit fausse. Par exemple (pseudocode):

i = 0
while i < 10
  i++

À chaque itération de la boucle, isera incrémentée de 1, jusqu'à ce qu'elle soit 10. À ce stade, la condition i < 10n'est plus vraie et la boucle se terminera.

Puisque la condition dans while Trueest explicitement et toujours true, la boucle ne se terminera jamais (jusqu'à ce qu'elle soit interrompue d'une autre manière, généralement par une construction comme breakdans le corps de la boucle).

Rien ne vaut Trueplus vite que True. Donc, c'est bien si vous utilisez à la while Trueplace de while 1==1etc.

while True:
    ...

signifie boucle infinie.

L'instruction while est souvent utilisée pour une boucle finie. Mais l'utilisation de la constante 'True' garantit la répétition de l'instruction while sans avoir besoin de contrôler la boucle (en définissant une valeur booléenne à l'intérieur de l'itération par exemple), à ​​moins que vous ne souhaitiez la rompre.

En réalité

True == (1 == 1)

tandis que True signifie une boucle infinie, cela est généralement utilisé par un processus long. vous pouvez changer

while True:

avec

while 1:

Bien que la plupart de ces réponses soient correctes à des degrés divers, aucune n'est aussi succincte que je le souhaiterais.

En termes simples, utiliser while True:n'est qu'un moyen d'exécuter une boucle qui continuera à s'exécuter jusqu'à ce que vous en sortiez explicitement en utilisant breakou return. Puisque True sera toujours évalué à True, vous devez forcer la boucle à se terminer quand vous le souhaitez.

while True:
    # do stuff

    if some_condition:
        break

    # do more stuff - code here WILL NOT execute when `if some_condition:` evaluates to True

Alors que normalement une boucle serait définie pour s'exécuter jusqu'à ce que la condition while soit fausse ou qu'elle atteigne un point final prédéfini:

do_next = True

while do_next:

    # do stuff

    if some_condition:
        do_next = False

    # do more stuff - code here WILL execute even when `if some_condition:` evaluates to True

Ces deux morceaux de code font effectivement la même chose

Si la condition par rapport à laquelle votre boucle évalue est peut-être une valeur qui ne figure pas directement dans votre contrôle, telle qu'une valeur d'entrée utilisateur, alors la validation des données et la sortie explicite de la boucle sont généralement nécessaires, vous voudrez donc le faire avec l'une ou l'autre méthode .

Le while Trueformat est plus pythonique puisque vous savez que cela breakbrise la boucle à ce point précis, alors que vous do_next = Falsepourriez faire plus de choses avant la prochaine évaluation de do_next.

Tout peut être considéré comme vrai jusqu'à ce que le contraire soit présenté. C'est ainsi que fonctionne la dualité. C'est une façon de comparer les contraires. Le noir peut être vrai jusqu'au blanc, auquel point il est faux. Le noir peut également être faux jusqu'au blanc, auquel point il est vrai. Ce n'est pas un état mais une comparaison d'états opposés. Si l'un ou l'autre est vrai, l'autre est faux. Vrai ne signifie pas qu'il est correct ou accepté. C'est un état où le contraire est toujours faux. C'est la dualité.