Python: if not val, vs if val is None

Question

I've always coded in the style of if not value, however, a few guides have brought to my attention that while this style works, it seems to have 2 potential problems:

1. It's not completely readable; if value is None is surely more understandable.
2. This can have implications later (and cause subtle bugs), since things like [] and 0 will evaluate to False as well.

I am also starting to apply this idea to other comparisons, such as:

• if not value vs if value is False
• if not value vs if value is []

And so goes the list...

The question is, how far do you go with the principle? Where to draw the line, while keeping your code safe?

Should I always use the if value is None style no matter what?

Answer 1

Use a comparison to None if that's what you want. Use "if not value" if you just want to check if the value is considered false (empty list, none, false).

I find "if not value" to be cleaner looking and Pythonic.

Also, be careful with lists. You should not use is when comparing for an empty list. If you know you're getting a list, use if <list> to check if it has any contents (or len()). Try typing this into the interpreter:

>>> a = []
>>> a is []
False

This is because the temporary list you just made has a different address in memory than the one stored at 'a'. You don't see this with None, False, or True because these are all values that are singletons (they all refer to the same section of memory) so using the 'is' keyword works.

You'll also find that CPython interns strings so the following works.

>>> 'a' is 'a'
True

You should not rely on this. It is an implementation detail and this is not specified to work with every version of Python.

Answer 2

No. If you want to run code when the value is false but isn't None, this would fail horribly.

Use is None if you're checking for identity with the None object. Use not value if you just want the value to be False.

Answer 3

Your use of the is operator is a little problematic. if value is [] will always be false, for example, because no two active lists have the same identity. It works great with None because None is a singleton (all references to None are the same object) but for other comparisons, use ==.

However, if value and if not value are perfectly readable and useful. IMHO there's no need to be more specific, unless you need to treat various types of truthy or falsy values differently, as, for example, distinguishing between 0 and None.

Answer 4

My answer is simple, as it applies to most coding problems: Don't try to write something that just works. Try to express your intent as clearly as possible. If you want to check if a value is false, use if not value. If you want to check for None, write it down. It always depends on the situation and your judgement.

You should not try to find rules which can be applied without thinking. If you find those rules, it's a job for a computer, not for a human! ;-)

Answer 5

if not value:
    pass

is fine and "pythonic". It does not cause subtle bugs, the rules are explicit and (I find) easy to understand.

If you need to differentiate between False and None, as you mentioned use:

if not value is None:  # or False, or == [], etc.
    pass

# more readable
if value is not None:  # or False, or != [], etc.
    pass

I find the above rarely necessary though.

In general, it is preferred to make positive conditions, and put them first. They are easier to understand at a glance and hold up well as complexity increases (as it always seems to).

if value:
    pass
else:
    pass