Is False == 0 and True == 1 an implementation detail or is it guaranteed by the language?

Гарантируется ли, что False == 0 и True == 1 в Python (при условии, что они не переназначены пользователем)? Например, гарантируется ли каким-либо образом, что следующий код всегда будет давать одинаковые результаты, независимо от версии Python (как существующей, так и, вероятно, будущей)?

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

Любая ссылка на официальную документацию была бы весьма признательна!

Как отмечалось во многих ответах, bool наследуется от int. Поэтому вопрос можно сформулировать следующим образом: "Официально ли в документации говорится, что программисты могут полагаться на логические значения, наследуемые от целых чисел, со значениями 0 и 1?". Этот вопрос актуален для написания надежного кода, который не даст сбоя из-за деталей реализации!

В Python 2.x это не гарантируется, поскольку возможно переназначение True и False. Однако, даже если это произойдет, логические значения True и логическое значение False все равно будут корректно возвращены для сравнения.

В Python 3.x True и False являются ключевыми словами и всегда будут равны 1 и 0.

При обычных обстоятельствах в Python 2 и всегда в Python 3:

False объект имеет тип, bool который является подклассом int:

    object
       |
     int
       |
     bool

Это единственная причина, по которой в вашем примере ['zero', 'one'][False] действительно работает. Это не будет работать с объектом, который не является подклассом integer , потому что индексирование списков работает только с целыми числами или объектами, которые определяют __index__ метод (спасибо Марку-дикинсону).

Редактировать:

Это верно для текущей версии python и для версии Python 3. В документах для python 2 и в документах для Python 3 говорится:

Существует два типа целых чисел: [...] Integers (int) [...] Booleans (bool)

и в подразделе boolean:

Логические значения: они представляют истинностные значения False и True [...] Логические значения ведут себя как значения 0 и 1 соответственно почти во всех контекстах, за исключением того, что при преобразовании в строку возвращаются строки "False" или "True" соответственно.

Также есть, для Python 2:

В числовых контекстах (например, при использовании в качестве аргумента арифметического оператора) они [False и True] ведут себя как целые числа 0 и 1 соответственно.

Таким образом, логические значения явно рассматриваются как целые числа в Python 2 и 3.

Таким образом, вы в безопасности, пока не появится Python 4. ;-)

Вот пример обсуждения нового типа bool в Python 2.3: http://www.python.org/dev/peps/pep-0285 / .

При преобразовании bool в int целочисленное значение всегда равно 0 или 1, но при преобразовании int в bool логическое значение равно True для всех целых чисел, кроме 0.

>>> int(False)
0
>>> int(True)
1
>>> bool(5)
True
>>> bool(-5)
True
>>> bool(0)
False

В Python 2.x это вообще не гарантируется:

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

Так что это может измениться. В Python 3.x True, False и None являются зарезервированными словами, поэтому приведенный выше код не будет работать.

В общем случае с логическими значениями вы должны предположить, что в то время как False всегда будет иметь целочисленное значение 0 (до тех пор, пока вы не измените его, как указано выше), True может иметь любое другое значение. Я бы не стал обязательно полагаться на какие-либо гарантии этого True==1, но на Python 3.x это всегда будет так, несмотря ни на что.

Давайте разберем этот вопрос на две части.

Python:

print(45 == "45")  # Output - False

Javascript:

console.log(45 == "45")  # Output - true

Здесь большинство людей думают, что Javascript проверяет только значение обоих побочных объектов, но это неправда, написание console.log(45 == "45") похоже на print(45 == "45").

Но теперь у вас возник вопрос, если оба синтаксиса похожи, почему я получаю разные результаты?

В Javascript :

• Оператор == выполняет приведение к типу перед сравнением значений. Это означает, что JavaScript попытается преобразовать операнды к общему типу перед оценкой равенства.


• В случае 45 == "45" в JavaScript строка "45" автоматически преобразуется в число, потому что другим операндом является число. JavaScript пытается выполнить неявное преобразование типов для сравнения. Строка "45" может быть преобразована в число 45, и, следовательно, сравнение 45 == "45" оценивается как true.


• Аналогично ключевому слову Python is, в Javascript есть === оператор сравнения. Который проверяет, расположены оба побочных объекта в одной и той же ячейке оперативной памяти компьютера или нет.

В Python :

• В Python 45 и "45" имеют разные типы. 45 является экземпляром class <integer>, и "45" является экземпляром class <string>. Они не являются экземплярами одного и того же класса.


• В отличие от Javascript, Python не выполняет внутреннее преобразование типов, поэтому print(45 == "45") вычисляетFalse.


• Python использовал внутреннее преобразование типов, да, вы не ослышались, но есть одно условие. Python будет использовать внутреннее преобразование типов только с boolean объектами типа.


• Итак, в выражении print(True == 1) логическое значение True неявно преобразуется в целое число 1 перед выполнением сравнения. В результате print(1 == 1) оценивается сравнение, которое является True.


• Когда вы пишете, print(True == 1) эквивалентно print(1 == 1). Когда интерпретатор Python достигает этой строки кода перед выполнением этого кода, он преобразуется print(True == 1) в print(int(True) == 1), так что в конечном итоге это становится print(1 == 1) и теперь согласно == правилу оба побочных объекта value и type <class int> одинаковы, следовательно, вы видите True вывод в терминале.


• Аналогично, print(False == 0) эквивалентно print(int(False) == 0) и, наконец, print(0 == 0) вычисляется до True.

Проверьте ЗДЕСЬ.

# Normal behavior
sample_1 = True
print(sample_1) # Output - True
print(int(sample_1)) # Output - 1

sample_2 = False
print(sample_2) # Output - False
print(int(sample_2)) # Output - 0


# Try with True - boolean
A = True + 5  # equivalent to `A = int(True) + 5`
print(A) # Output - 6 (True ---> 1)


# Try with False - boolean
B = False + 5 # equivalent to `A = int(False) + 5`
print(B) # Output - 5 (False ---> 0)


# Try both boolean together
final = False + True # equivalent to `final = int(False) + int(True)`
print(final) # Output - 1  (False ---> 0 & True ---> 1)

Надеюсь, это поможет всем!