Course: Python Programming
Topic: Understanding Truthy and Falsy Values
Course Link: Python Training Course – JustAcademy
Demo Link: Register for a Course Demo
Website: JustAcademy Official Website
In Python, truthy and falsy values are values that Python interprets as true or false when evaluating a condition. They are important in decision-making, loops, logical operations, input validation, and controlling program execution.
Python does not require every condition to contain an explicit comparison such as number > 0 or name == "Alex". Instead, many values can be used directly in an if statement. Python determines whether the value is considered true or false according to its truth value.
For example, a non-empty string is truthy, while an empty string is falsy. A non-zero number is generally truthy, while zero is falsy. An empty list is falsy, while a list containing at least one item is truthy.
and and or behave.value = 10
if value:
print("The value is truthy")
else:
print("The value is falsy")Output:
The value is truthyThe integer 10 is non-zero, so Python treats it as truthy and executes the first block.
Truthy values are values that Python treats as true when evaluating a condition. A truthy value does not necessarily have to be the Boolean value True.
Common examples include:
1, -5, and 100.3.14 and -0.5."Python" and "Hello".[1, 2, 3].(10, 20).{"name": "Sam"}.{1, 2, 3}.True.if 25:
print("A non-zero integer is truthy")
if "Python":
print("A non-empty string is truthy")
if [1, 2, 3]:
print("A non-empty list is truthy")
if True:
print("True is truthy")Output:
A non-zero integer is truthy
A non-empty string is truthy
A non-empty list is truthy
True is truthyAll four conditions are considered true by Python.
Falsy values are values that Python treats as false in a conditional expression. When a falsy value is used in an if condition, the if block is skipped unless another part of the condition changes the result.
The most common built-in falsy values are:
False – the Boolean false value.None – represents the absence of a value.0 – integer zero.0.0 – floating-point zero.0j – complex zero."" – an empty string.[] – an empty list.() – an empty tuple.{} – an empty dictionary.set() – an empty set.range(0) – an empty range.if 0:
print("This will not run")
if "":
print("This will not run")
if []:
print("This will not run")
if None:
print("This will not run")
print("Program continues")Output:
Program continuesEvery condition in this example contains a falsy value. Therefore, none of the four conditional blocks executes.
The following table compares commonly used values and their truth values in Python.
| Data Type | Truthy Example | Falsy Example | Explanation |
|---|---|---|---|
| Boolean | True |
False |
Boolean values directly represent true or false. |
| Integer | 5 |
0 |
Non-zero integers are truthy. |
| Float | 2.5 |
0.0 |
Zero-valued floats are falsy. |
| Complex | 2 + 3j |
0j |
A complex number is falsy when both parts are zero. |
| String | "Hello" |
"" |
An empty string is falsy. |
| List | [1, 2] |
[] |
An empty list is falsy. |
| Tuple | (1, 2) |
() |
An empty tuple is falsy. |
| Dictionary | {"a": 1} |
{} |
An empty dictionary is falsy. |
| Set | {1, 2} |
set() |
An empty set is falsy. |
| NoneType | Not applicable | None |
None represents the absence of a value. |
Python provides the built-in bool() function to convert a value into its Boolean truth value. It returns either True or False based on the value's truthiness.
bool(value)print(bool(100))
print(bool(0))
print(bool("Python"))
print(bool(""))
print(bool([1, 2]))
print(bool([]))
print(bool(None))Output:
True
False
True
False
True
False
Falsebool(100) returns True because 100 is non-zero.bool(0) returns False because zero is falsy.bool("Python") returns True because the string is not empty.bool("") returns False because the string has no characters.bool([1, 2]) returns True because the list contains elements.bool([]) returns False because the list is empty.bool(None) returns False because None is falsy.Important: bool() does not mean that a value is identical to True or False. It evaluates the value's truthiness and returns a Boolean result.
Truthy and falsy values can be used directly in if statements. This can make code simpler when the intention is to check whether a value is present or whether a collection contains elements.
username = "Aarav"
if username:
print("Username is provided")
else:
print("Username is missing")Output:
Username is providedSince the string is not empty, the first block executes.
username = ""
if username:
print("Username is provided")
else:
print("Username is missing")Output:
Username is missingAn empty string is falsy, so the else block executes.
cart = ["Laptop", "Mouse"]
if cart:
print("Your cart contains items")
else:
print("Your cart is empty")Output:
Your cart contains itemsThis approach is useful when checking whether a list, tuple, set, or dictionary contains any elements.
Truthy and falsy values can also be used in an if-elif-else chain. Python evaluates each condition in order and executes the first matching branch.
value = []
if value:
print("The value contains data")
elif value is None:
print("The value is not defined")
else:
print("The value exists but is empty")Output:
The value exists but is emptyThe list is empty, so it is falsy. However, it is not None, so the final else branch executes.
A variable containing None is different from a variable containing an empty string, empty list, or zero. All these values are falsy, but they represent different situations.
value = None
if value is None:
print("No value has been assigned")
elif not value:
print("A value exists but is empty or zero")
else:
print("A truthy value is present")Output:
No value has been assignedUse is None when you specifically need to determine whether a value is None, rather than merely checking whether it is falsy.
Python's logical operators and, or, and not work with truthy and falsy values. The not operator always returns a Boolean value, while and and or return one of their operands.
The not operator reverses the truth value of an expression.
print(not True)
print(not False)
print(not 0)
print(not "Python")
print(not [])Output:
False
True
True
False
TrueFor example, not 0 returns True because zero is falsy. Likewise, not "Python" returns False because a non-empty string is truthy.
The and operator evaluates operands from left to right. It returns the first falsy operand it encounters. If all operands are truthy, it returns the last operand.
print(True and True)
print(True and False)
print(10 and 20)
print(0 and 20)
print("Python" and "Programming")Output:
True
False
20
0
ProgrammingNotice that 10 and 20 returns 20, not the Boolean value True. Both operands are truthy, so the last operand is returned.
The or operator evaluates operands from left to right and returns the first truthy operand. If every operand is falsy, it returns the last operand.
print(False or True)
print(0 or 50)
print("" or "Default")
print([] or [1, 2, 3])
print(0 or "" or None)Output:
True
50
Default
[1, 2, 3]
NoneThe final expression returns None because every operand is falsy, and or returns the last operand when no truthy operand is found.
Short-circuit evaluation means Python may stop evaluating a logical expression as soon as its result is determined. This behavior is particularly important when using and and or.
def check_value():
print("Function executed")
return True
result = False and check_value()
print(result)Output:
FalseThe function is not called because the left operand of and is falsy. The result must therefore be falsy, so Python skips the right operand.
def check_value():
print("Function executed")
return True
result = True or check_value()
print(result)Output:
TrueThe function is not called because the left operand of or is already truthy. Python does not need to evaluate the right operand.
items = []
if items and items[0] == "Python":
print("Python is the first item")
else:
print("The list is empty or starts with another value")Output:
The list is empty or starts with another valueBecause items is empty and therefore falsy, Python does not evaluate items[0]. This avoids an IndexError.
Truthy and falsy values are useful in loops, especially when a loop should continue while a condition remains true or when processing input until the user provides a stopping value.
running = True
while running:
print("Program is running")
running = FalseOutput:
Program is runningThe loop starts because running is truthy. After its value becomes False, the loop stops.
tasks = ["Study Python", "Practice coding"]
while tasks:
task = tasks.pop(0)
print("Completed:", task)
print("All tasks completed")Output:
Completed: Study Python
Completed: Practice coding
All tasks completedThe loop continues while the list contains items. Once the list becomes empty, it is falsy and the loop terminates.
Python allows collections to be checked directly without comparing their lengths to zero. An empty collection is falsy, while a non-empty collection is truthy.
students = ["Riya", "Aman", "Neha"]
marks = {}
subjects = []
if students:
print("Student records are available")
if not marks:
print("No marks have been recorded")
if not subjects:
print("No subjects are available")Output:
Student records are available
No marks have been recorded
No subjects are availableBoth approaches below can check whether a collection contains items.
items = [10, 20, 30]
if items:
print("Items exist")
if len(items) > 0:
print("The collection is not empty")For a simple emptiness check, if items: is generally more concise and idiomatic in Python.
When collecting information from users, truthiness can help detect empty input. However, it is important to remember that input() always returns a string.
username = input("Enter your username: ")
if username:
print("Username received:", username)
else:
print("Username cannot be empty")If the user presses Enter without typing anything, the result is an empty string, which is falsy.
A string containing only spaces is still truthy because it contains characters. Use strip() to remove leading and trailing whitespace before checking the input.
username = input("Enter your username: ").strip()
if username:
print("Username accepted")
else:
print("Please enter a username")Now, input containing only spaces becomes an empty string and is rejected.
Do not use the truthiness of a number as a substitute for validating its range. Zero is falsy but may be a valid input, depending on the application.
try:
age = int(input("Enter your age: "))
if age < 0:
print("Age cannot be negative")
elif age == 0:
print("Age is zero")
else:
print("Age entered:", age)
except ValueError:
print("Please enter a valid whole number")This example explicitly handles zero and negative numbers rather than treating every falsy number as invalid.
The or operator is sometimes used to provide a default value when the original value is falsy.
username = ""
display_name = username or "Guest"
print(display_name)Output:
GuestBecause username is an empty string, the expression selects "Guest".
This technique treats all falsy values as missing, including zero, False, empty collections, and None. If zero or another falsy value is valid and should be preserved, check specifically for None instead.
quantity = 0
# This replaces zero with 10 because zero is falsy.
default_quantity = quantity or 10
print(default_quantity)
# This preserves zero and uses 10 only when quantity is None.
quantity = 0
safe_quantity = 10 if quantity is None else quantity
print(safe_quantity)Output:
10
0Python classes can define how their objects behave in Boolean contexts. By default, an ordinary object is generally truthy. A class can customize this behavior using the special method __bool__() or, if __bool__() is not defined, __len__().
class Account:
def __init__(self, active):
self.active = active
def __bool__(self):
return self.active
account = Account(True)
if account:
print("Account is active")
else:
print("Account is inactive")Output:
Account is activeThe __bool__() method returns the account's active status. Because the method returns True, the object is truthy in the conditional statement.
class Team:
def __init__(self, members):
self.members = members
def __len__(self):
return len(self.members)
team = Team([])
if team:
print("Team has members")
else:
print("Team is empty")Output:
Team is emptyWhen a class defines __len__() but does not define __bool__(), Python uses the length to determine truthiness. A length of zero makes the object falsy.
__bool__() takes precedence over __len__().__bool__() must return a Boolean value.__len__() is defined, zero means falsy and a non-zero length means truthy.This is incorrect because values such as 0, False, and empty collections are falsy even though they are not None.
value = 0
if value is None:
print("Value is None")
elif not value:
print("Value is falsy but not None")
else:
print("Value is truthy")Output:
Value is falsy but not NoneThe string "False" is truthy because it is not empty. Python does not automatically interpret ordinary text as a Boolean value.
value = "False"
if value:
print("This string is truthy")Output:
This string is truthyThe string "0" is truthy because it contains a character. It is different from the integer 0.
print(bool("0"))
print(bool(0))Output:
True
FalseUse == to compare values for equality and is to check object identity. To check specifically for the absence of a value, use value is None.
value = None
if value is None:
print("No value is available")Zero may be a valid measurement, quantity, score, or price. Avoid using a general truthiness check when the requirement is to check whether a value has been provided.
score = 0
if score is not None:
print("Score has been provided:", score)
else:
print("Score is missing")Output:
Score has been provided: 0if items: to check whether a collection contains elements.if not items: to check whether a collection is empty.value is None when checking for None specifically."False", "0", or "None" behaves like the corresponding Python values.strip() when validating strings that must contain non-whitespace characters.and and or can return operands rather than Boolean values.In this mini project, you will use truthy and falsy values to check whether a shopping cart contains products and whether a discount code has been entered.
cart = ["Laptop", "Keyboard"]
discount_code = ""
if cart:
print("Items are available in your cart")
else:
print("Your cart is empty")
if discount_code.strip():
print("Discount code entered")
else:
print("No discount code provided")
if cart and discount_code.strip():
print("Cart and discount code are ready")
elif cart:
print("Proceed to checkout without a discount")
else:
print("Add products before checkout")Output:
Items are available in your cart
No discount code provided
Proceed to checkout without a discountcart is truthy because it contains two products.discount_code is falsy.strip() method ensures that whitespace-only discount input is treated as empty.elif branch executes because the cart contains products, even though no discount code is available.bool() to test an integer, float, string, list, tuple, dictionary, set, and None.None, zero, an empty string, and a non-empty string.and and or to provide a default display name.__bool__().Truthy values are interpreted as true in a Boolean context, while falsy values are interpreted as false. Examples of falsy values include False, None, zero, and empty collections.
The bool() function converts a value into its Boolean truth value, returning either True or False.
An empty string, "", is falsy. A non-empty string is truthy, even if it contains the text "False" or "0".
Yes. Integer zero, floating-point zero, and complex zero are falsy. Non-zero numbers are truthy.
Yes. An empty list evaluates to false in a Boolean context, while a non-empty list evaluates to true.
None represents the absence of a value, whereas [] represents an existing list containing no elements. Both are falsy, but they have different meanings and types.
The not operator reverses the truth value of an expression and returns a Boolean result.
Short-circuit evaluation allows Python to stop evaluating a logical expression when the result is already determined. For example, False and expression does not evaluate the right-hand expression.
The or operator returns the first truthy operand. If all operands are falsy, it returns the last operand.
The and operator returns the first falsy operand. If all operands are truthy, it returns the last operand.
Use value is None. This explicitly checks whether the value is the singleton object None.
Yes. A class can define __bool__() to determine its Boolean value or define __len__() so that an object with length zero is falsy.
False, None, zero, empty strings, and empty collections are falsy.bool(value) to inspect a value's truth value.if collection: to check whether a collection contains elements.value is None to check for None specifically."False" and "0" are truthy strings.and and or operators return operands and use short-circuit evaluation.__bool__() or __len__().Understanding truthy and falsy values is essential for writing effective Python programs. This concept explains how Python evaluates conditions, handles empty collections, validates input, and processes logical expressions. It also helps developers write concise and readable code without unnecessary comparisons.
Remember that truthiness does not always indicate whether a value is valid or meaningful. Zero can be a valid quantity, an empty string may indicate missing input, and None may represent the absence of a value. Choose the condition that matches the actual requirement, and test important edge cases to make your programs reliable.
Continue learning Python: Explore the Python Training Course, register for a course demo, or visit the JustAcademy website.
