Logical operators in Python allow you to combine conditional statements and control the logic flow in your code. The six logical operators in Python are and
, or
, not
, in
, is
, and not in
.
Knowing the precedence of these logical operators is crucial for writing clear and robust Python programs that behave as expected. Adding parentheses around expressions can help reinforce and clarify the intended order of operations.
In this comprehensive guide, we will cover:
Table of Contents
Open Table of Contents
Overview of Logical Operators in Python
Logical operators allow you to combine conditional statements and control flow in Python. The six logical operators are:
and
 True if both operands are trueor
 True if either operand is truenot
 Flips the boolean value of the operandin
 True if first operand is contained in the secondis
 True if operands are identical objectsnot in
 Inverse ofin
operator
These operators are used extensively in conditional statements like if...else
blocks, while
loops, and ternary expressions to direct code flow based on boolean logic.
Here’s a simple example using and
, or
, and not
:
x = 5
y = 10
if x > 0 and y > 0:
print("Both x and y are positive")
if x > 0 or y < 0:
print("Either x is positive or y is negative")
if not(x == y):
print("x and y are not equal")
Understanding how these logical operators work and their order of precedence is important for writing Python code that functions as you intend.
Precedence and Truth Tables for Logical Operators
The logical operators in Python follow a standard order of operations based on precedence. The precedence hierarchy for logical operators from highest to lowest is:
not
and
or
The not
operator has the highest precedence, followed by and
, and then or
.
This precedence hierarchy can be visualized using truth tables, which show all possible operand combinations and the resulting boolean output:
NOT Operator Truth Table
x  not x 

True  False 
False  True 
The not
operator simply inverts the boolean value of its operand.
AND Operator Truth Table
x  y  x and y 

True  True  True 
True  False  False 
False  True  False 
False  False  False 
The and
operator results in True
only if both operands are True
, otherwise it’s False
.
OR Operator Truth Table
x  y  x or y 

True  True  True 
True  False  True 
False  True  True 
False  False  False 
The or
operator results in True
if either operand is True
, and only False
if both operands are False
.
Based on these truth tables, you can see the hierarchy where not
bindings tighter than and
, which binds tighter than or
.
Using Parentheses to Control Order of Operations
Because of the precedence hierarchy, you may need to use parentheses to explicitly control the order of operations and make your code’s logic clear.
Adding parentheses overrides the default precedence, forcing the expressions within the parentheses to be evaluated first before the rest of the expression.
For example:
x = True
y = False
print(x or not y and x) # Prints True
print((x or not y) and x) # Prints False
Without parentheses, not y
is evaluated first due to not
having the highest precedence, followed by and
, and then or
.
By adding parentheses around x or not y
, it forces that expression to be evaluated first before applying the and
operator. This changes the result.
Parentheses help reinforce the intended order of operations and improve readability of logical expressions.
Common Pitfalls and Errors with Logical Operator Precedence
Understanding operator precedence is important because the default order of operations can lead to errors and unintended behavior if not properly accounted for.
Here are some common pitfalls:
Accidentally inverting logic flow
For example:
if x > 0 or not y > 0:
# Code that assumes x or y needs to be positive
if x > 0 or (not y > 0): # Parentheses fix order of operations
# Code that assumes x or y needs to be positive
Without parentheses, the not
applies to y
, when the intended logic was for not
to apply to the whole y > 0
expression.
Overly complex boolean logic
Boolean logic can get complex quickly. Long chains of logical operators without parentheses to control order of operations can lead to hardtoread code and unintended behavior.
Assuming default order of operations
It’s easy to assume that the operators will be evaluated in the order you wrote them. But leaving out parentheses means relying on the default precedence, which may not match your intent.
Mixing bitwise and logical operators
In Python, bitwise operators like &
and 
have lower precedence than logical operators like and
and or
. Mixing them without parentheses can change logic flow.
Best Practices for Using Logical Operators Clearly
To write Python code with clean logical operator usage:

Use parentheses liberally  Make liberal use of parentheses any time default precedence may cause unintended results, or to clarify complex boolean logic chains.

Keep logic simple  Avoid long chains of logical operators without parentheses. Break complex conditions into intermediate variables or functions to encapsulate and name the logic.

Name variables meaningfully  Use variable names that capture the meaning and purpose of operands in logical expressions.

Comment complex expressions  Use comments to document the intended order of operations in complex logical expressions.

Test edge cases  Thoroughly test edge case behavior of logical operators to prevent bugs.

Break into steps  Decompose complex boolean logic into intermediate variables and boolean functions with descriptive names.

Refer to truth tables  Consult truth tables when in doubt about how an operator works or to verify intended behavior.
RealWorld Examples and Use Cases
Logical operators are used extensively in realworld Python programs for control flow. Here are some examples of how they are applied:
Validation logic
Using and
and or
to validate user input:
is_valid =
input_string != ""
and len(input_string) < 100
and input_string.isalpha()
Safety checks
Adding safety checks with or
before executing code:
if not safe_mode or is_debug:
execute_code()
else:
print("Code execution disabled")
Data filters
Filtering data using membership operators in
and not in
:
filtered_results = [x for x in results if "keyword" in x and "blacklist" not in x]
Ternary conditionals
Using logical operators in ternary expressions:
access_level = "admin" if is_admin else "readonly"
Debugging output
Printing debug logs based on boolean conditions:
if show_debug and debug_mode:
print("Running in DEBUG mode")
Conclusion
Understanding precedence of logical operators in Python allows you to precisely control code flow and behavior. Explicitly grouping expressions with parentheses helps reinforce the intended order of evaluation. Using logical operators clearly is crucial for writing robust Python programs that function as expected. Following best practices like liberally adding parentheses, keeping logic simple, and testing edge cases will help you avoid common pitfalls.