Python Or Operator

Python’s or operator performs the logical OR operation that returns True if at least one of the operands evaluates to True. The operator performs an optimization called short-circuiting, so if the first operand evaluates to True, it returns the first right away without further evaluating the second, and if the first operand evaluates to False, it returns the second operand.

As you read through the article, you can also watch my video for supporting explanations:

Python or Operator – on Booleans

Here’s the result of the or operator when applied to Boolean operands:

You can see those examples in the following script:

>>> False or False
False
>>> False or True
True
>>> True or False
True
>>> True or True
False

Python or Operator – on Integers

You can also apply the or operator to integers:

The same can be seen in the following Python script:

>>> 0 or 0
0
>>> 0 or 1
0
>>> 1 or 0
0
>>> 1 or 1
1

Python or Operator – on Objects

Interestingly, you can also apply the logical OR operator on arbitrary Python objects. The base idea is the “truthiness” of Python objects, i.e., every Python object has an associated Boolean value as determined by the __bool__() magic method.

In the following code, you create a custom class called My_Obj and use the “or” operator on instances of this class.

>>> class My_Obj:
	None

	
>>> My_Obj() or My_Obj()
<__main__.My_Obj object at 0x0000025108D897F0>
>>> 0 or My_Obj()
<__main__.My_Obj object at 0x0000025108D897F0>
>>> 1 or My_Obj()
1

You may wonder why some of the outputs are as strange-looking as they are. The reason is simple: every custom object has an associated implicit Boolean value:

>>> bool(My_Obj())
True

If the first operand of the or operation evaluates to False, Python performs the short-circuiting optimization, i.e., it immediately returns the second operand. This makes sense because the second operand logically determines the overall result (see tables below where the first operand is False).

Thus, it is not needed to even evaluate the second operand—and Python simply returns it without modification. That’s why the result of the or operation can be a custom object instead of a Boolean value.

Python or Operator – on Lists

You can apply the or operator on arbitrary objects, including lists. Every list object has an associated Boolean value as determined by the bool(list) method—all lists evaluate to True except the empty list. If you apply the or operator on two lists, Python returns the first list if it is non-empty (due to short-circuiting), and the second list otherwise.

>>> [1, 2, 3] or [4, 5, 6]
[1, 2, 3]
>>> [] or [4, 5, 6]
[4, 5, 6]
>>> [1, 2, 3] or []
[1, 2, 3]
>>> [] or []
[]

So, you’d use the Python or operator on lists, for example, if you’d had a number of backup lists (the second, third, fourth, …) that should be used instead of the higher-priority ones in case they’re empty.

Python or Operator Short Circuit

Short-circuiting is a common optimization in programming languages that use the following observation: if the first operator evaluates to True, the whole or expression must evaluate to True too. Thus, it is not needed to evaluate subsequent operands to know the result of the overall logical expression. Only if the first operand is False, it moves further to the second operand—and, potentially, the third and so on. This can save significant time when evaluating complicated logical expressions.

A minimal example of short-circuiting on the or operator is shown here:

>>> True or print('Am I evaluated?')
True 
>>> False or print('Am I evaluated?')
Am I evaluated?

We use a simple trick to check if the second operand is evaluated or not due to the short-circuiting optimization—the second operand is a print() statement that always returns None but generates visible side-effects when executed. You can see that in the first example, it is not evaluated because the first operand already determines the result of the whole expression. But in the second example, it is evaluated because the first operand does not provide a conclusive answer on the result of the overall expression.

Python or Operator vs |

Python’s “or” operator performs a logical OR operation that returns True if one or more operands are True. Python’s “|” symbol is a bitwise operator that works on the bit representations of the operands and performs a bit by bit operation. So, “or” tests whether at least one operand is logically True whereas “|” performs bitwise OR operation on the operands.

When considering only a single bit, semantically, such as when comparing Booleans, the operators are the same:

>>> True or False
True
>>> True | False
True

However, the difference becomes apparent if you use integer operands:

>>> 32 or 16
32
>>> 32 | 16
48

The first expression 32 or 16 determines that the integer value 32 is associated to the Boolean True, so it returns the first operand 32 as it performs the short-circuiting optimization.

The second expression 32 | 16 operates on the bit representations 10000 (decimal 32) and 01000 (decimal 16) and performs bit-wise OR. The result is the bit representation 11000 which represents the decimal 48:

Similarly, let’s have a look at another example to showcase the bitwise OR operator:

>>> 31 | 15
31

You can see this in the following visualization:

The decimal representation of the bit sequence 11111 is 31.

Python or Operator Evaluation Order

Python evaluates the left before the right operand. It uses short-circuiting when evaluating expressions involving the logical and or or operators, so it doesn’t evaluate the second operand unless it is necessary to determine the result. The logical and takes precedence before the logical or.

In the following example, you see that the “and” operator is evaluated first because it has precedence over the “or” operator.

>>> False and False or True
True
>>> (False and False) or True
True
>>> False and (False or True)
False

The same precedence can be seen here:

>>> True or False and False
True
>>> (True or False) and False
False
>>> True or (False and False)
True

This also rules out what many people wrongly assume—that there’s a first-comes-first-serve operator precedence. In this example, the “or” operator is evaluated last even though it comes first.

Python or Operator in If Condition

If you want to use the logical OR operator in an if condition, use the keyword or instead of the double || symbol you may know as the logical OR from Java or C++. For example, if A or B would be correct whereas if A || B would be incorrect.

Here’s the correct use of the logical AND in an if condition:

# YES!
if 2+2 == 4 or 2-2 == 0:
    print('YES!')

The result of this code snippet is 'YES!'.

Here’s the wrong way of doing it as a C++ or Java coder going Python:

# NO!
if 2+2 == 4 || 2-2 == 0:
    print('NO!')

The result of this code snippet is a SyntaxError:

To resolve this, simply replace the faulty double symbol || with the correct keyword or.

Logical Operators

Logical operators are shortcuts to perform Boolean comparisons, but can be used on integers and other objects as well.