Functions versus procedures

What you'll learn

• What a subprogram is, and why programmers split code into smaller parts.
• The difference between a function and a procedure.
• How to write Python 3 functions that return values.
• How to write Python 3 procedures that do not return values.

Why subprograms matter

A subprogram is a named block of code that performs a smaller task inside a larger program.

Instead of writing one long program from top to bottom, programmers split it into subprograms. This makes code easier to:

• read
• test
• reuse
• fix
• update

For example, a quiz program might have separate subprograms to:

• display the menu
• ask a question
• calculate the score
• show the final result

Calling a subprogram

To call a subprogram means to run it by writing its name, followed by brackets.

In Python:

display_menu()

The brackets are still needed even if no data is being passed in.

Parameters and arguments

Subprograms can be given data to work with.

A parameter is a variable listed in the subprogram definition. It acts like a placeholder for data that will be supplied later.

An argument is the actual value passed into the subprogram when it is called.

def greet_user(name):      # name is a parameter
    print("Hello", name)

greet_user("Amina")        # "Amina" is an argument

The key difference: functions return, procedures do not

The main difference is about whether the subprogram sends a value back to the part of the program that called it.

A function must return a value.

A procedure does not return a value.

Functions

A function is a subprogram that returns a value to the code that called it.

In Python, a function is written using def, just like other subprograms, but it uses return to send a value back.

Function with no parameters

A function does not have to receive data.

def get_welcome_message():
    return "Welcome to the quiz!"

message = get_welcome_message()
print(message)

Here:

• get_welcome_message has no parameters
• it returns the string "Welcome to the quiz!"
• the returned value is stored in message

Function with parameters

A function can also take parameters.

def calculate_total_score(score1, score2):
    total = score1 + score2
    return total

final_score = calculate_total_score(8, 7)
print(final_score)

Here:

• score1 and score2 are parameters
• 8 and 7 are arguments
• the function returns the total
• the returned value is assigned to final_score

def calculate_rectangle_area(length, width):
    area = length * width
    return area

rectangle_area = calculate_rectangle_area(6, 4)
print(rectangle_area)

The return statement

The return statement sends a value back from a function to the line of code that called it.

For example:

def double_number(number):
    return number * 2

answer = double_number(5)

The function call double_number(5) is replaced by the returned value, so answer stores 10.

Procedures

A procedure is a subprogram that performs a task but does not return a value.

In Python, procedures are also written using def, but they do not return a useful value.

Procedure with no parameters

A procedure can perform an action without receiving any data.

def display_menu():
    print("1. Start quiz")
    print("2. View scores")
    print("3. Quit")

display_menu()

This procedure displays text on the screen. It does not calculate and return a value.

Procedure with parameters

A procedure can take parameters if it needs data to carry out its action.

def display_score(name, score):
    print(name, "scored", score)

display_score("Amina", 15)

Here, the procedure receives name and score, then prints a message.

def display_welcome(username):
    print("Welcome,", username)

display_welcome("Sam")

Comparing functions and procedures

Choosing between a function and a procedure

When deciding which one to write, ask:

• Does the subprogram need to give a value back?
• Will the calling code need to store, compare, print, or calculate with the result?
• Or does the subprogram simply perform an action?

Use a function for a result.

Use a procedure for an action.

def calculate_average(score1, score2):
    average = (score1 + score2) / 2
    return average

def display_certificate(name):
    print("Certificate awarded to", name)

average_score = calculate_average(10, 8)
print("Average score:", average_score)
display_certificate("Amina")

Using functions and procedures together

Real programs often use both.

A function might calculate a value, then a procedure might display it.

def calculate_discounted_price(price, discount):
    discounted_price = price - discount
    return discounted_price

def display_price(price):
    print("Final price:", price)

final_price = calculate_discounted_price(20, 5)
display_price(final_price)

In this example:

• calculate_discounted_price is a function because it returns a value
• display_price is a procedure because it only prints a value
• final_price stores the returned value from the function

def add_bonus(score):
    new_score = score + 5
    return new_score

def display_result(result):
    print("Result:", result)

player_score = add_bonus(12)
display_result(player_score)

Writing clear subprograms

Use meaningful names so the purpose of each subprogram is obvious.

Good function names often describe the value being calculated:

calculate_total()
get_username()
find_largest_number()

Good procedure names often describe the action being performed:

display_menu()
print_receipt()
save_score()

Also remember that Python uses indentation to show which lines belong inside the subprogram.

def display_message():
    print("This line is inside the procedure")

print("This line is outside the procedure")