Organize Code into Functions

You’ve been writing Python scripts that work — but as they grow, you feel the pain. The same block of code appears in three places, you’re scared to change a single line because you might break something elsewhere, and your script file scrolls past 300 lines. This is the exact moment you need to organize code into functions and scripts — the single most effective practice for taming complexity and turning a messy script into a maintainable Python program.

The problem this lesson solves

When you write all your logic in one long, linear script (often called a monolithic script), you face several issues:

• Duplication — You copy-paste the same calculation or input routine multiple times. If a bug exists, you have to fix it in every copy. If requirements change (e.g., a new tax rate), you hunt down every occurrence.
• No reusability — You cannot easily reuse a block of logic in another script without copying the entire file.
• Poor readability — A 500-line script with no structure forces you to scroll back and forth, losing context. Debugging becomes a guessing game.
• Testing is impossible — You cannot test a single unit of logic in isolation. You have to run the entire script and check output manually.

The solution? Break your code into functions (named, reusable blocks) and organize those functions into scripts (files) that call them. This is the foundation of modular programming — every professional Python developer relies on it.

Core concept / mental model

Think of a function as a mini-program inside your script. It takes input (parameters), does one specific task, and returns an output (return value). A script is the main program that orchestrates these mini-programs.

Pro tip: The best function does exactly one thing — and does it well. If you find yourself writing do_everything(), break it into smaller helper functions like get_user_input(), calculate_total(), and display_result().

Key definitions: - Function definition — Code block that starts with def, has a name, parameters (optional), and a body. - Function call — Executing the function by using its name followed by parentheses and any arguments. - Return value — The result the function sends back to the caller. - Script — A .py file that contains function definitions and a main execution block (if __name__ == "__main__":).

How it works step by step

Let’s walk through the process of transforming a flat script into an organized, function-based script.

Step 1: Identify repeated logic

Look for code that appears more than once — the same calculation, input validation, or output format. In the example below, the sales tax calculation is duplicated for each item:

# flat script — duplication everywhere
item1_price = 100
item1_tax = item1_price * 0.08
print(f"Item 1 total: {item1_price + item1_tax}")

item2_price = 200
item2_tax = item2_price * 0.08
print(f"Item 2 total: {item2_price + item2_tax}")

item3_price = 50
item3_tax = item3_price * 0.08
print(f"Item 3 total: {item3_price + item3_tax}")

Step 2: Extract the repeated logic into a function

Define a function that takes the price and returns the total (price + tax).

def calculate_total(price, tax_rate=0.08):
    """Return price plus tax."""
    tax = price * tax_rate
    return price + tax

Now your main logic becomes clean and non-repetitive:

item1_total = calculate_total(100)
item2_total = calculate_total(200)
item3_total = calculate_total(50, tax_rate=0.1)  # different rate for item 3
print(item1_total, item2_total, item3_total)

Step 3: Group related functions into a script

Put all your functions in a single file, and use a main() function to call them. Add the guard if __name__ == "__main__": so that the code only runs when the file is executed directly (not when imported as a module).

# sales.py — organized into functions

def calculate_total(price, tax_rate=0.08):
    tax = price * tax_rate
    return price + tax

def get_item_price(item_name):
    price = float(input(f"Enter price for {item_name}: "))
    return price

def main():
    item1_price = get_item_price("Item 1")
    item2_price = get_item_price("Item 2")

    total1 = calculate_total(item1_price)
    total2 = calculate_total(item2_price)

    print(f"Total for item 1: ${total1:.2f}")
    print(f"Total for item 2: ${total2:.2f}")

if __name__ == "__main__":
    main()

Hands-on walkthrough

Now you’ll build a real script: a grade calculator that reads scores, computes averages, and assigns letter grades without any code duplication.

Setup

Create a new file called grade_calculator.py.

Step 1: Write helper functions

def get_scores():
    """Prompt user for scores until empty line, return list of floats."""
    scores = []
    while True:
        user_input = input("Enter a score (or press Enter to finish): ")
        if user_input == "":
            break
        scores.append(float(user_input))
    return scores

def calculate_average(scores):
    """Return average of scores list."""
    if not scores:
        return 0.0
    return sum(scores) / len(scores)

def get_grade(average):
    """Return letter grade based on average."""
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    else:
        return "F"

Step 2: Write the main function

def main():
    print("Grade Calculator")
    scores = get_scores()
    if len(scores) == 0:
        print("No scores entered.")
        return
    avg = calculate_average(scores)
    grade = get_grade(avg)
    print(f"Average: {avg:.2f}")
    print(f"Grade: {grade}")

if __name__ == "__main__":
    main()

Step 3: Run it

python grade_calculator.py

Expected output (example):

Grade Calculator
Enter a score (or press Enter to finish): 85
Enter a score (or press Enter to finish): 92
Enter a score (or press Enter to finish): 78
Enter a score (or press Enter to finish):
Average: 85.00
Grade: B

Pro tip: Always add a docstring (triple-quoted comment) to each function — it helps others (and future you) understand what the function does without reading the full code.

Compare options / when to choose what

For medium-sized scripts (50–500 lines), the single-script-with-functions approach is the sweet spot — you get reusability without the overhead of import management.

Troubleshooting & edge cases

• Function defined but never called — Did you forget to call main()? Check that if __name__ == "__main__": main() is at the bottom of your script.
• Variable scope — A variable defined inside a function is local and cannot be accessed outside. To pass data out, use return.
• No return statement — A function without return implicitly returns None. If your function is supposed to give back a value, make sure return is present.
• Empty input handling — In get_scores(), if the user enters a blank, the loop breaks. But what if they enter an empty string and press Enter? The code above handles that. What if they enter letters? You’d want a try...except to convert (future lesson).
• Running the wrong file — If you import your script in another file, the code under if __name__ == "__main__": will NOT run. That’s the expected behavior.

What you learned & what's next

You now know how to organize code into functions and scripts — the foundation of writing clean, reusable, and maintainable Python. You can: - Identify repeated code and extract it into a function. - Write a script with multiple functions and a main() entry point. - Use docstrings to document functions. - Understand when a single script suffices vs. when you need multiple files.

Next step: The next lesson in this track teaches modules and imports — how to split your functions across multiple files and import them, turning your scripts into a true Python package. You’ll learn import, from ... import ..., and the __name__ variable in depth.

Keep practicing: Refactor any of your old scripts into functions today. You’ll immediately see how much easier they become to read and modify.