3.mp4

Functions including parameters and returns

So far, you’ve used and created simple functions that carry out one task in isolation. This type of function is often referred to as a procedure or subroutine. These functions might accept parameters, but they do not return any information to the program that called them.

In this step, you’ll learn more about these two aspects of functions — parameters and return values — and how they make functions incredibly useful.

Just like in the previous step, I’d like you to imagine the function as a machine carrying out a computational task when switched on or called. A simple function or procedure is like a basic machine: it does one fixed task, like a kettle. I turn it on, it does the task, and I receive no real feedback from the machine. Every time this function is called, it carries out its task.

Parameters = inputs

Most everyday machines allow you some control over what the machine does: the temperature of an oven, the speed of a fan, or the amount of water a washing machine should use. Without these controllable elements you’d need a different machine with a different setting for every job, for example a different oven for each temperature you want to cook at.

It’s a similar story with programming. Whilst simple functions allow a programmer to package up code and reuse it, without controllable elements they would need a different function for every scenario, even if they are very similar.

Rather than reinvent the wheel every time, a programmer will create a function that can apply to multiple situations and be tailored to each one, using inputs or parameters.

For example, here’s a pair of functions that each load some map data from a file. As you can see, they have very similar actions: they each open a text file in r (read) mode, and add the contents of the file to a list.

map1 = [] #Creates an empty list

#Here I define the function

def load_level_1():

with open("map1.txt",mode="r") as file:

for line in file:

map1.append(line.strip().split(","))

map2 = [] #Creates an empty list

#Here I define the function

def load_level_2():

with open("map2.txt",mode="r") as file:

for line in file:

map2.append(line.strip().split(","))

Such duplication in programs can be avoided by writing a single function with parameters, which can then be used to load either map data file. Here the parameters have been given descriptive names (file and map), but you can call them anything you like. The names don’t need to relate to anything in the rest of the program: they only exist within the scope of this function.

map1 = []

map2 = []

def load_level(file,map):

with open(file,mode="r") as file:

for line in file:

map.append(line.strip().split(","))

This function can then be called, and will use whichever map file and variable you ask for:

load_level("map1.txt",map1)

Return values = outputs

A real-life machine, like the functions you have seen, has consequences or side effects: it washes clothes, cooks food, or boils water, etc. However, unlike the functions you’ve seen so far, it may also provide some feedback or information as output. Machines might beep, display some text, or sound an alarm, for example. A function can also provide information, simply by returning some data to the program that called it.

When programming, you will often need to get data back from a function, either simply to confirm that the function has done its job, or to get some richer data that the function has calculated. This is done via the return command, which “returns” data back to the process that called the function. In the simple example below, the function isWeekday checks whether the date provided is a weekday.

from datetime import datetime

def isWeekday(mydate):

day = mydate.weekday() #Get the number of the day of the week - Monday = 0, Tuesday = 1 etc.

if day < 5:

return True

else:

return False

# Calls the function providing a date

workday = isWeekday(datetime.now()) #Call the isWeekday function with today's date, store the returned data in a variable "workday".

Once defined, a function like isWeekday, which returns a True or False (Boolean) value, can be used in conditional statements:

if isWeekday(datetime.now()):

print("It is a week day")

Of course, functions aren’t just limited to returning Boolean values. They can return any variable, list, or other object. For example, the following function asks the user to input some numbers, and then returns the same numbers as a list.

def getNums(size):

nums = []

for x in range(size):

num = int(input("Enter a whole number: "))

nums.append(num)

return nums

mynums = getNums(10)

You can even return several values from one function and then store these in separate variables:

def get_profile():

firstname = input("What is your first name? ")

lastname = input("What is your last name? ")

age = int(input("What is your age? "))

return firstname, lastname, age

fname,lname,user_age = get_profile()

In this example, I have used different variable names when calling the function from the variable names inside the function. While this is good practice, as it helps the programmer distinguish between them, it is not actually necessary in Python. In other words, I could have called the function like this:

firstname,lastname,age = get_profile()

Variables defined inside a function, like firstname, exist in isolation from other variables and only whilst the function is run. This is their scope. Variables defined in the main program, rather than within functions, exist for the duration of the program and are said to be global in scope. If you want a function to have access to variables outside its own scope, best practice would be to add them as parameters to the function:

am = "Good Morning"

pm = "Good Evening"

def get_profile(msg):

print (msg)

firstname = input("What is your first name? ")

lastname = input("What is your last name? ")

age = int(input("What is your age? "))

return firstname, lastname, age

#Function called passing in variable from global scope

fname,lname,user_age = get_profile(am)

Combining functions

Once you’ve got to grips with creating your own functions, you can begin to add more structure to your programs, taking each component of the program and creating a reusable function from it.

For example, imagine you wanted to create a program that could send Morse code messages by blinking a single LED. This problem can be broken down into a hierarchy of functions.

The highest or most abstract function might be morseMessage(), whose job is to take a given string and turn it into a Morse sequence. To do this, it will call charLookup() for each character in turn, and then the relevant dot, dash, and pause functions.
The charLookup() function looks up a given character and determines the correct sequence of dots, dashes and pauses for that character. This sequence is returned as a string to the morseMessage() function.
The dot(),dash(), and pause() functions receive no input, and simply turn the LED on and off for the appropriate lengths of time to represent dots and dashes.

You could represent this as a diagram, like this:

An example of the full code for a Morse code generator can be found here.

Over to you

Can you create your own functions that use parameters and return values? Pick one of these challenges to complete (they are listed in order of “difficulty”):

Create a function that accepts the dimensions of a triangle and returns its area (if you did the triangle task in the last step you can just adapt it). Note: The formula for the area of a triangle is base*height/2
Create a function that accepts a string and returns the same string reversed.
Create a function that simulates a single six-sided dice being rolled n times and returns the number of occurrences of each number.
- This is a more complicated program which will require you to import the random library, and to use the randint() function to get the number. If you are not comfortable with this, choose one of the other two challenges.

<- previous

next ->