What Is None in Python?

None is a built-in constant that stands for the absence of a value. The interpreter creates exactly one None object, and every reference to None points at it. You can check that with the identity operator.

print(None is None)          # True

x = None
y = None
print(x is y)              # True, one object and two names

print(None == False)       # False, it is not the same value
print(bool(None))          # False, but it is falsy
print(None or 'fallback')  # fallback

# Every empty container is falsy as well.
values = [0, '', [], {}, None]
for value in values:
    print(repr(value), '->', bool(value))

Two distinctions matter here, and people regularly mix them up. Falsy means that the object is treated as false in a boolean context, and None qualifies for that. Equal means that the object compares equal to another object, and None equals only None. So None is falsy but it is not equal to False, and an empty list is falsy but it is not equal to None either.

That gap is the reason why the correct test for a missing value is is None rather than == None, and why the correct test for a usable value is if value is not None rather than if value. The second mistake quietly throws away an empty string, a zero, or an empty list, and all of those are values that a function might legitimately return.

There is one more practical note. A function that returns nothing returns None without saying so, so a missing return statement cannot be told apart from an explicit return None. That is deliberate in Python, because there is no separate missing-value marker to be confused with, but it does mean that callers should check for None instead of assuming that a return value exists.

None and False are different objects with different meanings. None means that no value was provided, or that a lookup failed, or that a function came back without a value. False means a genuine boolean answer of no. They are not equal, so None == False is False, even though both of them are falsy in a boolean context.

The rule for testing is to use is None. None is a singleton, so the only correct test for it is identity. There is exactly one None object, and is None compares directly against that object. Writing == None happens to give the right answer today, because the equality of None is identity, but it is the wrong tool for the job. It expresses the wrong question, and it will behave differently for any class that overrides __eq__ and does not handle None in a sensible way.

There is a classic trap here. A custom class defines __eq__ to compare itself against something else, and then a comparison against None raises an exception instead of returning False. Using is None avoids that whole problem, because the identity operator never calls __eq__.

The complementary mistake is to use a bare truthiness check. Writing if result: is wrong when the function may legitimately return an empty list, an empty string, or a zero, because all of those are falsy but they are not missing. Writing if result is not None: tests exactly what you mean.

The one place where the singleton nature of None is genuinely useful is as a default value for a parameter. A parameter that defaults to None can be told apart from any real value that the caller supplies, and that is how you build a function that is safe from the shared mutable default argument bug.