Est Faux == 0 et True == 1 un détail d'implémentation, ou est-il garanti par la langue?

Est-il garanti que False == 0 et True == 1, en Python (en supposant qu'ils ne sont pas réaffectés par l'utilisateur)? Par exemple, il est en quelque sorte la garantie que le code suivant va toujours produire les mêmes résultats, quelle que soit la version de Python (à la fois existants et, probablement, d'autres dans l'avenir)?

0 == False  # True
1 == True   # True
['zero', 'one'][False]  # is 'zero'

Toute référence à la documentation officielle serait bien apprécié!

Modifier: Comme indiqué dans de nombreuses réponses, bool hérite de int. La question peut donc être qualifié de: "la documentation officiellement dire que les programmeurs peuvent compter sur les booléens héritant de nombres entiers, avec les valeurs 0 et 1?". Cette question est pertinente pour l'écriture de code robuste qui ne manquera pas à cause de détails de mise en œuvre!

  • Il y a de nombreuses raisons de se poser la question ci-dessus. Ainsi, il y a des cas où s'appuyant sur les booléens entier rend votre code plus simple: avez-vous le changer? Ou, vous pouvez repérer les lieux dans un code écrit par quelqu'un d'autre qui s'appuie sur les booléens sont des nombres entiers: avez-vous interrompre ce que vous êtes en train de modifier dans le code afin de "fixer" un code existant, ou vous pouvez être assuré que le courant de codage est le son? Il existe une multitude d'autres exemples. Plus généralement, il est bon de connaître les règles du jeu, de sorte que vous pouvez jouer et le programme dans un son chemin.
  • pouvez-vous fournir un exemple de "s'appuyant sur les booléens entier rend votre code plus simple"? Je ne peux pas imaginer une telle chose. " avez-vous interrompre ce que vous êtes en train de modifier dans le code afin de "fixer" un code existant, ou vous pouvez être assuré que le courant de codage est le son?" La question semble technique, n'est pas "comment dois-je faire?" Les règles sont simples: ne dépendent pas de la mise en œuvre de détails. Alors pourquoi poser des questions sur un détail d'implémentation?
  • Le post original précisément les échos de votre point: la question est essentiellement "Est-ce qu'un détail d'implémentation?", parce que je suis entièrement d'accord avec vous sur l'idée que l'on ne doit pas s'appuyer sur les détails d'implémentation. Si les booléens sont officiellement entiers de valeurs connues, puis le code en question ne repose pas sur les détails de mise en œuvre, ce qui est bon.
  • Lot: Sachant que==False 0 et True==1 en fait, il est plus facile de compter combien de booléens dans une séquence sont remplies: il Vous suffit d'écrire sum(bool_list). Sinon, vous auriez à écrire sum(1 for x bool_list if x).
  • C'est une façon de comptage des valeurs booléennes. Je dirais que bool_list.count(True) est plus explicite; c'est aussi 3 fois plus vite... 🙂
  • Le traitement des booléens comme des entiers est une erreur de type. Si Python a types. Je ne voudrais pas faire des erreurs dans le code.
  • Comme les réponses montrent, Python booléens sont en fait (une sous-classe spécifique de des entiers. En outre, Python, bien évidemment, des types, peut-être que vous avez voulu dire qu'il n'est "pas statiquement typé"? Aussi, je ne suis pas sûr de ce que tu veux dire par "je ne voudrais pas faire des erreurs dans le code". Maintenant, je n'ai jamais aime le mélange des booléens avec des entiers, parce qu'ils sont conceptuellement différentes, et je ne me dérangerait pas si Python booléens n'étaient pas des entiers, mais en sachant qu'ils sont, avec les valeurs 0 et 1, est utile.

InformationsquelleAutor Eric O Lebigot | 2010-05-04
  1. 173

    En Python 2.x c'est pas garanti car il est possible pour True et False être réaffectés. Cependant, même si cela se produit, boolean boolean True et False sont toujours retournés correctement pour les comparaisons.

    En Python 3.x True et False sont des mots-clés et sera toujours égal à 1 et 0.

    Dans des circonstances normales en Python 2, et toujours en Python 3:

    False objet est de type bool qui est une sous-classe de int:

    object
   |
 int
   |
 bool

    C'est la seule raison pour laquelle, dans votre exemple, ['zero', 'one'][False] fonctionne. Il ne serait pas travailler avec un objet qui n'est pas une sous-classe d'un entier, parce que la liste d'indexation ne fonctionne qu'avec des entiers, ou des objets qui définissent un __index__ méthode (merci marque-dickinson).

    Edit:

    Il est vrai de l'actuelle version de python, et de celle de Python 3. Le docs pour python 2.6 et la docs pour Python 3 disent tous les deux:

    Il y a deux types d'entiers: [...] des Entiers (int) [...] les Booléens (bool)

    et dans le booléen paragraphe:

    Booléens: ils représentent les valeurs de vérité de Faux et de Vrai [...] des valeurs Booléennes se comportent comme les valeurs 0 et 1, respectivement, dans presque tous les contextes, à l'exception que lorsqu'il est converti en chaîne de caractères les chaînes de caractères "False" ou "True" sont renvoyés, respectivement.

    Il y a aussi, pour Python 2:

    Dans des contextes numériques (par exemple, lorsque utilisée comme argument d'un opérateur arithmétique), ils [False et True] se comportent comme les entiers 0 et 1, respectivement.

    Donc les booléens sont explicitement considérés comme des entiers en Python 2.6 et 3.

    Ainsi, vous êtes sûr jusqu'à ce que Python 4 vient le long. 😉

    • 0 == 0.0 retourne True alors que ['zero', 'un'][0.0] échoue. ['zero', 'un'][False] fonctionne parce que bool est une sous-classe de type int. (int.__les sous-classes__() renvoie [<type 'bool'>])
    • Pinailler: tout objet qui fournit une __index__ méthode peut être utilisée comme un indice de la liste, et pas seulement des sous-classes de int ou long.
    • Ah oui, il y a aussi. Mais il serait mieux de ne pas le lien vers le Python 3.0 documentation: 3.0 est mort. 🙂
    • Re: "En Python 2.x ce n'est pas garanti qu'il est possible pour le Vrai et le Faux pour être réaffectés". À mon humble avis, si cela est vrai, quelqu'un qui réaffecte Vrai ou Faux mérite quelques étranges conséquences qu'ils obtiennent. Plus précisément, le stockage de Vrai avant la réaffectation, puis de comparer le résultat à Vrai après réaffectation allait se briser. a = True; True = 'i am an idiot'; a == True => False. Autre que cette affection, les valeurs par défaut sont normalisés de 0 et de 1, et je crois qu'il est de pratique courante à en dépendent; par exemple, pour les index dans un tableau à deux éléments, où [0] conserve la fausse affaire, [1] true.
    • Je viens de remarquer un autre fonctionnaire de la confirmation du fait que le Vrai peut dans la pratique être considérées comme 1 et False 0: docs.python.org/2/library/stdtypes.html#boolean-values. Je suis en ajoutant ce pour cette réponse.
    • Upvoting pour le petit lambeau d'espoir que Python 4 va corriger cela. Merci pour cela.

    InformationsquelleAutor Olivier Verdier
  2. 71

    Lien vers le PEP de discuter de la nouvelle type bool en Python 2.3: http://www.python.org/dev/peps/pep-0285/.

    Lors de la conversion d'une valeur bool int, la valeur de l'entier est toujours 0 ou 1, mais lors de la conversion d'un int bool, la valeur booléenne est Vraie pour tous les entiers sauf 0.

    >>> int(False)
0
>>> int(True)
1
>>> bool(5)
True
>>> bool(-5)
True
>>> bool(0)
False
    InformationsquelleAutor Erik Cederstrand
  3. 22

    En Python 2.x, il n'est pas garanti à tous:

    >>> False = 5
>>> 0 == False
False

    De sorte qu'il pourrait changer. En Python 3.x, True, False, et Aucun n'est les mots réservés, de sorte que le code ci-dessus ne fonctionnerait pas.

    En général, avec les booléens, vous devez considérer que tout Faux ont toujours une valeur entière de 0 (tant que vous ne l'avez pas changé, comme ci-dessus), Véritable pourrait avoir toute autre valeur. Je ne serais pas nécessairement compter sur aucune garantie que True==1, mais sur Python 3.x, ce sera toujours le cas, peu importe quoi.

    • Re " Vrai pourrait avoir toute autre valeur. Je ne serais pas nécessairement compter sur aucune garantie que la Vraie==1". En fait, vous POUVEZ compter sur True==1, comme par python.org/dev/peps/pep-0285 , et spec docs.python.org/2/reference/... "des valeurs Booléennes se comportent comme les valeurs 0 et 1, respectivement, dans presque tous les contextes..." je ne dis pas qu'il est impossible de surcharger dans Py 2 en réaffectant Vrai ou Faux, mais je suis en train de dire qu'à moins d'un programmeur sur votre projet est un idiot et d'une telle réaffectation, le comportement est garanti.
    InformationsquelleAutor Daniel G
  4. -1

    Très simple. Comme bool a trait à l'évaluation d'un entier comme un bool, SEULEMENT le zéro donne une réponse fausse. TOUTES les valeurs Non nulles, des flotteurs, des entiers, y compris les nombres négatifs, ou qu'avez-vous, retournera true.

    Un bel exemple de pourquoi c'est utile, c'est de déterminer l'état de l'alimentation d'un périphérique. Sur est une valeur non nulle, off est zéro. Électroniquement parlant cela fait sens.

    Pour déterminer vrai ou faux relativement entre les valeurs, vous devez avoir quelque chose à comparer à. Ceci s'applique pour les chaînes et les nombres, à l'aide de == ou != ou <, > >=, <=, etc.

    Vous pouvez affecter un entier à une variable et ensuite obtenir true ou false selon que la valeur de la variable.

    • La question est de savoir si True == 1 est garanti par Python, et non sur la valeur booléenne d'entiers.
    InformationsquelleAutor Kathy
  5. -2

    Il suffit d'écrire int(False) et vous obtiendrez 0, si vous tapez int(True) il sera de sortie 1

    • Cela signifie seulement que le Faux et le Vrai sont des entrées valides pour int(), avec un simple sens numérique, non pas qu'ils sont exactement identiques à la 0 et 1.
    InformationsquelleAutor Harsh Rathee
  6. -5

    Le faux est un bool. Il a un type différent. C'est un objet différent de 0, ce qui est un entier.

    0 == False renvoie la valeur True parce que de Faux est converti en un entier. int(False) retourne 0

    Le python de la documentation de l'opérateur == est dit (l'aide('==')):

    Les opérateurs <, >, ==, >=, <=, et != comparer les valeurs de deux objets. Les objets n'ont pas besoin d'avoir le même type. Si les deux sont des nombres, ils sont convertis en un type commun.

    Comme une conséquence de Faux est converti en entier pour le besoin de la comparaison. Mais il est différent de 0.

    >>> 0 is False
False
    • Ce n'est pas tout à fait juste: bool est une sous-classe de int, donc dans un sens très réel bool est un entier. Par exemple, isinstance(True, int) renvoie la valeur True. Et le contrôle d'égalité ne pas convertir le bool int, puisque aucune conversion n'est nécessaire: il appelle simplement int.__cmp__ directement. Notez que bool.__cmp__ is int.__cmp__ évalue aussi pour True.
    • -1 pour cette réponse. Description incorrecte de la relation entre bool int (en Python 2). isinstance(True, int) => True. C'est, Vrai EST un entier, et ne nécessite pas de conversion.
    • J'avais un script qui a retourné False ou un Int... à l'aide de while response is False travaillé, et while response == False n'ai pas.. Merci!
    • Que 0 is False est faux vous dit rien. Dans votre interactive interprète, entrez x = -10, puis y = -10, puis x is y et ce aussi faux. Juste parce qu'il y a des optimisations dans le lieu où l'interpréteur Python ré-utilise le même entier des objets dans certaines circonstances (stocker les littéraux entiers comme des constantes, un stage de petits entiers) ne signifie pas que is doit être utilisé lorsque vous voulez tester entier valeur de l'égalité.
    InformationsquelleAutor luc