Comparing boolean values with == works in Python. But when I apply the boolean not operator, the result is a syntax error:
Python 2.7 (r27:82500, Sep 16 2010, 18:02:00)
[GCC 4.5.1 20100907 (Red Hat 4.5.1-3)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> True == True
True
>>> False == False
True
>>> True is not False
True
>>> True == not False
File "<stdin>", line 1
True == not False
^
SyntaxError: invalid syntax
>>>
Why is this a syntax error? I would expect not False to be an expression that returns a boolean value, and True == <x> to be valid syntax wherever <x> is an expression with valid syntax.
Answers:
Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.
Method 1
It has to do with operator precedence in Python (the interpreter thinks you’re comparing True to not, since == has a higher precedence than not). You need some parentheses to clarify the order of operations:
True == (not False)
In general, you can’t use not on the right side of a comparison without parentheses. However, I can’t think of a situation in which you’d ever need to use a not on the right side of a comparison.
Method 2
It’s just a matter of operator precedence. Try:
>>> True == (not False) True
Have a look in this table of operator precedences, you’ll find that == binds tigher than not, and thus True == not False is parsed as (True == not) False which is clearly an error.
Method 3
Answers claiming that the reason for True == not False constituting a syntax error had to do with operator precedence are mistaken. If that were the case, the expression 2 ** - 1 would yield a syntax error as well, which of course it doesn’t. Precedence never causes an operator to be drawn in in place of an operand.
The true reason for True == not False being a syntax error is that there exists no syntax rule that would produce a comparison therefrom, since
comparison ::= or_expr (comp_operator or_expr)*
– i. e. after the comp_operator == an or_expr must follow, which includes an xor_expr, an and_expr, a shift_expr, an a_expr, an m_expr, an u_expr, a power…, but no not_test.
By comparison, the precedence-wise similar construct 2 ** - 1 in accordance with the power rule
power ::= (await_expr | primary) [“**” u_expr]
has u_expr following the power operator **, thus allowing - x on the right hand side.
Method 4
Python has an operator precedence (This is like Bodmas in maths. Certain operators are considered before others. Eg: multiplication operator is considered before addition). In python ‘==’ comes before ‘not’ in the operator precedence. Therefore, in your line of code, the first thing that Python analyses is ‘False == not’. Because this is incorrect syntax, an error is raised.
Method 5
I think what you are looking for is “and not”. This gives you the results you are looking towards. If your comparing booleans what you have is a compound boolean expression, here is an example website Compound Boolean Expression.
>>> True and True True >>> True and not True False >>> True and not False True >>> False and not True False >>> False and not False False >>> False and False False
All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0