How to Check Multiple Conditions in if Statements (and, or, any, all) in Python

In Python programming, if statements often need to evaluate more than one condition to make a decision. You might need to check if all conditions are true, or if at least one condition is true. Python provides logical operators (and, or) and built-in functions (all(), any()) to handle these scenarios effectively.

This guide explains how to use these tools to check multiple conditions within your if statements.

The Need for Multiple Conditions

Simple if statements check a single condition. However, real-world logic often requires combining several criteria. For example:

• Is a user logged in and do they have admin privileges?
• Is the input value greater than 0 and less than 100?
• Did the operation succeed or is a retry allowed?

Python's boolean logic tools allow you to express these complex checks clearly.

Checking if ALL Conditions are True

Use these methods when the if block should only execute if every single specified condition evaluates to True.

Using the and Operator

The and operator connects two or more boolean expressions. The result is True only if all connected expressions are True.

age = 25
has_permission = True
is_active = True

if age >= 18 and has_permission and is_active:
    print("Access Granted: All conditions met.")
else:
    print("Access Denied: Not all conditions met.")

is_active = False
if age >= 18 and has_permission and is_active:
     print("Access Granted (Scenario 2).")
else:
    print("Access Denied (Scenario 2): Not all conditions met.")

Using the all() Function

The built-in all() function takes an iterable (like a list or tuple) containing boolean values or expressions. It returns True if all elements in the iterable are truthy, and False otherwise. It also returns True for an empty iterable.

value = 75
lower_bound = 0
upper_bound = 100

conditions = [
    value > lower_bound,     # True
    value < upper_bound,     # True
    isinstance(value, int)   # True
]

if all(conditions):
    print(f"Value {value} is valid (using all()).")
else:
    print(f"Value {value} is invalid (using all()).")

conditions_fail = [
    value > lower_bound,     # True
    value < 50,              # False
    isinstance(value, int)   # True (but all() stops after False)
]
if all(conditions_fail):
    print(f"Value {value} is valid (Scenario 2).")
else:
    print(f"Value {value} is invalid (Scenario 2 - using all()).")

• Readability: all() can be more readable than long chains of and operators, especially if the conditions are generated dynamically.
• Short-circuiting: all() also short-circuits; it stops iterating through the iterable as soon as it finds a False (or falsy) value.

Checking if ANY Condition is True

Use these methods when the if block should execute if at least one of the specified conditions evaluates to True.

Using the or Operator

The or operator connects two or more boolean expressions. The result is True if at least one of the connected expressions is True. It's only False if all expressions are False.

role = "guest"
is_owner = False
has_special_pass = True

if role == "admin" or is_owner or has_special_pass:
    print("Special Access Granted: At least one condition met.")
else:
    print("Standard Access: None of the special conditions met.")

has_special_pass = False
if role == "admin" or is_owner or has_special_pass:
     print("Special Access Granted (Scenario 2).")
else:
    print("Standard Access (Scenario 2): None of the special conditions met.")

• Short-circuiting: Python evaluates or conditions from left to right. If it encounters a True condition, it immediately stops evaluating the rest and the overall result is True.

Using the any() Function

The built-in any() function takes an iterable (like a list or tuple). It returns True if at least one element in the iterable is truthy. It returns False if the iterable is empty or if all elements are falsy.

status_code = 404
error_flags = ["timeout", "server_error", "not_found"]
current_error = "not_found"

conditions = [
    status_code >= 500,             # False
    current_error == "timeout",     # False
    current_error in error_flags    # True
]

if any(conditions):
    print("An error condition was detected (using any()).")
else:
    print("No error conditions detected (using any()).")


conditions_none_met = [
    status_code >= 500,                     # False
    current_error == "connection_refused"   # False
]
if any(conditions_none_met):
    print("An error condition was detected (Scenario 2).")
else:
    print("No error conditions detected (Scenario 2 - using any()).")

• Readability: Similar to all(), any() can improve readability over long chains of or operators.
• Short-circuiting: any() short-circuits, stopping iteration as soon as it finds a True (or truthy) value.

Combining and and or (Using Parentheses)

You can mix and and or in a single if statement, but you need to be careful about operator precedence. The and operator has higher precedence than or, meaning and operations are typically evaluated before or operations.

To avoid ambiguity and ensure the logic executes as intended, always use parentheses () to explicitly group your conditions.

score = 85
attendance = 95
has_extra_credit = False


if (score >= 80 and attendance >= 90) or has_extra_credit:
    print("Condition Met: Either high score/attendance OR extra credit.")
else:
    print("Condition Not Met.")

if score >= 80 and (attendance >= 90 or has_extra_credit):
    print("Condition Met: High score AND (good attendance OR extra credit).")
else:
    print("Condition Not Met.")

Parentheses make the evaluation order explicit and your code much easier to read and debug.

Choosing the Right Approach

• and / or Operators: Best for a small number of fixed conditions where the logic is clear and easily expressed by chaining.
• all() / any() Functions: Often better when:
  • You have many conditions.
  • The conditions are generated dynamically (e.g., checking properties of all items in a list).
  • You find all([...]) or any([...]) more readable than long and/or chains.

Conclusion

Python provides flexible ways to evaluate multiple conditions in if statements:

• Use the and operator or the all() function when all conditions must be true.
• Use the or operator or the any() function when at least one condition must be true.
• Always use parentheses () to group conditions clearly when mixing and and or operators to control the order of evaluation and enhance readability.

Understanding these tools allows you to write precise and expressive conditional logic in your Python programs.