Programming in Python · Chapter 4

`if` Statements and Branching Structures

Conditional Branching

Evaluate the runtime state,
then choose which execution path to take.

Chapter Overview

Conditions and Choices in Programs

In the first three chapters, programs ran from top to bottom along a single path.
Real-world business problems, however, involve conditions and choices.

Business Rules

Online orders of 99 yuan or more ship for free; otherwise, a base shipping fee applies.
When the account balance is sufficient, the deduction succeeds; otherwise, payment fails.
An exam score of 60 or above passes; otherwise, it fails.

Chapter Roadmap

Single-branch, two-way, and multi-branch structures.
Compound conditions, short-circuit evaluation, and independent checks.
Nested branches and branching inside functions.

Extended topics: conditional expressions and guard clauses.

4.1 Execute Only When a Condition Holds

The `if` Statement and Code Blocks

if condition_expression:
    statement_1_when_true
    statement_2_when_true

subsequent_statement_after_branch

Single-branch structure: runs when the condition holds,
and skips the block directly when the condition fails.

if declares a conditional branch.
The condition can be a comparison expression, a logical expression, or a boolean variable.
An ASCII colon at the end of the condition introduces the code block.
Statements inside the branch are indented to the right, with 4 spaces recommended.

Returning indentation to the level of if exits the code block and resumes the main flow.

4.1 Case Description

Preset a Base Fee and Waive It at the Threshold

Shipping is waived when the order amount reaches 99 yuan;
below that threshold, a 6 yuan base shipping fee applies.

Order Amount	Meets Free-Shipping Threshold?	Final Shipping Fee	Total Payable
85.0 yuan	No, skip branch	6.0 yuan	91.0 yuan
99.0 yuan	Yes, run branch	0.0 yuan	99.0 yuan
120.0 yuan	Yes, run branch	0.0 yuan	120.0 yuan

Preset the base shipping fee first, and set it to zero if the condition holds.
After the branch finishes, calculate the total payable.

4.1 Case Code

Free Shipping Rule: Single-Branch Implementation

PYTHON

order_amount = 120.0  # Order amount
shipping_fee = 6.0    # Default base shipping fee

if order_amount >= 99.0:
    shipping_fee = 0.0

total = order_amount + shipping_fee
print(f"Shipping fee: {shipping_fee:.2f} yuan")
print(f"Total payable: {total:.2f} yuan")

4.1 In-Class Exercise · Prompt

The Boundary of "Reaches 99 Yuan"

Change the order amount to 98.0, 99.0, and 100.0 in turn.
Calculate the shipping fee and total payable by hand first, then run the code to verify.

Order Amount	Condition Holds?	Final Shipping Fee	Total Payable
98.0 yuan	?	?	?
99.0 yuan	?	?	?
100.0 yuan	?	?	?

Note that "reaches 99 yuan" includes the case of exactly 99 yuan.

4.1 In-Class Exercise · Solution

Boundary Values: Code and Results

Modify the first line for each value, then run

order_amount = 98.0  # Then change to 99.0 and 100.0
shipping_fee = 6.0

if order_amount >= 99.0:
    shipping_fee = 0.0

total = order_amount + shipping_fee
print(f"Shipping fee: {shipping_fee:.2f} yuan")
print(f"Total payable: {total:.2f} yuan")

Verification Results

Order	Shipping	Total
98.0	6.0	104.0
99.0	0.0	99.0
100.0	0.0	100.0

Because the threshold value is included, use >=.

Testing boundary values verifies that the comparison operator matches the business rule.

4.2 Execute A or Execute B?

`if/else`: Choosing Between Two Alternatives

if condition_expression:
    statement_when_true
else:
    statement_when_false

subsequent_statement_after_branch

The defining property of a two-way branch is mutual exclusion.

Each execution takes one and only one of the two branches.
else must share the same indentation as its paired if.
A colon follows else directly; no condition may be attached to else.

Once the chosen branch finishes, execution rejoins the subsequent statements and continues downward.

4.2 Case Description

Is the Account Balance Sufficient for Payment?

When the balance is sufficient, deduct the payment and report success.
When the balance is insufficient, do not deduct and report failure.

Initial Balance	Payment Amount	Executed Branch	Balance After Deduction
120.0 yuan	114.0 yuan	Deduction succeeds	6.0 yuan
100.0 yuan	114.0 yuan	Deduction fails	100.0 yuan
114.0 yuan	114.0 yuan	Deduction succeeds	0.0 yuan

When the balance equals the payment amount, the payment still succeeds.
When payment fails, the account balance keeps its original value.

4.2 Case Code

Payment Processing: Two Explicit Paths

