The World of Python Programming

Python Logical Operators: and, or, not — Complete Guide

Basic Syntax & Control Flow
目次

1. Introduction

Python is widely loved as a simple, highly readable programming language. Its flexibility and intuitive syntax make it popular among everyone from beginners to professionals. Among its features, logical operators are indispensable when writing conditionals, loops, and complex conditional expressions. This article thoroughly explains Python’s logical operators — and, or, and not — covering everything from basic usage to advanced techniques. It also covers operator precedence, how non-boolean values are evaluated, and the mechanics of short-circuit evaluation. Finally, we’ve included practical examples and a FAQ. By reading this article, even Python beginners will be able to master logical operators and perform conditionals and data manipulation more efficiently. We hope you find it useful.

2. Types of logical operators in Python and basic examples

Python has three primary logical operators. Below we’ll explain each one’s behavior and usage in detail with concrete examples.

and (logical AND)

and is evaluated as True only when all conditions are True. If even one condition is False, the whole expression is False. Basic usage
x = 10
y = 20

if x > 5 and y < 30:
    print("Both conditions are met")
# Output: Both conditions are met
In this example, both x > 5 and y < 30 are met, so the code inside the if statement is executed.

or (logical OR)

or is evaluated as True if any one of the conditions is True. Use it when you want to check whether at least one of several conditions is satisfied. Basic usage
age = 65

if age < 18 or age > 60:
    print("You are eligible for a discount")
else:
    print("Regular price applies")
# Output: You are eligible for a discount
In this example, since age is over 60 years old, the condition evaluates to True.

not (logical NOT)

not reverses the result of a condition’s evaluation. It converts True to False and False to True. Basic usage
is_logged_in = False

if not is_logged_in:
    print("You need to log in")
# Output: You need to log in
In this example, because is_logged_in is False, not makes the condition evaluate to True.

Practical examples

You can also combine multiple operators when setting conditions.
x = 15
y = 10
z = 5

if (x > y and z < y) or not (x == 15):
    print("The conditions are met")
else:
    print("The conditions are not met")
# Output: The conditions are met
When setting up complex conditional expressions like this, it’s important to use parentheses to make the order of evaluation explicit.
侍エンジニア塾

3. Thorough Guide to Python Logical Operator Precedence: How to Write Accurate Conditional Expressions

In Python, when multiple logical operators are combined, they are evaluated according to their respective precedence. Understanding this precedence helps prevent unintended behavior and enables you to write accurate conditional expressions.

Basic rules of precedence

The precedence of logical operators in Python is as follows.
  1. not (highest)
  2. and
  3. or (lowest)
Example:
a = True
b = False
c = True

result = a or b and c
print(result)  # Output: True
In this example, b and c is evaluated first, and its result is combined with a or. The evaluation of b and c is False, and a or False becomes True.

Specifying precedence explicitly using parentheses

Using parentheses is an effective way to make precedence explicit, and it also improves code readability. Example:
a = True
b = False
c = True

result = (a or b) and c
print(result)  # Output: True
In this case, a or b is evaluated first, and then and c is applied. Using parentheses clarifies the program’s intent.

What happens if you ignore precedence

Ignoring precedence can lead to unexpected results. Example:
x = 10
y = 5
z = 20

# If you ignore precedence
if x > y or z < y and z > x:
    print("The condition is met")
else:
    print("The condition is not met")
# Output: The condition is met
In this code, z < y and z > x takes precedence, so the result may not be evaluated correctly. Using parentheses allows you to set clear conditions.

4. Examples showing how Python logical operators evaluate non-boolean values

In Python, logical operators apply not only to boolean values but also to other data types. Understanding this behavior lets you write more flexible code.

Evaluation rules for non-boolean values

The following values are considered ‘false’ in Python.
  • 0 (numeric types)
  • "" (empty string)
  • [] (empty list)
  • None
  • False
All other values are treated as ‘true’. Example:
value = 0 or "default value"
print(value)  # Output: default value
In this example, 0 evaluates to ‘false’, so the value "default value" is returned.

Practical examples

Set a fallback value when a condition isn’t met
user_input = ""
default_value = user_input or "No input"

print(default_value)  # Output: No input
Since user_input is an empty string (considered ‘false’), "No input" is chosen instead.

5. How Short-Circuit Evaluation Works with Python Logical Operators

