Python Short Circuit Evaluation Explained
Learn how Python's short-circuit evaluation works with `and` and `or`, including operand return values, common use cases, and pitfalls.

When you write a and b or a or b in Python, the interpreter does not always evaluate both operands. This behavior, known as Python's short-circuit evaluation, affects not only performance but also the result of the expression. In Python, and and or return one of the operands, not necessarily a boolean. Understanding this is essential for writing idiomatic and safe code.
How and and or Return Operands
Python's logical operators evaluate operands from left to right and stop as soon as the result is determined. For and, if the left operand is falsy, the expression returns the left operand without evaluating the right. If the left operand is truthy, it evaluates the right operand and returns it. For or, the opposite happens: if the left operand is truthy, it returns the left operand; otherwise it evaluates and returns the right operand.
print(0 and "value") # 0
print(1 and "value") # "value"
print(0 or "default") # "default"
print(1 or "default") # 1This is not a quirk; it is documented behavior. The operators return the actual operand value, which is why 1 and "value" returns "value" and not True. This behavior is the foundation for several common Python patterns.
Using Short-Circuiting for Default Values
The most common use of short-circuit evaluation is providing a default value. Instead of writing an explicit if statement, you can use or to fall back to a default when the first value is falsy.
username = input("Enter username: ") or "guest"
print(f"Logged in as {username}")Here, if input() returns an empty string (falsy), the expression evaluates to "guest". This works because or returns the first truthy operand. However, this pattern is only safe when the falsy value is not a legitimate input. For example, if 0 is a valid value, using or would incorrectly replace it with the default. In such cases, an explicit if or a conditional expression is better.
Guarding Expensive or Risky Operations
Short-circuit evaluation is also used to avoid executing code that would be wasteful or cause an error. For instance, you can check that a resource exists before attempting to access it:
if resource and resource.is_available():
resource.use()If resource is None, the and expression short-circuits and resource.is_available() is never called, preventing an AttributeError. Similarly, you can avoid division by zero:
def safe_divide(a, b):
return b != 0 and a / bIf b is zero, the function returns False instead of raising an exception. This is concise but can be less readable than an explicit check. Use it when the condition is simple and the intent is clear.
Common Pitfalls and Misconceptions
One common mistake is assuming that and and or always return a boolean. They do not. This can lead to subtle bugs when you use the result in a context that expects True or False. For example:
result = 1 and 2
if result == True:
print("This won't print")Here result is 2, not True. To get a boolean, wrap the expression with bool() or use a comparison.
Another pitfall is mixing and and or without considering operator precedence. and has higher precedence than or, so a or b and c is evaluated as a or (b and c). This can cause unexpected results if you don't parenthesize explicitly.
Performance and Runtime Considerations
Short-circuit evaluation can improve performance by avoiding unnecessary work. If the left operand is cheap to evaluate and often determines the result, you save the cost of the right operand. This is especially important when the right operand involves a function call, a database query, or a network request.
# Expensive function that might not need to run
if is_valid(user) and fetch_user_data(user):
process(user)Here, fetch_user_data is only called when is_valid returns a truthy value. This can significantly reduce latency in hot paths. However, do not over-optimize. In most cases, the performance gain is negligible compared to the cost of the operation itself. Use short-circuiting for correctness first, and treat performance as a secondary benefit.
When to Choose Explicit Conditionals
Short-circuit evaluation is elegant, but it is not always the most readable choice. For complex conditions, an explicit if statement with separate lines is often clearer. For example:
# Short-circuit version
if user and user.is_active and user.has_permission("admin"):
grant_access(user)
# Explicit version
if user is not None:
if user.is_active:
if user.has_permission("admin"):
grant_access(user)The explicit version is more verbose but makes each condition obvious. It also allows you to add an else clause for each step if needed. Use short-circuiting for simple, well-known patterns like default values or guard clauses. Reserve explicit conditionals for logic that is complex or needs to be debugged frequently.
Handling Edge Cases with Falsy Values
Python treats several values as falsy: False, 0, 0.0, "", [], {}, set(), None, and objects whose __bool__ returns False or whose __len__ returns 0. When using or for defaults, be aware that any of these values will trigger the fallback. For example:
config = {"retries": 0}
retries = config.get("retries") or 3 # retries becomes 3, not 0This is a classic bug. The intended value 0 is falsy, so it is replaced by the default. To preserve 0, use an explicit check:
retries = config["retries"] if "retries" in config else 3Or use the dict.get method with a default argument, which returns the stored value even when it is falsy:
retries = config.get("retries", 3)Understanding which values are falsy is crucial when relying on short-circuit evaluation. Always consider whether a legitimate value could be falsy before using or for defaults.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.