Skip to main content

How to Check for None in Python

In Python, None represents the absence of a value. Correctly checking for None is crucial for avoiding errors and writing robust code.

This guide explains the right way to check if a variable is None (and is not None), using the is and is not operators, and why using == or != is generally incorrect for this purpose.

Checking if a Variable IS None (Using is)​

The correct and Pythonic way to check if a variable is None is to use the is operator:

my_var = None

if my_var is None:
    print('variable is None')  # This will be printed
  • is checks for object identity. It tests if two variables refer to the exact same object in memory.

Checking if a Variable is NOT None (Using is not)​

To check if a variable is not None, use the is not operator:

my_var = 'example'

if my_var is not None:
    print('variable is not None')  # This will be printed

Why is and is not are Preferred over == and !=​

None is a Singleton​

None is a singleton in Python. This means there's only one instance of None in existence during the lifetime of your program. The is operator checks for object identity, which makes it perfect for checking singletons such as None.

print(id(None))  # Always the same ID
print(id(None))  # Always the same ID (same as above)
  • This means that comparing to None using the identity operator is will always return the correct result.

Object Identity vs. Equality​

  • is / is not (Identity): Checks if two variables point to the same object in memory.
  • == / != (Equality): Checks if two variables have the same value. This invokes the __eq__() method, which can be overridden, and therefore can have any custom implementation.

While == might often work correctly for comparing with None, it's not guaranteed to be reliable in all cases. Classes can override the __eq__() method to define custom equality behavior. The is operator, however, always checks for object identity, making it the correct and unambiguous way to test for None.

The PEP 8 style guide also recommends using is and is not when checking for singletons like None.

Checking if a Variable Exists (and is Declared)​

To check if a variable has even been defined (declared), use a try/except block:

try:
    does_this_exist
    print('variable exists')
except NameError:
    print('variable does NOT exist') # This will be printed

  • This handles the NameError that occurs if the variable hasn't been assigned a value. This will test both if the variable has been defined and also whether it has a value of None.

Checking for "Truthy" and "Falsy" Values (Different from None)​

It's essential to understand the difference between checking for None and checking for "truthy" or "falsy" values.

var_1 = None

# Checks if the variable stores a falsy value (includes None, 0, "", [], etc.)
if not var_1:
    print('The variable stores a falsy value')
  • This code checks if var_1 is a falsy value. Many things are falsy in Python, including:
  • None
  • False
  • 0 (zero of any numeric type)
  • Empty sequences and collections ('', [], (), {}, set(), range(0))
note

This is different from checking specifically for None. An empty string ("") is falsy, but it's not None.

Checking Multiple Variables for None​

To check if multiple variables are all None (or are all not None), the most Pythonic way is to use the all() function.

a = 'a'
b = 'b'
c = 'c'
if all(item is not None for item in [a, b, c]):
    print('Multiple variables are NOT None') # This prints
else:
    print('At least one of the variables stores a None value')
  • The all() function returns True if all elements in the iterable are truthy.
  • We are using a generator expression (item is not None for item in [a, b, c]) to iterate through all the variables.
  • The code will check if any of the variables is None.

Table of Contents