Functions and a Mini Project

What a function is

You've been using functions since the first lesson: print(), len(), round(), sum(). A function is a named block of code that does one job. You can also write your own, so that a calculation you need often is written once and reused:

• Less repetition: fix a bug in one place, not ten.
• Clearer code: vat(price) says what it does.
• Easier testing: check the function on its own.

Defining and calling a function

Welcome to CloudTech Academy
Welcome to CloudTech Academy

• def starts the definition, followed by the function's name, brackets and a colon.
• The indented block is the body: the code that runs when the function is called.
• Defining a function doesn't run it. Calling it, greet(), does, as many times as you like.

Name functions like variables (lowercase with underscores), ideally with a verb: calculate_vat, print_report.

Parameters and arguments

A function becomes useful when you can give it inputs. Parameters are the names in the definition; arguments are the values you pass when you call it:

Welcome, Adaeze!
Welcome, Musa!

With several parameters, arguments are matched in order:

Tobi is in 200 level

return: sending a result back

print shows a value on screen. return sends it back to the code that called the function, so it can be stored and used:

3000.0
43000.0

return also ends the function: any lines after it in the same block don't run. A grading function can return as soon as it knows the answer:

A
F

print or return?

Most functions that calculate should return. A function with no return gives back None.

Default values

Give a parameter a default with = in the definition. If the caller leaves it out, the default is used:

43000.0
44000.0

Parameters with defaults must come after those without.

Keyword arguments

You can name arguments when you call a function, so their order doesn't matter and the call explains itself:

22000.0
22000.0

Returning several values

Return several values separated by commas, and unpack them into several variables:

45 81 63.8

(Python packs the values into a tuple and unpacks them for you.)

Scope: variables inside functions

Variables created inside a function exist only inside it. They're local:

200

Outside, result doesn't exist: print(result) would give a NameError. That's a good thing: functions don't accidentally overwrite each other's variables. Pass values in as arguments and get them out with return.

Docstrings

A docstring is a description in triple quotes on the first line of the body. It tells other people (and you, later) what the function does:

₦12,500
Format an amount as naira with thousands separators, e.g. ₦12,500.

In Colab, typing naira( also shows the docstring in a pop-up, and help(naira) prints it with the function's details.

Functions that use functions

Functions can call other functions, so you build bigger jobs out of small, tested pieces:

₦53,750

Mini project: a monthly budget tracker

Put everything together: variables, a dictionary, functions, a loop, maths, f-strings and decisions. Copy this into Colab and run it:

Monthly spending
Food          ₦28,000  50.0%
Transport     ₦12,500  22.3%
Data           ₦6,000  10.7%
Books          ₦4,500   8.0%
Other          ₦5,000   8.9%
------------------------------
Total         ₦56,000
You have ₦4,000 left.

Read it line by line. You've met every piece in this course: the spending dictionary, the naira function, the loop over .items(), the percentage maths, the aligned f-strings and the final if.

When it goes wrong

def total_cost(price, quantity):
    price * quantity

print(total_cost(500, 4))

None

Forgetting return. The function calculated the value, then threw it away. Add return price * quantity.

def greet(name):
    print(f"Hello {name}")

greet()

TypeError: greet() missing 1 required positional argument: 'name'

Missing an argument. The function needs a name; give it one, or a default (name="friend").

greet("Ada")

def greet(name):
    print(f"Hello {name}")

NameError: name 'greet' is not defined

Calling before defining. Python reads top to bottom, so define functions before you call them (in Colab, run the cell with the def first).

Show it off

Save your notebook, then in Colab choose File → Save a copy in GitHub to put it in a repository (see the Git & GitHub course). It's a small but real project for your portfolio.

Summary

Try it

Run the budget tracker as it is in the lesson, then answer these about its numbers.