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:
Related
This question already has answers here:
Is False == 0 and True == 1 an implementation detail or is it guaranteed by the language?
(3 answers)
Closed 1 year ago.
When I execute this piece of code in python3
x= bool(input())
y= bool(input())
print(x+y)
and when I give input as True True or False False or True False,
I am getting output as 2.
Why is it so? I expected 1 and 0 as the output.
input() in Python 3 returns a string. No data conversions are performed. So the inputs you get are, literally, the strings "True" and/or "False". Then bool() applied to a non-empty string returns True.
>>> bool("True")
True
>>> bool("False")
True
>>> bool("just about anything")
True
>>> bool("") # except an empty string
False
That's why you always get 2 no matter what you enter. Both inputs become True, which equals 1 in a numeric context.
>>> True == 1
True
While people will yell at you if you do this, eval() is the most convenient (although dangerous!) way to evaluate a string as if it were Python code:
>>> eval("True")
True
>>> eval("False")
False
It's dangerous because eval() will evaluate any Python expression, so if you don't trust your input it can trick your program into doing just about anything.
Input converts your input to string format!
bool(str) gives you True state! And then you're trying to do True + True so you get 2!
x = bool(input()) #--> x= True
y = bool(input()) #--> y= True
print(x+y) #--> True + True = 2
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
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
This question already has answers here:
python operator precedence of in and comparison [duplicate]
(3 answers)
Closed 3 years ago.
Why does python obtain such a result?
>>> 1 in [] == False
False
Obviously, '1 in []' is evaluated to False, and 'False == False' is evaluated to True. And 1 in ([] == False) is not valid expression.
On the other hand '(1 in []) == False' is evaluated to True, but I still do not understand why '1 in [] == False' is evaluated to False,
Python interprets 1 in [] == False as
1 in [] AND [] == False. Both of which are False.
Also 1 in [1] == False is False since
1 in [1] AND [1] == False generates True and False. True and False gives us False.
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