Truthiness and None, Explained Like You've Never Coded Before

Every condition in Python eventually boils down to a simple question: "Is this true, or is this false?" But in the real world of code, you aren't always dealing with strict True or False boolean values. Sometimes you are dealing with a list of users, a number from a database, or a variable that just hasn't been assigned anything yet.

How does Python decide if the number 0 is true or false? What about an empty list? What happens when there is simply nothing there at all? To build a solid mental model—moving from a newbie's confusion to a veteran's intuition—we have to look at the causality behind the design. We need to understand why Python makes the decisions it does when evaluating data.

Same approach as always — why first, then what, then code.

---

🚦 Truthiness

In Python, you don't need a literal True or False to trigger an if statement. Every single object in Python has an inherent "boolean value"—a nature of being either fundamentally true-ish or false-ish. We call this Truthiness.

From first principles, this exists to make your code readable and concise. If you want to check if a list has items, you shouldn't have to measure its exact length. You should just be able to ask, "Hey, is there anything in this list?" Truthiness allows objects to answer that question themselves.

Falsy values

The rule for falsy values is incredibly strict and beautifully simple: Python treats anything representing "emptiness", "zero", or "nothing" as False. That's the entire list.

• Numbers that equal zero: 0, 0.0

• Empty collections: [], "", {}, set(), ()

• The literal concept of nothing: None

• The boolean: False

Truthy values

The rule for truthy values is just the inverse: Literally everything else. If it isn't completely empty, zero, or None, Python considers it True.

• Numbers (even negative ones): 1, -42, 3.14

• Collections with anything inside: [0], "hello", {"key": "value"}

• The boolean: True

Analogy: Imagine you are working in a mailroom sorting boxes. A "Falsy" box is either completely empty or has a giant zero written on it. A "Truthy" box has something inside it. It doesn't matter if the box contains a bar of gold or a crumpled piece of trash (like a list containing just the number zero: [0]). If it's not totally empty, it's Truthy.

Numeric truthiness

if 42:
    print("This prints! 42 is truthy.")

if 0:
    print("This never prints. 0 is falsy.")

if -1:
    print("This prints! Negative numbers are truthy.")

Why is 0 falsy but -1 truthy? Because zero represents the absence of quantity. In binary logic, 0 is definitively off, and 1 (or any non-zero voltage) is on.

Empty collections

cart = []

if cart:
    print("Proceed to checkout")
else:
    print("Your cart is empty")  # ✅ This triggers

This is the most common idiomatic use of truthiness in Python. A veteran doesn't write if len(cart) > 0:. They trust the chain of thought: an empty list is empty, therefore it is inherently falsy.

bool() and len()

Behind the scenes, when you put a variable in an if statement, Python silently wraps it in the bool() function.

bool(0)          # False
bool("hello")    # True
bool([])         # False

But how does Python know a list is empty? If an object doesn't explicitly define how to convert itself to a boolean, Python falls back to checking its length using len(). If len(obj) is 0, Python declares it Falsy. If the length is greater than 0, it's Truthy.

Custom truthiness

What if you build your own custom object, like a BankAcount class? By default, all custom objects are Truthy just by existing. But if you want your object to play by Python's native rules, you can define a special __bool__ method inside it. This teaches Python exactly how to answer the question, "Is this specific object currently empty or zero?"

---

🚫 None

If Truthiness is about whether a box is empty or not, None is the realization that there is no box at all.

What is None?

None is a special built-in constant in Python. It has its own unique data type (NoneType). It doesn't mean zero. It doesn't mean empty string. It explicitly means the intentional absence of a value.

Why None exists

Imagine a database query asking for the phone number of a user named "Aman".

• If Aman's phone number is "" (an empty string), it means "Aman has a phone, but the number was deleted."

• If the query returns None, it means "We have absolutely no record of Aman having a phone number field at all."

None exists because we need a programmatic way to represent missing information, uninitialized variables, or a dead end.

None vs False

Analogy: Did you pass the driving test?

• True: Yes, I passed.

• False: No, I took the test and I failed.

• None: I haven't taken the test yet.

False is a definitive answer. None is the lack of an answer.

None vs empty values

wallet = 0       # I have a wallet, and it has exactly zero dollars.
wallet = []      # I have a wallet, and there is nothing inside it.
wallet = None    # I do not own a wallet.

While 0, [], and None are all falsy (they will all fail an if wallet: check), they represent vastly different realities in your program's logic.

Checking with is None

When you want to know if a variable is explicitly None, you should never use ==. You must use is.

user_input = None

if user_input == None:   # ❌ Works, but considered bad practice
    pass

if user_input is None:   # ✅ The correct, Pythonic way
    pass

Why is and not ==? The == operator checks if two things have the same value. The is operator checks if two things are the exact same object in memory.

In Python, there is only ever one instance of None in your entire program's memory. It is a "singleton." When you say x is None, you are checking causality at the lowest level: "Does the variable x point to the exact same memory address as the universal concept of None?" It is faster, safer, and immune to custom objects that might try to trick the == operator.

Function return values

Finally, None is the default response of the Python universe. If you write a function that does some work but you forget to include a return statement at the end, Python silently returns None for you.

def say_hello(name):
    print(f"Hello, {name}!")
    # No return statement here

result = say_hello("Aisha")
print(result)  # ✅ Outputs: None

The function did its job (it printed to the screen), but it handed nothing back to the variable result. None is Python's way of politely confirming, "I finished the task, but I have nothing to give you."