> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Logical OR
The `or` operator in Python is a logical operator that performs inclusive disjunction. It evaluates two expressions and returns the first operand if it resolves to a truthy value; otherwise, it evaluates and returns the second operand. Unlike some languages where logical operators strictly return boolean types (`True` or `False`), Python's `or` operator returns the actual object reference of the evaluated operand.
```python theme={"dark"}
operand_left or operand_right
```
## Evaluation Mechanics
Python evaluates the `or` operator using **short-circuit evaluation**. The interpreter processes the operands from left to right based on their boolean context (truthiness).
1. `operand_left` is evaluated.
2. If `operand_left` is truthy, the expression immediately returns `operand_left`. The `operand_right` expression is completely ignored (short-circuited).
3. If `operand_left` is falsy, the interpreter evaluates and returns `operand_right`.
## Truthiness and Return Values
In Python, objects like `None`, `0`, `0.0`, empty sequences (`""`, `[]`, `()`), and empty mappings (`{}`) are considered **falsy**. All other objects are generally considered **truthy**.
```python theme={"dark"}
# Standard boolean evaluation
True or False # Evaluates to: True
# First operand is truthy: Returns the first operand
"Python" or "" # Evaluates to: "Python"
[1, 2] or [3, 4] # Evaluates to: [1, 2]
10 or 0 # Evaluates to: 10
# First operand is falsy: Returns the second operand
0 or 20 # Evaluates to: 20
"" or "String" # Evaluates to: "String"
None or [] # Evaluates to: []
# Both operands are falsy: Returns the second operand
0 or False # Evaluates to: False
"" or 0 # Evaluates to: 0
```
## Short-Circuit Demonstration
Because of short-circuiting, the right-hand operand is only executed if the left-hand operand is falsy. This is observable when the right-hand operand contains a function call or an operation with side effects.
```python theme={"dark"}
def side_effect():
print("Evaluated!")
return True
# side_effect() is NOT called because 1 is truthy
result_1 = 1 or side_effect()
# result_1 is 1
# side_effect() IS called because 0 is falsy
result_2 = 0 or side_effect()
# Prints: "Evaluated!"
# result_2 is True
```
## Chaining Multiple `or` Operators
When multiple `or` operators are chained, the interpreter evaluates from left to right and stops at the very first truthy operand it encounters, returning that operand. If no truthy operand is found, it returns the final falsy operand.
```python theme={"dark"}
# Stops at 5 (first truthy value)
result = 0 or [] or 5 or "String" # Evaluates to: 5
# Evaluates all, returns the last falsy value
result = 0 or [] or "" or None # Evaluates to: None
```
## Operator Precedence
The `or` operator has the lowest precedence among Python's logical operators (`not`, `and`, `or`). It evaluates after `and` but before assignment operators.
```python theme={"dark"}
# 'and' is evaluated before 'or'
# Equivalent to: "A" or ("" and "B") -> "A" or "" -> "A"
"A" or "" and "B" # Evaluates to: "A"
# Equivalent to: ("" or "A") and "B" -> "A" and "B" -> "B"
("" or "A") and "B" # Evaluates to: "B"
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
