Python Logical AND

The and operator in Python is a logical operator that performs boolean AND operations using short-circuit evaluation. Rather than strictly returning the boolean values True or False, it evaluates expressions from left to right and returns the first falsy operand it encounters, or the last operand if all operands evaluate to truthy.

expression1 and expression2

Evaluation Mechanics

When the Python interpreter encounters an and expression, it processes the operands based on their boolean context (truthiness):

Left-to-Right Evaluation: It evaluates expression1 first.
Short-Circuiting: If expression1 evaluates to a falsy value, the and operator immediately returns expression1. It completely halts evaluation, meaning expression2 is never executed or evaluated.
Continuation: If expression1 evaluates to a truthy value, the operator proceeds to evaluate and return expression2.

Truthy and Falsy Context

To understand the return values, it is necessary to know how Python defines falsy values. The following built-in objects are considered falsy:

Constants: None and False
Zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
Empty sequences and collections: "", (), [], {}, set(), range(0)

All other values are considered truthy by default.

Syntax and Behavior Visualization

Standard Boolean Evaluation:

True and True    # Returns True
True and False   # Returns False
False and True   # Returns False (short-circuits at False)
False and False  # Returns False (short-circuits at the first False)

Non-Boolean Object Evaluation: Because and returns the actual operand rather than a casted boolean, it yields the underlying objects:

5 and "String"   # Returns "String" (5 is truthy, returns the last operand)
"" and 10        # Returns "" (Empty string is falsy, short-circuits)
[1, 2] and None  # Returns None ([1, 2] is truthy, returns the last operand)
0 and []         # Returns 0 (0 is falsy, short-circuits)

Short-Circuit Demonstration: The short-circuiting behavior prevents the execution of subsequent expressions if an early expression fails.

# The ZeroDivisionError is never raised because 0 is falsy.

# The evaluation short-circuits and returns 0.
result = 0 and (10 / 0) 

Operator Precedence

In Python’s order of operations, the and operator has:

Lower precedence than arithmetic operators (+, -, *), bitwise operators (&, |), and comparison operators (==, >, <).
Higher precedence than the logical or operator.
Left-to-right associativity, meaning multiple and operators in a sequence are evaluated from left to right.

# Comparison operators are evaluated before 'and'

# Equivalent to: (5 > 3) and (10 < 20)
5 > 3 and 10 < 20  # Returns True


# 'and' is evaluated before 'or'

# Equivalent to: "a" or ("b" and "c")
"a" or "b" and "c" # Returns "a"