Functions and Modular Programming - Programming for Machine Learning and Business

Reusing Logic Clearly and Efficiently¶

Functions turn repeated steps into reusable tools¶

Loops taught Python how to repeat logic. Functions teach Python how to package that logic behind a clear name, with inputs and outputs, so the same idea can be reused across reports, dashboards, models, and business rules.

Why this matters¶

A growing project becomes easier to manage when repeated logic is turned into reusable building blocks. In business and ML work, functions help you:

calculate the same KPI for many teams without rewriting the formula
package a scoring rule so it can be tested and reused
separate data cleaning, transformation, and reporting into understandable steps
prepare code so it can later move into modules and packages

Core Explanation¶

A function is a named block of code that performs one clear task. Instead of rewriting the same steps every time, you define the logic once and call it whenever you need it.

Named function

Lambda expression

Use a named function when the logic deserves a clear label, may be reused often, or needs more than one line to stay readable.

def discount_price(price, rate):
    return price * (1 - rate)

Use a lambda for very small, short-lived expressions, especially when passing a tiny transformation into another function.

double = lambda value: value * 2

If the logic starts needing explanations, conditions, or multiple steps, switch back to a named function.

Visual intuition: calling a function many times¶

A loop can call the same function for many records. That is the bridge between repeated processing and reusable logic.

def greet_user(name):
    return f"Welcome, {name}."

print(greet_user("Business Python Learner"))

Welcome, Business Python Learner.

Worked Example: turning a formula into a reusable helper¶

Suppose a company wants the same profit calculation to work for many product lines. A function makes the rule reusable and easy to test.

Small example: lambda for a tiny transformation¶

Guided Practice¶

What is the main purpose of a function parameter?¶

To pass input values into the functionCorrect. Parameters let the same function work with different inputs.

To end the program immediatelyParameters are inputs, not stop commands.

To replace every variable in the notebookParameters only exist in the function definition and calls that use them.

When is a lambda usually appropriate?¶

When the logic spans many lines and needs commentsThat is a sign that a named function would be clearer.

When the operation is short and simpleCorrect. Lambdas are best for compact expressions.

Only when working with loopsLambdas are not tied only to loops.

Exercises¶

Exercise 1: Total invoice¶

Exercise 2: Pass or review¶

Exercise 3: Tiny lambda helper¶

The next notebook shows how reusable logic moves beyond one file and into modules and packages.

double = lambda x: x * 2
print(double(6))

Practice Lab¶

Key Takeaway¶

Functions are the first major tool for turning a script into a maintainable program. Once logic has a name, inputs, and outputs, it becomes much easier to reuse, test, and eventually move into separate modules.