IFI 8410 — Session 4: Functions and Decomposition

Functions as Decomposition

From tasks and handoffs to contracts and return values

The core idea

A function is a boundary around one task

Decomposition gave us tasks with inputs, dependencies, and an owner. In Python, a function is how we draw that boundary explicitly.

Everything the task needs comes in through parameters.
Everything it produces goes out through return.

The map

Four payoffs → four design habits

Pillar 1 of 4

Clarity ↔ explicit function contracts

TAX_RATE = 0.08
prices = [4.50, 3.25, 5.00]

def total():
    print(sum(prices) * (1 + TAX_RATE))

total()   # can't reuse the number

def order_total(prices: list[float],
                tax_rate: float) -> float:
    return sum(prices) * (1 + tax_rate)

total = order_total([4.50, 3.25, 5.00], 0.08)
print(f"${total:.2f}")   # printing is the caller's choice

• Parameters replace hidden globals — every dependency is listed in the signature.
• Return instead of print — the next step (or a test) can use the result.

Pillar 2 of 4

Reuse ↔ local scope and pure functions

def without_missing(values: list) -> list:
    """Return a NEW list with None values removed. Input is unchanged."""
    return [value for value in values if value is not None]

measurements = [2.1, None, 3.4]
cleaned = without_missing(measurements)

print("returned:", cleaned)          # [2.1, 3.4]
print("original:", measurements)     # [2.1, None, 3.4] -- still auditable

• Local scope: temporary names disappear when the function returns.
• Return new objects instead of mutating inputs — the raw data keeps its provenance.
• No unannounced side effects → safe to reuse in any script or parallel pipeline.

Pillar 3 of 4 — at run time

Checking ↔ validating inputs

def mean(values: list[float]) -> float:
    if not isinstance(values, list):
        raise TypeError("values must be a list")
    if len(values) == 0:
        raise ValueError("values must not be empty")
    return sum(values) / len(values)

Fail before computing — so a bad input never becomes a plausible-looking wrong answer downstream.

Pillar 3 of 4 — before you ship

Checking ↔ unit tests

def test_validate_age():
    assert validate_age("42") == 42        # normal
    assert validate_age(" 7 ") == 7        # messy but valid
    assert validate_age("0") == 0          # boundary
    assert validate_age("120") == 120      # boundary
    assert validate_age("121") is None     # just outside
    assert validate_age("abc") is None     # not a number
    assert validate_age(None) is None      # missing

Each function is tested in isolation under normal, boundary, and extreme conditions — exactly the "check each piece" idea from decomposition.

Pillar 4 of 4

Collaboration ↔ contracts others can call

def validate_age(age: object) -> "int | None":
    """Return age as an int, or None when it is
    missing or implausible.

    Args:
        age: A raw age value from the survey,
             typically a string.

    Returns:
        An int between 0 and 120 inclusive,
        or None if the value cannot be used.
    """
    ...

The whole process

Decomposition steps → pipeline design

Putting it together

Design the stages first

def load_survey_data(path: str) -> list[dict]: ...
def validate_age(age: object) -> "int | None": ...
def clean_age_column(rows: list[dict]) -> list[dict]: ...
def summarize_by_region(rows: list[dict]) -> list[dict]: ...
def export_summary(summary: list[dict], path: str) -> None: ...

rows    = load_survey_data("survey.csv")
cleaned = clean_age_column(rows)
summary = summarize_by_region(cleaned)
export_summary(summary, "summary_by_region.csv")

Five named stages. Each one can now be discussed, tested, and replaced on its own — before a single body is written.

Now: hands-on

Over to the notebooks

Folder 04-Functions-Decomposition — same material at three altitudes. Work them in this order:

As you work, ask of every function: is it clear, reusable, checkable, and callable by someone else?

Let's code

Open your first notebook

04-Functions-Decomposition/Examples_of_Python_Functions_orig.ipynb

1. Pull the latest course repository.
2. Open the notebook and run the cells from the top.
3. Stop at each Try it cell — change something and predict the result before you run it.

Reference while you work: Decomposition deck · Decomposition reading