PYTHON

account_balance = 120.0
payment = 114.0

if account_balance >= payment:
    account_balance = account_balance - payment
    print("Payment successful")
else:
    print("Insufficient balance, payment incomplete")

print(f"Current balance: {account_balance:.2f} yuan")

4.3 Multi-Branch · Case Description

Handling Multiple Cases: Course Grade Classification

Score Interval	Assigned Grade
90 and above	Excellent
80 to 89	Good
60 to 79	Pass
Below 60	Fail

A given score falls into one grade only.

Python uses if/elif/else to express this multi-way choice.

elif means "otherwise, if...": the interpreter checks the current condition only when all preceding conditions are false.

The table states integer intervals. The code also handles decimals; for instance, 89.5 receives Good. Scores are assumed to lie in 0–100.

4.3 Case Code

Check Top to Bottom and Exit on First Match

PYTHON

score = 85

if score >= 90:
    grade = "Excellent"
elif score >= 80:
    grade = "Good"
elif score >= 60:
    grade = "Pass"
else:
    grade = "Fail"

print(f"Score: {score}, Grade: {grade}")

4.3 Execution Mechanism

Condition Order Directly Determines the Result

When condition ranges nest inside one another, check stricter conditions first,
then check looser conditions.

Comparison Form	Threshold Order	Principle
One-sided lower bound `>=`	Descending: 90, 80, 60	Larger values cover a smaller range
One-sided upper bound `<=`	Ascending	Smaller values cover a smaller range

A score of 95 satisfies all three lower bounds (90, 80, and 60). Checking 60 first
matches "Pass" early and prevents execution from reaching the stricter "Excellent" branch below.

Reaching the 80-point check already rules out scores of 90 or above, so there is no need to repeat the condition that the score is below 90.

4.4 Checking Multiple Conditions Together

Logical Operators: `and`, `or`, `not`

and · Conjunction: Both conditions must hold.
If either side is false, the whole expression is false.
or · Disjunction: Either condition suffices.
The whole expression is false only when both sides are false.
not · Negation: Inverts the boolean value:
true becomes false, and false becomes true.

A	B	A and B	A or B
False	False	False	False
True	False	False	True
False	True	False	True
True	True	True	True

This table assumes boolean operands. A boolean variable
can serve directly as a condition without comparing it to True.

4.4 Case Description

Free Shipping, Except for Remote Areas

Orders of 99 yuan or more or orders placed by VIP members qualify for free shipping,
except for deliveries to remote areas.

Combine free-shipping eligibility firstThe order amount reaches the threshold, or the user is a VIP member.
Check the region restriction nextThe destination must not be a remote area.

Parentheses in Compound Conditions

Enclose grouped conditions in parentheses so the business logic is clear at a glance.

Common precedence from highest to lowest:
arithmetic, comparison, not, and, or.

Precedence determines how expressions bind. At runtime, evaluation still follows left-to-right order and short-circuit rules.

4.4 Case Code

Using Parentheses to Clarify Compound Conditions

PYTHON

order_amount = 85.0
is_vip = True
is_remote_area = False

if (order_amount >= 99.0 or is_vip) and not is_remote_area:
    shipping_fee = 0.0
else:
    shipping_fee = 6.0

print(f"Shipping fee: {shipping_fee:.2f} yuan")

4.4 Common Pitfall · Problem Description

"Equals A or B" Requires Two Full Comparisons

To test whether a coupon code is SAVE10 or VIP10,
write a complete comparison expression on each side of or.

If the comparison target is omitted on the right, the right side becomes a standalone string.
Because a non-empty string has a truth value of true, an invalid coupon code will still pass the check.

Distinguish the object returned by an expression from the truth value of that object in a condition.

In Python, and and or return the operand that determines the outcome, whereas not always returns a boolean.

4.4 Common Pitfall · Code Comparison

Coupon Validation: Write Each Comparison in Full

INCORRECT

# Incorrect: right side does not perform a comparison
if coupon_code == "SAVE10" or "VIP10":
    ...

CORRECT

coupon_code = "VIP10"

if coupon_code == "SAVE10" or coupon_code == "VIP10":
    print("Coupon valid")
else:
    print("Invalid coupon")

4.4 Short-Circuit Evaluation · Case Description

Check the Course Count Before Computing the Average

During left-to-right evaluation, once the left side determines the overall truth value,
the interpreter stops evaluating the remaining expressions.

Expression	Left Result	Evaluates Right Side?
`A and B`	False	No, skipped by short-circuiting
`A or B`	True	No, skipped by short-circuiting

When the course count is 0, dividing by it directly raises an error.
Place the guard check on the left and the calculation that depends on it on the right.