Python’s logical operators use a feature called “short-circuit evaluation”. With this mechanism, if a result is determined while evaluating a conditional expression, the remaining parts are skipped and not evaluated. This avoids needless computation and allows more efficient processing.

Short-Circuit Evaluation: and Operator

and stops evaluating further conditions as soon as it finds one that evaluates to False. This is based on the property that and is True only when all conditions are True. Example:
def check_condition():
    print("This function was executed")
    return True

result = False and check_condition()
print(result)  # Output: False (the function is not executed)
In this example, because the first condition is False, the check_condition() function is not executed and the entire expression evaluates to False.

Short-Circuit Evaluation: or Operator

or stops evaluating further conditions as soon as it finds one that evaluates to True. This is based on the property that or is True if any condition is True. Example:
def check_condition():
    print("This function was executed")
    return True

result = True or check_condition()
print(result)  # Output: True (the function is not executed)
In this example, because the first condition is True, the check_condition() function is not executed and the entire expression evaluates to True.

Practical Examples of Short-Circuit Evaluation

Short-circuit evaluation is especially useful for avoiding errors and skipping unnecessary processing. Error-avoidance example
a = None

if a is not None and a.value > 10:
    print("Condition met")
else:
    print("Condition not met")
In this example, if a is not None is False, a.value is not accessed and an error (AttributeError) can be avoided. This is a good example of how short-circuit evaluation improves program safety.

Performance improvements from short-circuit evaluation

Performance-improvement example
def expensive_computation():
    print("Running an expensive operation")
    return True

result = False and expensive_computation()
# Since the expensive operation is not executed, computational cost is reduced
Here, because the first condition is False, expensive_computation() is not executed and the result is determined. This avoids unnecessary computation and allows the program to run more efficiently.

6. Practical Examples of Using Python Logical Operators for Conditionals and List Operations

Python’s logical operators can be used in many situations, such as conditionals, loops, and list comprehensions. Here are some concrete examples.

Using in Conditional Branching

In conditional statements (if statements), you can combine multiple conditions for flexible control. Example:
temperature = 25
weather = "sunny"

if temperature > 20 and weather == "sunny":
    print("It's a great day to go out")
else:
    print("Please check the weather")
In this example, it prints “It’s a great day to go out” when the temperature is 20 degrees or higher and the weather is sunny. By combining multiple conditions, you can specify detailed criteria.

Using in List Comprehensions

By incorporating logical operators into list comprehensions, you can perform concise and efficient list operations. Example:
numbers = [1, 2, 3, 4, 5, 6]
filtered = [num for num in numbers if num % 2 == 0 or num > 4]
print(filtered)
# Output: [2, 4, 5, 6]
In this example, the list is filtered for numbers that are even or greater than 5. Even when conditions are complex, logical operators let you express them concisely.

Using in while Loops

In while loops, you can use logical operators to control multiple conditions. Example:
x = 0
y = 10

while x < 5 and y > 5:
    print(f"x: {x}, y: {y}")
    x += 1
    y -= 1
In this example, the loop runs while x is less than 5 and y is greater than 5. Even with multiple conditions, logical operators allow concise expression.

7. FAQ Section

Answers common questions readers have when using Python’s logical operators.

What are common mistakes with Python’s logical operators?

  1. Misunderstanding operator precedence
  • Misunderstanding the precedence of conditional expressions can lead to unintended results. Solution: Use parentheses to make precedence explicit.
  1. Handling non-boolean values
  • None and empty lists being evaluated as “false” — if you don’t understand this rule, it can lead to unexpected behavior.

Tips for handling complex conditions with Python’s logical operators?

  1. Split conditions into functions
  • If conditions are complex, factor parts into functions to improve readability. Example:
   def is_adult(age):
       return age >= 18

   def is_member(member_status):
       return member_status == "active"

   if is_adult(25) and is_member("active"):
       print("The member meets the conditions")
  1. Break conditions down
  • Instead of writing multiple conditions all at once, separate them to make them easier to understand.

8. Summary

Python’s logical operators are an essential tool used in a variety of applications, such as conditional branching, list manipulation, and preventing errors. In this article, we covered logical operators in detail from the basics to practical usage and provided concrete examples showing how to use them. By properly understanding logical operators and leveraging short-circuit evaluation and precedence rules, you can write more efficient and safer programs. Refer to this article and actively apply these techniques in your everyday programming.