Python logical operators allow us to perform logical AND, OR, and NOT operation between boolean values. In this article, we will look into the logical operator’s execution in more detail.
Python Logical Operators
There are three logical operators in Python.
Logical Operator | Description | Simple Example |
---|---|---|
and | Logical AND Operator | flag = True and True = True |
or | Logical OR Operator | flag = False or True = True |
not | Logical NOT Operator | flag = not(False) = True |
Python Logical AND Operator
Here is a simple example of a logical and operator.
x = 10
y = 20
if x > 0 and y > 0:
print('Both x and y are positive numbers')
Output: Both x and y are positive numbers
Before the logical operation is performed, the expressions are evaluated. So the above if condition is similar to below:
if (x > 0) and (y > 0):
print('Both x and y are positive numbers')
In Python, every variable or object has a boolean value. We have explained this in more detail at Python bool() function.
if x and y:
print('Both x and y have boolean value as True')
Output: Both x and y have boolean value as True
because ‘x’ and ‘y’ len() function will return 2 i.e. > 0.
False
, then the further expressions are not evaluated.Let’s confirm the above statement by defining a custom object. Python uses __bool__()
function to get the boolean value of an object.
class Data:
id = 0
def __init__(self, i):
self.id = i
def __bool__(self):
print('Data bool method called')
return True if self.id > 0 else False
d1 = Data(-10)
d2 = Data(10)
if d1 and d2:
print('Both d1 and d2 ids are positive')
else:
print('Both d1 and d2 ids are not positive')
Output:
Data bool method called
At least one of d1 and d2 ids is negative
Notice that __bool__() function is called only once, confirmed from the print statement output.
Below diagram depicts the flow chart of logical and operation.

Python Logical and Operator Flow Chart
Python Logical OR Operator
Let’s look at a simple example of logical OR operator.
x = 10
y = 20
if x > 0 or y > 0:
print('At least one of x and y is positive number')
Output: At least one of x and y is positive number
True
, then the further expressions are not evaluated.Let’s confirm this with a simple code snippet. We will reuse the Data class defined earlier.
d1 = Data(10)
d2 = Data(20)
# The expressions are evaluated until it's required
if d1 or d2:
print('At least one of d1 and d2 id is a positive number')
else:
print('Both d1 and d2 id are negative')
Output:
Data bool method called
At least one of d1 and d2 id is a positive number
Notice that the __bool__() method is called only once and since it’s evaluated to True
, further expressions are not evaluated.
Let’s run another example where both Data object boolean value will return False
.
d1 = Data(-10)
d2 = Data(-20)
if d1 or d2:
print('At least one of d1 and d2 id is a positive number')
else:
print('Both d1 and d2 id are negative')
Output:
Data bool method called
Data bool method called
Both d1 and d2 id are negative
Finally, below image depicts the flow chart of logical or operator.

Python Logical or Operator
Python Logical NOT Operator
This is a very simple operator that works with a single boolean value. If the boolean value is True
then not operator will return False
and vice-versa.
Let’s look at a simple example of “not” operator.
a = 37
if not (a % 3 == 0 or a % 4 == 0):
print('37 is not divisible by either 3 or 4')
Output: 37 is not divisible by either 3 or 4

Python Logical Not Operator
Python Operators Are Evaluated From Left to Right
Let’s look at an example where we have multiple logical operators. We are not mixing different types of Python operators, so that operator precedence won’t come in picture and it will be easier to explain the output.
We will also override the __bool__() function to print “id” value.
def my_bool(data):
print('Data bool method called, id =', data.id)
return True if data.id > 0 else False
Data.__bool__ = my_bool
d1 = Data(10)
d2 = Data(-20)
d3 = Data(20)
# evaluated from left to right, confirmed from the __bool__() print statement
if d1 and d2 or d3:
print('At least one of them have a positive id.')
Output:
Data bool method called, id = 10
Data bool method called, id = -20
Data bool method called, id = 20
At least one of them have a positive id.
Notice that the boolean value is calculated for d1 first, thus confirming that the execution is happening from left to right.
Logical operators work with any custom object?
In Python, every object has a boolean value. So logical operators will work with any custom objects too. However, we can implement __bool__() function to define our custom rules for an object boolean value.
Summary
Python logical operators allow us to perform logical operations. We looked into logical operators in detail, how their execution is optimized to take the least amount of time. We also confirmed that the operator’s execution is performed from left to right side.