4.4 Short-Circuit Evaluation · Case Code

Using `and` to Skip Division by Zero

PYTHON

total_score = 150.0
course_count = 0

if course_count > 0 and (total_score / course_count) >= 60.0:
    print("Passed assessment")
else:
    print("No valid scores or assessment not passed")

4.5 Case Description

Multiple Independent `if` Statements vs. a Branch Chain

For the same 250 yuan purchase,
whether the customer receives both gifts depends on the business rules.

Rule Type	Store Policy	Control Structure
Cumulative	Spend 100 yuan for a coupon; spend 200 yuan for an extra tote bag	Multiple independent `if` statements
Mutually exclusive (pick one)	Spend 200 yuan for a tote bag only; spend 100–199 yuan for a coupon only	A single `if/elif` chain

Independent checks can trigger multiple outcomes at once.
A single branch chain ends on the first match and executes at most one branch.

4.5 Case Code

Choosing the Control Structure to Match the Business Rule

Multiple Independent if Statements: Cumulative

order_amount = 250.0

if order_amount >= 100.0:
    print("Award a coupon")

if order_amount >= 200.0:
    print("Award a custom tote bag")

Award a coupon
Award a custom tote bag

A Single if/elif Chain: Mutually Exclusive

order_amount = 250.0

if order_amount >= 200.0:
    print("Award a custom tote bag")
elif order_amount >= 100.0:
    print("Award a coupon")

Award a custom tote bag

4.6 Nested Branches · Case Description

Verify the Prerequisite Before Detailed Checks

Check first whether the user is logged in.
If logged in, then check whether the user is a VIP member.

Login Status	Membership Status	Action
Not logged in	Not checked	Prompt "Please log in first"
Logged in	Regular user	Display 100 yuan standard price
Logged in	VIP member	Display 80 yuan VIP price

Writing a complete if statement inside another branch's block
is called nested branching.

4.6 Case Code

Indentation Determines Which `if` an `else` Pairs With

PYTHON

is_logged_in = True
is_vip = False

if is_logged_in:
    if is_vip:
        price = 80.0
    else:
        price = 100.0
    print(f"Product price: {price:.2f} yuan")
else:
    print("Please log in to view price")

4.7 Branching in Functions · Case Description

Calculating Shipping Fees from Package Weight

Billable weight is a positive integer,
measured in kilograms.

Billing Tier	Shipping Fee
Up to 1 kg	12 yuan
Over 1 kg	12 + (weight − 1) × 5 yuan

Function Workflow

Receive input: the weight parameter.
Branch calculation: assign a value to the freight variable.
Unified return: keep a single return statement outside the branches.

This pattern is called a single-exit structure.

4.7 Case Code

Compute Inside Branches, Return Once Outside

PYTHON

def calculate_freight(weight: int) -> int:
    """Calculate shipping fee from package weight."""
    if weight <= 1:
        freight = 12
    else:
        freight = 12 + (weight - 1) * 5

    return freight


print(calculate_freight(1))
print(calculate_freight(2))
print(calculate_freight(4))

Core Exercise 1 · Prompt

Calculating the Total Payable for a Takeout Order

The standard delivery fee is 5.0 yuan. Delivery is free when the food total
reaches 30.0 yuan or more, or when the customer is a VIP.

The total payable equals the food total plus the delivery fee. Design the function name,
parameters, type annotations, and return value, then test your code against the cases below.

Food Total	Is VIP	Expected Return
25.0	False	30.0
30.0	False	30.0
25.0	True	25.0

Core Exercise 1 · Reference Code

Takeout Total: Combining Conditions and Unified Calculation

PYTHON

def calculate_takeout_total(
    food_total: float, is_vip: bool
) -> float:
    """Calculate takeout total from food amount and VIP status."""
    if food_total >= 30.0 or is_vip:
        delivery_fee = 0.0
    else:
        delivery_fee = 5.0

    return food_total + delivery_fee


print(calculate_takeout_total(25.0, False))
print(calculate_takeout_total(30.0, False))
print(calculate_takeout_total(25.0, True))

Core Exercise 2 · Prompt

Calculating Tiered Printing Fees

Printing more pages lowers the unit price per page.
The total fee equals the page count multiplied by the corresponding unit price.

Page Count (Positive Integer)	Unit Price	Boundary Self-Checks
Under 20 pages	0.5 yuan / page	19 pages: 9.5 yuan
20 to 49 pages	0.4 yuan / page	20 pages: 8.0 yuan; 49 pages: 19.6 yuan
50 pages or more	0.3 yuan / page	50 pages: 15.0 yuan

