I've always thought of the if not x is None
version to be more clear, but Google's style guide and PEP-8 both use if x is not None
. Is there any minor performance difference (I'm assuming not), and is there any case where one really doesn't fit (making the other a clear winner for my convention)?*
*I'm referring to any singleton, rather than just None
.
...to compare singletons like None. Use is or is not.
This question is related to
python
coding-style
nonetype
boolean-expression
pep8
I would prefer the more readable form x is not y
than I would think how to eventually write the code handling precedence of the operators in order to produce much more readable code.
if not x is None
is more similar to other programming languages, but if x is not None
definitely sounds more clear (and is more grammatically correct in English) to me.
That said it seems like it's more of a preference thing to me.
The answer is simpler than people are making it.
There's no technical advantage either way, and "x is not y" is what everybody else uses, which makes it the clear winner. It doesn't matter that it "looks more like English" or not; everyone uses it, which means every user of Python--even Chinese users, whose language Python looks nothing like--will understand it at a glance, where the slightly less common syntax will take a couple extra brain cycles to parse.
Don't be different just for the sake of being different, at least in this field.
Code should be written to be understandable to the programmer first, and the compiler or interpreter second. The "is not" construct resembles English more closely than "not is".
Both Google and Python's style guide is the best practice:
if x is not None:
# Do something about x
Using not x
can cause unwanted results.
See below:
>>> x = 1
>>> not x
False
>>> x = [1]
>>> not x
False
>>> x = 0
>>> not x
True
>>> x = [0] # You don't want to fall in this one.
>>> not x
False
You may be interested to see what literals are evaluated to True
or False
in Python:
Edit for comment below:
I just did some more testing. not x is None
doesn't negate x
first and then compared to None
. In fact, it seems the is
operator has a higher precedence when used that way:
>>> x
[0]
>>> not x is None
True
>>> not (x is None)
True
>>> (not x) is None
False
Therefore, not x is None
is just, in my honest opinion, best avoided.
More edit:
I just did more testing and can confirm that bukzor's comment is correct. (At least, I wasn't able to prove it otherwise.)
This means if x is not None
has the exact result as if not x is None
. I stand corrected. Thanks bukzor.
However, my answer still stands: Use the conventional if x is not None
. :]
Python
if x is not None
orif not x is None
?
TLDR: The bytecode compiler parses them both to x is not None
- so for readability's sake, use if x is not None
.
We use Python because we value things like human readability, useability, and correctness of various paradigms of programming over performance.
Python optimizes for readability, especially in this context.
The not
binds more weakly than is
, so there is no logical difference here. See the documentation:
The operators
is
andis not
test for object identity:x is y
is true if and only if x and y are the same object.x is not y
yields the inverse truth value.
The is not
is specifically provided for in the Python grammar as a readability improvement for the language:
comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
And so it is a unitary element of the grammar as well.
Of course, it is not parsed the same:
>>> import ast
>>> ast.dump(ast.parse('x is not None').body[0].value)
"Compare(left=Name(id='x', ctx=Load()), ops=[IsNot()], comparators=[Name(id='None', ctx=Load())])"
>>> ast.dump(ast.parse('not x is None').body[0].value)
"UnaryOp(op=Not(), operand=Compare(left=Name(id='x', ctx=Load()), ops=[Is()], comparators=[Name(id='None', ctx=Load())]))"
But then the byte compiler will actually translate the not ... is
to is not
:
>>> import dis
>>> dis.dis(lambda x, y: x is not y)
1 0 LOAD_FAST 0 (x)
3 LOAD_FAST 1 (y)
6 COMPARE_OP 9 (is not)
9 RETURN_VALUE
>>> dis.dis(lambda x, y: not x is y)
1 0 LOAD_FAST 0 (x)
3 LOAD_FAST 1 (y)
6 COMPARE_OP 9 (is not)
9 RETURN_VALUE
So for the sake of readability and using the language as it was intended, please use is not
.
To not use it is not wise.
The is not
operator is preferred over negating the result of is
for stylistic reasons. "if x is not None:
" reads just like English, but "if not x is None:
" requires understanding of the operator precedence and does not read like english.
If there is a performance difference my money is on is not
, but this almost certainly isn't the motivation for the decision to prefer that technique. It would obviously be implementation-dependent. Since is
isn't overridable, it should be easy to optimise out any distinction anyhow.
Personally, I use
if not (x is None):
which is understood immediately without ambiguity by every programmer, even those not expert in the Python syntax.
Source: Stackoverflow.com