Develop Reference

Python type conversion int <=> bool [duplicate]

This question already has answers here:
Why does 1 == True but 2 != True in Python? [duplicate]
(8 answers)
Closed 1 year ago.
It is in the REPL
>>> 1 == True
True
>>> 2 == True
False
>>> 3 == True
False
>>> -1 == False
False
but
if 3:
print('yes') #prints yes
if not -1:
print('yes') #prints nothing
Why are positive integers not evaluated as True when using ==, but they are evaluated as True in if-statements? 2) Why are negative integers not evaluated as False when using ==, but they are also not evaluated as False in if-statements?
What is the underlying rule, where is it written down?

Every integer except 0 evaluates to True. The reason why your REPL was giving you different results than your if statements is because you aren't evaluating the same expression.
In your REPL you are asking is A equal to B. It's only true for False == 0 or True == 1. In your code you aren't doing a comparison. You are just checking that the variable is not something that could be considered "empty/nonexistent" (so to speak).
in short:
if a == True: and if a: are not the same thing.
If it helps, you can look at it like this:
if changeForADollar == myChange:
vs
if anyChangeAtAll:

Understanding precedence of `not` operator [duplicate]

This question already has answers here:
Priority of the logical operators (order of operations) for NOT, AND, OR in Python
(8 answers)
Closed 2 years ago.
I tried to test empty string in Python (empty string should be "Falsy" as they write in: How to check if the string is empty?). However I used a little bit different syntax and get weird result in the following comparison:
not(''); # result: True
not('hello'); # result: False
not('hello') == False; # result: True
not('hello') == True; # result: True - how is this result possible? (False == True: result must be False)
Thank you for the answer!

The precedence here is not ('hello' == False). 'hello' equals neither True nor False, so both 'hello' == True and 'hello' == False are False, which is then negated by not.
>>> 'hello' == False
False
>>> 'hello' == True
False
>>> not ('hello' == True)
True
Truthiness isn't the same as being equal to True. A string can be truthy (i.e. you can decide whether it's more of a "yes" or a "no"), but at the same time not be equal to a boolean value (because a string is a string and a boolean is a boolean).

It's important to understand that not is an operator, not a function. The parenthesis do nothing for the expression, here's how it is read:
not('hello') == True
# is the same as
not 'hello' == True
# which is the same as
not ('hello' == True)
# which is equivalent to
not False
# which is
True
Which happens to evaluate to the same as the expression above (for the same reason that 'hello' == False is False.
The correct way of enforcing precedence with not would be to do
(not something) == True

How is 1 == 2 == 2 evaluated? [duplicate]

This question already has an answer here:
How do chained comparisons in Python actually work?
(1 answer)
Closed 2 years ago.
Running this in the REPL gives me
>>> 1 == 2 == 2
False
Which surprised me, in C this would evaluate to 1. I expected the right-hand side to evaluate to True and 1 == True is True in Python. For example, this evaluates as I would expect:
>>> 1 == (2 == 2)
True
How is Python parsing and evaluating the first expression? This, evaluates the same way but this is what I would expect because == is right-associative and would evaluate to 0 in C
>>> 2 == 2 == 1
False

This is due to the operators chaining phenomenon
An example :
>>> 1==2
=> False
>>> 2!=3
=> True
>>> (1==2) and (2!=3)
# False and True
=> False

Why does this boolean expression evaluate to False? [duplicate]

This question already has answers here:
python operator precedence of in and comparison [duplicate]
(3 answers)
Closed 3 years ago.
Can someone explain to me why the Python interpreter evaluates this expression to be False?
1 in [1] == True
I would expect that 1 in [1] would evaluate to True, and obviously True == True would be True. However this isn't what happens - the expression is False. Why does this happen?

== and in are both comparison operators. And when you have multiple comparison operators like this, Python considers it a chained comparison. For example, 1 < x < 10 is equivalent to 1 < x and x < 10.
In your case, 1 in [1] == True is equivalent to (1 in [1]) and ([1] == True), which evaluates to False.

If you have an expression like this python split it to more statements. In fact:
1 in [1] == True equals to: (1 in [1]) and ([1] == True)
Right side is false since [1] != True and whole sentence is false

Why does [] == False evaluate to False but 0 == False to True in python? [duplicate]

This question already has answers here:
Empty list boolean value
(3 answers)
Closed 4 years ago.
I am relatively new to Python and don't understand the following behavior:
Why does the statement
[] == False
evaluate to false, eventhough an empty list is falsy?
Here are more examples - in many other cases it seems that the empty list does behave in a falsy way, just not in [] == False...
>>> 0 == False # what I'd expect
True
>>> not [] # what I'd expect
True
>>> bool([]) # what I'd expect
False
>>> [] == True # what I'd expect
False
>>> [] == False # unexpected
False
>>> bool([]) == False # why does it evaluate to True again now?
True
>>> ([]) == (bool([])) # unexpected
False
>>> (not []) == (not bool([]) # apparently adding 'not' makes it behave as expected again - why?
True
Can somebody please explain this to me? How are these statements internally evaluted? I have a feeling it might be related to chaining comparisons (see e.g. here), but cannot really understand if that's correct and why.

Because falsy isn't False. Falsy just means
bool(some_object) is False
So,
>>> bool([]) is False
True
>>> bool({}) is False
True
>>> bool(0) is False
True