Design the function interface yourself, and consider the ordering of the multi-branch conditions.

Core Exercise 2 · Reference Code

Matching Unit Prices from Strictest to Loosest

PYTHON

def calculate_printing_fee(pages: int) -> float:
    """Calculate tiered printing fee from total page count."""
    if pages >= 50:
        unit_price = 0.3
    elif pages >= 20:
        unit_price = 0.4
    else:
        unit_price = 0.5

    return pages * unit_price

print(calculate_printing_fee(19))
print(calculate_printing_fee(20))
print(calculate_printing_fee(49))
print(calculate_printing_fee(50))

Core Exercise 3 · Prompt

Layered Verification of Order Payment Status

Check first whether the order has been cancelled.
If the order is active, check whether the account balance covers the payment.

Order Cancelled	Account Balance	Amount Payable	Expected Return
True	120.0	114.0	Order cancelled
False	120.0	114.0	Payment approved
False	100.0	114.0	Insufficient balance
False	114.0	114.0	Payment approved

Use two-level nested branches, checking the balance inside the outer else.
Store the message in a variable and return that string at the end of the function.

Core Exercise 3 · Reference Code

Nested Branches and the Single-Exit Structure

PYTHON

def get_payment_message(
    is_cancelled: bool, account_balance: float, payment: float
) -> str:
    """Check order status and balance; return status text."""
    if is_cancelled:
        message = "Order cancelled"
    else:
        if account_balance >= payment:
            message = "Payment approved"
        else:
            message = "Insufficient balance"

        return message

Part 2 · Extended Topic 4.8

Conditional Expressions: Single-Line Two-Way Assignment

When a branch simply chooses between two values based on a condition,
a compact conditional expression can assign the result on one line.

target_variable = value_1 if condition else value_2

Evaluation Order

Evaluate the middle condition first:
take the left value if true, or the right value if false.

Revisiting the Free-Shipping Rule

If the order reaches 99 yuan, shipping is 0 yuan;
otherwise, shipping is 6 yuan.

Best suited for simple assignments. When branches require multiple steps or complex logic, a multi-line branch structure is clearer.

4.8 Extended Case · Code

Free Shipping Rule: Conditional Expression

PYTHON

order_amount = 120.0

shipping_fee = 0.0 if order_amount >= 99.0 else 6.0
print(f"Shipping fee: {shipping_fee:.2f} yuan")

Evaluate the condition first, then select one of the two values.

Extended Topic 4.9 · Case Description

Exiting a Function Early with `return`

Once a function executes return, it terminates immediately
and returns the result to the caller; subsequent code does not run.

Payment Status Check	Handling with Early Return
Order is cancelled	Return "Order cancelled" immediately
Order is active and balance is sufficient	Return "Payment approved"
All other cases	Return "Insufficient balance" by default at the end

This pattern is called a guard clause, or early return.
Filtering out special cases upfront reduces nested indentation.

4.9 Extended Case · Code

Flattening Layered Checks with Guard Clauses

PYTHON

def get_payment_message(
    is_cancelled: bool, account_balance: float, payment: float
) -> str:
    if is_cancelled:
        return "Order cancelled"

    if account_balance >= payment:
        return "Payment approved"

    return "Insufficient balance"


print(get_payment_message(True, 120.0, 114.0))
print(get_payment_message(False, 120.0, 114.0))
print(get_payment_message(False, 100.0, 114.0))

Chapter Summary

Choosing the Right Branching Structure

Business Requirement	Control Structure	Execution Behavior
Execute only when a condition holds	`if`	Runs if true; skips otherwise
Two mutually exclusive paths	`if/else`	Takes one and only one path
Multiple mutually exclusive cases	`if/elif/else`	Checks in order; exits on first match
Independent rules that can accumulate	Multiple independent `if` statements	Evaluates each condition separately
Subsequent check depends on a prerequisite	Nested branches	Checks the prerequisite before detailed checks

Indentation expresses block membership, and condition order shapes the execution path.
Group compound conditions explicitly, and test boundary values to verify business rules.

Action	Shortcut
Next slide	`→` `↓` `Space` `Page Down`
Previous slide	`←` `↑` `Page Up` `Shift + Space`
First / Last slide	`Home` / `End`
Contents / Fullscreen	`M` / `F`
Shortcuts / Close dialog	`?` / `Esc`

if Statements and Branching Structures

Business Rules

Chapter Roadmap

Parentheses in Compound Conditions

Multiple Independent if Statements: Cumulative

A Single if/elif Chain: Mutually Exclusive

Function Workflow

Evaluation Order

Revisiting the Free-Shipping Rule

`if` Statements and Branching Structures