Logical Operators and Boolean Expressions

Short-circuit evaluation stops evaluating a logical expression once the result is already determined.

Programming

Why Evaluation Order Matters

A logical expression can contain more than one condition. Python evaluates those parts from left to right, but it does not always evaluate every part. When the result is already determined, Python stops. This behavior is called short-circuit evaluation.

Key point

The central rule is simple: and stops when the first part is False, while or stops when the first part is True.

Tracing a Logical Expression

How does Python evaluate an and expression from left to right, and where does it stop when the result is already determined?

Worked example

Following an and expression

Trace the expression x >= 2 and (x/y) > 2 when x is less than 2.

1
Check the first part
Because x is less than 2, x >= 2 evaluates to False.
2
Apply the and rule
In an and expression, a False first part makes the entire expression False. Python therefore does not evaluate (x/y) > 2.
3
Check the consequence
Since the division is not attempted, a zero value for y does not cause a ZeroDivisionError in this case.

Result

The expression is False, and the second part is skipped.

What do you think happens?

What happens when x is less than 2 and y is zero in x >= 2 and (x/y) > 2?

Python always attempts the division and raises ZeroDivisionError
Python stops after the first part and the expression is False
Python changes the expression into an or expression

Reveal answer

Answer:

Python stops after the first part and the expression is False.

The first part is False. That already determines the result of an and expression, so Python never evaluates the division.

The Two Short-Circuit Rules

Operator	First part	What Python does	Reason
and	False	Stops and does not evaluate the later part	The entire and expression must be False
and	True	Evaluates the later part	The later part is needed to determine the result
or	True	Stops and does not evaluate the later part	The entire or expression must be True
or	False	Evaluates the later part	The later part is needed to determine the result

The first operand determines whether Python can stop evaluating.

What different evaluation paths occur when the first operand of an and or or expression is true or false?

The two operators use opposite stopping conditions. With and, the first part must be False to prevent the later part from running. With or, the first part must be True to prevent the later part from running. The operator and the guard condition must therefore be chosen together.

Using the Guardian Pattern

Definition

The guardian pattern places a safe guard condition before a risky operation in a logical expression. If the guard makes the first part False in an and expression, Python stops before evaluating the risky operation.

How does checking a condition first prevent Python from evaluating a later expression that could cause ZeroDivisionError?

In x >= 2 and (x/y) > 2, x >= 2 is the guard and (x/y) > 2 is the risky operation. When x is less than 2, the guard is False. The and expression is then already False, so Python never attempts the division. If the guard is True, Python continues and evaluates the second part.

The same pattern can protect a list access. The guard len(my_list) > 0 ensures that my_list[0] is accessed only when the list is not empty. When the list is empty, the guard is False and the list access is skipped, preventing an IndexError.

Mistakes Beginners Make

Common mistake
Assuming Python always evaluates both parts of a logical expression
What it looks like
Treating x >= 2 and (x/y) > 2 as if the division always occurs
Why it fails
When x >= 2 is False, the and result is already determined, so Python skips the division.
Do this instead
Trace the first part first and ask whether it already determines the result.
Common mistake
Reversing the short-circuit rules
What it looks like
Expecting and to stop on True or or to stop on False
Why it fails
The stopping conditions are opposite: and stops on False, while or stops on True.
Do this instead
Remember that a False first part settles and, and a True first part settles or.
Common mistake
Putting the risky operation before the guard
What it looks like
Evaluating a division before checking the condition intended to protect it
Why it fails
Python evaluates from left to right, so a later guard cannot prevent an earlier operation from running.
Do this instead
Place the safe guard first.
Common mistake
Choosing an operator without considering the guard's required result
What it looks like
Using an operator whose short-circuit condition does not match the guard
Why it fails
An and expression needs a False first part to skip its second part, while an or expression needs a True first part.
Do this instead
Choose the operator and guard condition together.

Practice the Trace

MEDIUM

For each situation, identify whether Python evaluates the later part of the expression. Explain your answer using the words guard, short-circuit, and result already determined.

Hints

For and, ask whether the first part is False.
For or, ask whether the first part is True.
Check the expression from left to right.

Your attempt (not saved)

Worked example

Practice answer

Analyze x >= 2 and (x/y) > 2 when x is less than 2 and y is zero.

1
Identify the guard
The first part, x >= 2, is the guard.
2
Evaluate the guard
Because x is less than 2, the guard is False.
3
Apply short-circuit evaluation
The and expression is already False, so Python skips the later division.

Result

No division is attempted, so this expression does not raise ZeroDivisionError in this situation.

Key Takeaways

1
Python evaluates logical expressions from left to right and stops when the result is already determined.
2
An and expression short-circuits when its first part is False.
3
An or expression short-circuits when its first part is True.
4
The guardian pattern places a safe condition before a risky operation.
5
Correct guard order can prevent runtime errors such as ZeroDivisionError and IndexError.

At a glance

Short-circuit evaluation means Python may skip later parts of a logical expression.
The and operator stops on a False first part; the or operator stops on a True first part.
A guardian condition must appear before the operation it protects.
The guardian pattern can prevent errors by ensuring that a risky expression is evaluated only when its required condition is met.

More concepts starting with L