Understanding Code: From Conditions to Functions with Real‑World Analogies

Code is a language that a computer can understand; unlike a human, a computer cannot infer ambiguous instructions, so every possible action must be described explicitly. Think of the computer as a fast, obedient person who follows detailed commands.

Programming = Algorithms + Data Structures

Python is used for all examples because its syntax is concise.

1. Conditionals

Conditional statements let the computer choose different actions based on conditions. Keywords include if, else, elif, logical operators and, or, and comparison operators <, >, ==, !=, <=, >=. Example (buy a watermelon only if the store is discounted):

if fruit_store_is_discounted:
    buy_watermelon
else:
    do_not_buy

A more complex scenario adds bargaining with the store owner and different purchase quantities based on discount depth, using nested if statements and logical operators.

2. Loops

Loops repeat the same command for multiple objects. Python keywords are for…in…, while, break, and continue. Example (search three fruit stores for a discount):

for store in (Xianfeng, Siji, Street_stall):
    if store_is_discounted:
        buy_watermelon
        break
    else:
        pass
# continue after the loop
bring_watermelon_home

The break statement ends the loop once a suitable store is found.

3. Variables

Variables act as the computer’s memory cells, storing values that can change. Assignment uses =, while comparison uses ==. The special value None represents an empty cell. Scope determines where a variable is visible: a variable is accessible from its first appearance down through all deeper‑indented code, but not outside that block.

previous_max_discount

store_with_max_discount

current_store_discount

store (loop variable)

Example of tracking the best discount across stores:

previous_max_discount = None
store_with_max_discount = None
for store in (Xianfeng, Siji, Street_stall):
    current_discount = get_discount_from_owner()
    if previous_max_discount is None or current_discount < previous_max_discount:
        previous_max_discount = current_discount
        store_with_max_discount = store
buy_watermelon_from(store_with_max_discount)

4. Functions

Functions group reusable code and give it a name. Defined with def function_name():, the indented block forms the function body. Calling the function executes its code. Parameters allow the same logic to work with different data, avoiding duplication.

Example of a generic fruit‑buying function:

def buy_fruit(fruit_name):
    for store in (Xianfeng, Siji, Street_stall):
        if store_is_discounted:
            buy(fruit_name)
            break
        else:
            bargain()
            if bargain_successful and discount_rate <= 5:
                buy_two(fruit_name)
            elif bargain_successful and discount_rate > 5:
                buy_one(fruit_name)
            else:
                give_up()

Calling buy_fruit('watermelon') or buy_fruit('pomelo') runs the same workflow with different fruit.

Python also supports default parameters, e.g.:

def sum(a, b=0, c=1):
    return a + b + c

Calls sum(1), sum(1, 0, 1), or sum(1, c=1) all produce the same result.

5. Modules

Modules are files (typically .py) that bundle related functions, classes, and variables. Importing a module makes its contents available to other files. Three common import styles: import a → use

a.function()

from a import *

→ use function() directly from a import func1, func2 → import selected names

6. Classes and Objects

Classes define a blueprint that combines state (attributes) and behavior (methods). An object is an instance created from a class at runtime. For example, a “WatermelonBuyer” class could store a name, balance, and owned watermelons, and provide a method to purchase watermelons. This concept differs from functions and modules, which mainly organize code; classes encapsulate both data and functionality.

Overall, the article demonstrates how explicit commands, control structures, reusable functions, modular organization, and object‑oriented design enable clear, maintainable code.