Functions

You've already used plenty of functions — print(), len(), type() — without writing one yourself. In this lesson you'll learn to define your own: how inputs (parameters) and outputs (return values) work, why return is not the same as print, and how small, well-named functions turn a messy notebook into readable analysis.

Functions you already know

Python ships with dozens of built-in functions. Each one takes input, does a job, and hands back output:

Python — runs in your browser

Run

numbers = [3, 2, 4, 5] print(sum(numbers)) # add everything up print(len(numbers)) # count the items print(max(numbers)) # largest value print(round(3.14159, 2))# round to 2 decimals print(pow(3, 3)) # 3 to the power of 3

That input → work → output pattern is the whole idea. Writing your own function just means defining what happens in the "work" step.

Defining your own: def and return

The anatomy of a function definition:

• def starts the definition, followed by the name and parentheses
• names inside the parentheses are parameters — placeholders for inputs
• the indented body is the work
• return sends a value back to whoever called the function

Python — runs in your browser

Run

def calculate_mean(numbers): total = sum(numbers) count = len(numbers) return total / count # The values you pass in are called ARGUMENTS student1 = [90, 80, 80, 60] student2 = [65, 50, 80, 60] print(calculate_mean(student1)) print(calculate_mean(student2)) print(calculate_mean([1, 2, 3, 4]))

One definition, unlimited reuses — that's the payoff. A quick vocabulary note: parameters are the names in the definition (numbers); arguments are the actual values you pass when calling (student1).

return vs print

This distinction confuses every beginner, so let's nail it down. print displays a value on screen; return hands the value back so the rest of your program can use it. A function that only prints gives you nothing to work with:

Python — runs in your browser

Run

def mean_that_prints(numbers): print(sum(numbers) / len(numbers)) # displays, returns nothing def mean_that_returns(numbers): return sum(numbers) / len(numbers) # hands the value back a = mean_that_prints([1, 2, 3]) b = mean_that_returns([1, 2, 3]) print(a) # None - there was nothing to catch! print(b * 10) # a real number we can keep computing with

A function without a return statement implicitly returns None. Rule of thumb: compute with return, display with print — and do the printing at the call site, not inside the function.

Default parameters and keyword arguments

Sometimes a parameter has a sensible usual value. Give it a default in the definition and callers can omit it. Here's a function that computes the n-th term of an arithmetic sequence (first term a, common difference d, term formula a + (n - 1) * d):

Python — runs in your browser

Run

def nth_term(sequence, n=10): a = sequence[0] d = sequence[1] - sequence[0] return a + (n - 1) * d print(nth_term([1, 2, 3, 4])) # n falls back to the default 10 print(nth_term([1, 2, 3, 4], 100)) # positional argument overrides it print(nth_term([1, 11, 21], n=300)) # keyword argument: name it explicitly

Keyword arguments (n=300) name the parameter at the call site. They make calls self-documenting and let you skip over defaults you don't want to change — you'll see them everywhere in pandas and scikit-learn, where functions have ten or more optional parameters.

Returning multiple values

return can send back several values separated by commas — Python bundles them into a tuple, and you can unpack them into separate variables on the receiving end:

Python — runs in your browser

Run

def describe(numbers): mean = sum(numbers) / len(numbers) lowest = min(numbers) highest = max(numbers) return mean, lowest, highest scores = [65, 50, 80, 60, 95] stats = describe(scores) print(stats) # it's really one tuple avg, lo, hi = describe(scores) # unpack into three names print(f"mean={avg:.1f}, min={lo}, max={hi}")

Scope: what happens in a function stays in a function

Variables created inside a function are local — they exist only while the function runs, then vanish. This is a feature: functions can't accidentally trample your notebook's variables, and vice versa:

Python — runs in your browser

Run

total = 1000 # a "global" variable, outside any function def add_fee(amount): fee = 50 # local: exists only inside this call total = amount + fee # a NEW local total, not the outer one return total print(add_fee(200)) print(total) # still 1000 - the function never touched it try: print(fee) # locals are gone after the call except NameError as e: print("Error:", e)

Functions can read outer variables, but relying on that makes code fragile. Best practice: pass everything a function needs in as parameters, and get everything out via return.

Docstrings: explain your function

A string right under the def line is a docstring — documentation baked into the function itself. Tools like help(), Jupyter's Shift+Tab, and your future teammates all read it:

Python — runs in your browser

Run

def trimmed_sum(numbers, trim=0): """Sum a list after dropping trim items from each end. numbers: list of numbers trim: how many items to drop from the front AND the back """ kept = numbers[trim:len(numbers) - trim] return sum(kept) print(trimmed_sum([1, 2, 3, 4, 100], trim=1)) help(trimmed_sum)

Lambda: tiny anonymous functions

A lambda is a one-expression function with no name and no def. These two definitions behave identically:

Python — runs in your browser

Run

def calculate_mean(numbers): return sum(numbers) / len(numbers) calculate_mean_v2 = lambda numbers: sum(numbers) / len(numbers) print(calculate_mean([1, 2, 3, 4])) print(calculate_mean_v2([1, 2, 3, 4])) # The real use case: quick throwaway logic passed to another function people = [("Rama", 25), ("Budi", 30), ("Teguh", 28)] by_age = sorted(people, key=lambda person: person[1]) print(by_age)

For anything you'd call by name, prefer def — it gets a docstring and a readable name in error messages. Lambdas shine as short one-off arguments to functions like sorted, and later to pandas' .apply().

Check your understanding

5 questions · free

1. Q1.What is the difference between a parameter and an argument?

   AThey are exact synonymsBParameters are the names in the def line; arguments are the actual values passed when callingCArguments are optional, parameters are requiredDParameters only exist in lambdas

2. Q2.A function ends with print(result) instead of return result. What does x = my_func() store in x?

   AThe printed valueBAn empty stringCNoneDIt raises an error

3. Q3.Given def nth_term(seq, n=10), which call is INVALID?

   Anth_term([1, 2, 3])Bnth_term([1, 2, 3], 50)Cnth_term(n=50, seq=[1, 2, 3])Dnth_term(n=50)

4. Q4.What does return mean, lowest, highest actually return?

   AThree separate return values sent one at a timeBA single tuple containing the three valuesCOnly the last value, highestDA dictionary with three keys

5. Q5.A variable created inside a function body is...

   Avisible everywhere in the notebook after the callBlocal - it exists only during that function callCautomatically returnedDshared between all functions

Exercise: Write a trimmed mean function

A trimmed mean is an average computed after cutting off the extremes — a robust statistic that outliers can't drag around. Write trimmed_mean(numbers, trim=0) that drops trim items from the front and back of the list, then averages what remains. For example, with [1, 2, 3, 4, 10] and trim=1 you average [2, 3, 4] and get 3.0. Verify: trimmed_mean([1, 2, 3, 4, 10]) → 4.0, trimmed_mean([1, 2, 3, 4, 10], 1) → 3.0, and trimmed_mean([1, 2, 3, 4, 4, 4, 4, 4, 10], 2) → 3.8. Include a docstring.

Next up: conditionals — teaching your code to make decisions with if, elif, and else.