# From Notebook Cells to Functions

A notebook that answers this week's questions has to be edited by hand for next week's file, so the cells you run again and again become functions whose parameters are what changes, such as the file and how many top items to show, and which return their results instead of printing them.

Journeyman · Python · Updated November 19, 2026

By Gregor Dzierzon

## After this lesson you can

- Turn cells you rerun for each new file into a function with parameters for what changes, such as the file to load and how many top items to show
- Return a function's results instead of printing them, so a notebook, a report or a test can use them

## Key takeaways

- A cell you rerun with a new file name or a new number is a function waiting to be written. What changes each time becomes a parameter.
- load_week(path) loads any week, so two weeks can sit side by side without copying a single cell.
- print shows a value on the screen and hands back nothing (None). return hands the value back, so other code can compare it, chart it or test it.
- A number buried in a cell, such as the 3 in head(3), belongs in a parameter with a default, such as n=3.

An analysis that answers a question once is a good start. The trouble starts when the same question comes back every week: the club's attendance every month, a lab's readings every Monday, a store's sales every week. If the answer lives in notebook cells you edit by hand, every week is a fresh chance to change one cell and forget another. Turning those cells into functions is the first step toward a report that rebuilds itself.

The example all chapter is the Greenway Food Truck. Each week a file of its sales arrives in `data/incoming/`, named by the Monday the week starts on: `week-2026-09-07.csv`, `week-2026-09-14.csv` and on, eight weeks so far, about 400 sales each. Each row is one sale: `sold_at` (the date and time), `location` (City Park, Office Row or Stadium, wherever the truck parked that day), `item`, `quantity`, `price` (for one item) and `payment`. Dana, who owns the truck, wants the same numbers every Monday.

## The notebook that worked once

Here's the first week, answered in three cells. (VS Code draws the tables as a grid; here they're shown as text.)

```python
import pandas as pd

week = pd.read_csv("data/incoming/week-2026-09-07.csv")
week[["sold_at", "location", "item", "quantity", "price"]].head(3)
```

```text
            sold_at    location          item  quantity  price
0  2026-09-07 11:01  Office Row    Quesadilla         1    8.5
1  2026-09-07 11:04  Office Row  Loaded Fries         1    6.5
2  2026-09-07 11:06  Office Row  Street Tacos         1    9.0
```

```python
week["total"] = week["quantity"] * week["price"]
print("sales:", week["total"].sum())
print("items sold:", week["quantity"].sum())
```

```text
sales: 4653.5
items sold: 564
```

```python
week.groupby("item")["quantity"].sum().sort_values(ascending=False).head(3)
```

```text
item
Street Tacos    157
Burrito Bowl    127
Quesadilla      102
Name: quantity, dtype: int64
```

It works. Now it's the next Monday. You change the file name in the first cell, run every cell again, and copy the numbers into a message to Dana. Then she asks how this week compares with last week, and the notebook can't say: `week` holds one week at a time. Copying all three cells and renaming `week` to `week2` in each is how mistakes creep in. And the `3` in `head(3)` is a **hard-coded value**: a number typed into the code where nobody will think to look for it when Dana asks for the top five.

## A function for each job

The fix is to notice what changes each week (the file) and what stays the same (everything else). What stays the same becomes the body of a **function**; what changes becomes its **parameter**, the name in the parentheses that gets a new value each time the function is called:

```python
def load_week(path):
    week = pd.read_csv(path)
    week["total"] = week["quantity"] * week["price"]
    return week

first = load_week("data/incoming/week-2026-09-07.csv")
second = load_week("data/incoming/week-2026-09-14.csv")
print("first week:", len(first), "sales")
print("second week:", len(second), "sales")
```

```text
first week: 409 sales
second week: 422 sales
```

Two weeks, side by side, and the loading code was written once. A mistake fixed in `load_week` is fixed for every week.

## Return the answer, don't print it

A cell that ends with `print` is made for your eyes. Turned into a function, it shows the number and hands nothing back:

```python
def show_sales(week):
    print("sales:", week["total"].sum())

result = show_sales(first)
print("result:", result)
```

```text
sales: 4653.5
result: None
```

`None` is Python's word for "nothing here". The number reached the screen, but `result` got nothing, so no other code can use it. **`return`** hands the value back to the line that called the function. That value is the function's **return value**, and it can be stored, compared or tested:

```python
def total_sales(week):
    return week["total"].sum()

change = total_sales(second) - total_sales(first)
print("change:", change)
```

```text
change: 110.5
```

Sales were $110.50 higher in the second week. A function that returns its answer can feed a comparison, a chart, a web page or a test; one that prints can only feed your eyes.

## Numbers that belong in parameters

The `3` from the third cell becomes a parameter too. Giving it a **default value**, `n=3`, keeps the usual case short and lets Dana's top five be `n=5`:

```python
def top_items(week, n=3):
    counts = week.groupby("item")["quantity"].sum()
    return counts.sort_values(ascending=False).head(n)

top_items(second, n=2)
```

```text
item
Burrito Bowl    141
Street Tacos    139
Name: quantity, dtype: int64
```

The headline numbers can come back together as a dictionary, one name for each number. `float()` and `int()` turn pandas' numbers into plain Python ones, so the dictionary prints cleanly:

```python
def summarize(week):
    return {
        "sales": float(week["total"].sum()),
        "items_sold": int(week["quantity"].sum()),
        "best_item": top_items(week, n=1).index[0],
    }

summarize(second)
```

```text
{'sales': 4764.0, 'items_sold': 583, 'best_item': 'Burrito Bowl'}
```

The Burrito Bowl outsold the Street Tacos in the second week, and nothing had to be copied to find out. Any week is now two lines: `load_week` with its file, then `summarize`. The next step is moving these functions out of the notebook into a `.py` file of their own, which *Your Own Modules and Packages* shows and *Using Your Module in a Notebook: autoreload* puts to work.

## Check yourself

2 questions to try on the lesson page.

## So what

When the same question comes back every week, the code that answers it should be written once: functions whose parameters are what changes, and which return their answers so other code can use them.

## Key terms

- [Function](https://www.ask-codey.com/glossary/function-python)
- [Parameter](https://www.ask-codey.com/glossary/parameter)
- [Return Value](https://www.ask-codey.com/glossary/return-value)
- [Default Parameter Value](https://www.ask-codey.com/glossary/default-parameter-value)
- [Hard-Coded Value](https://www.ask-codey.com/glossary/hard-coded-value)

## Related

- [Using Your Module in a Notebook: autoreload](https://www.ask-codey.com/lessons/data-module-in-a-notebook)
- [A Cleaning Function, Step by Step](https://www.ask-codey.com/lessons/pandas-cleaning-function)

Source: https://www.ask-codey.com/lessons/data-cells-to-functions
