Contents

• Overview
• Goals of Writing Functions
• Types of Functions
• Coding Standards for Functions
• Creating & Calling a Void Function
• Creating & Calling a Value Function
• Execution Path
• Practice Problems

Overview

So far, our programs have contained all their code in one overall block in one Python (.py) file. That's ok when programs are small; however as programming problems grow more complex, trying to manage hundreds or thousands of lines of code in one large block becomes challenging. Also, more extensive programs tend to have segments that are repeated unnecessarily. One way we can improve this is through writing functions.

We can visualize the difference between the programs we've been writing with all of the code in one place versus programs that are made more modular by writing and using functions:

We have already used some functions, some built into Python, such as print(), len(), etc. These functions contain code to perform a task, such as printing to the screen or returning the length of an object. We don't know how they work internally and don't need to know, we just learn how to use them and interact with them, and that's it. We can write and use functions like any built-in functions.

When writing functions, there are specific goals we try to achieve, as outlined here:

In Python, there are different types of functions. As mentioned above, Python has built-in functions available for our use and provide many features to simplify our programming tasks. We can call these functions from anywhere in our code. Calling a function means instructing the computer to run (execute) that function. As Python programmers, in addition to using the built-in functions, we can also create Void and Value-Return Functions to achieve the goals outlined above. These two types of functions provide different approaches to modular code.

Void Functions allow us to write code that performs a specific task and then terminates, with no return interaction between the Void Function and the calling program. An example of a void function might be a function that prints a standardized header at the top of all output for a program. Calling that function would cause the header to print, and there is nothing to return to the calling program.

Value-Return Functions allow us to write code that accepts values (arguments), performs actions on those values, and can return resulting values to the calling program. An example of a value-return function might be a function that calculates employee bonuses based on a set of values our calling program passes to the function; the function performs the calculations based on business rules and then returns a result (the bonus amount) to the calling program.

We will explore both Void Functions and Value-Return Functions throughout the rest of this page.

There are some rules in Python for naming functions and also there are common conventions that many developers follow to improve consistency. The rules are similar to naming variables, for example, function names cannot include spaces, the first character of the name must be an alphabetic letter or an underscore (_), and the rest of the name of a function can only contain alphabetic characters, digits 0 thru 9 or underscores, function names are case-sensitive and you cannot name functions the same as any Python keyword.

Common conventions for naming functions, like variables, suggest using descriptive names that relate to the purpose of the function. For example, naming a function x, while valid from the rules perspective, is not descriptive. Instead, use a name that helps the reader identify the purpose of the function, like print_header, calculate_interest, update_tax_record, etc.

Creating a Void Function

The general form for creating a Void Function is as follows:

def function_name([var_1, var_2, ... var_n]):
    statement_1
    statement_2
    .
    .
    statement_n

Code Details:

• Code Line 1: The def keyword indicates the definition of a function.
  • The function_name must follow the coding conventions outlined above.
  • Function names must include parenthesis ( ) at the end of the function name.
  • Calling programs can pass values (arguments) to a Void Function. When a Void Function can receive arguments, we list variables inside the parentheses of the function signature as placeholders for those values. Inside the function, those variables become local variables the function can use for its tasks.
  • Function signature lines must end with a colon to indicate the end of the function name definition.
• Code Lines 2 thru 6: Void Functions can contain any number of Python code statements.
• There are return values in Void Functions.

Calling a Void Function

The general form for calling a Void Function is as follows:

function_name()

Code Details:

• Code Line 1: To call a Void Function simply use its name with empty parentheses.

Example 1

In this example, we write a function to print a report header. This is a simple example of a Void Function that we could use any number of times in a program without writing the code for the header more than once. It is also an excellent example of how to make something that will remain consistent, that is, it will always print the same header information in the same format.

# Functions
def print_header():
    print("\n" + "-" * 80)
    print("S u m m a r y  R e p o r t")
    print("\n" + "-" * 80)

# Main (calling) Program
print_header()

Output

----------------------------------------
S u m m a r y  R e p o r t
----------------------------------------

Code & Output Details:

• Code Line 2: Function definition (def) of a Void Function called print_header().
• Code Lines 3 thru 5: Lines of code inside the Void Function.
• Code Line 8: In the Main Program, the function is called by the function name and a set of parentheses.

Functions create modular units of code separate from the main program, as depicted in the diagram below. The print_header() function is called from the main program, its code is executed, and program flow returns to the main program on the next line after the print_header() function call.

Example 2

In this example, we write a flexible function that will print dashes to create a horizontal line. The number of dashes is adjustable by using a parameter specified in the function signature, so the programmer can call this function and limit the number of dashes they want to print on the screen.

# Functions
def print_line(num_dashes):
    print("-" * num_dashes)

# Main (calling) Program
print_line(10)
print_line(20)
print_line(40)
print_line(80)

Output

----------
--------------------
----------------------------------------
--------------------------------------------------------------------------------

Code & Output Details:

• Code Line 2: Function definition (def) of a Void Function called print_line, which also has a parameter (num_dashes).
• Code Line 3: The only line of code inside the function. This line uses the value passed to the function to determine how many times to print the dash character to create a horizontal line.
• Code Lines 6 thru 9: Demonstrate several calls to the print_line function. Note the different values passed to the function. From the perspective of the calling program, these values are called arguments while they are called parameters in the called function itself.

Example 3

This example is an enhancement of Example 2 above. This function also prints characters to the screen to make a horizontal line and the number of characters that are printed is based on a parameter provided by the calling program. The enhancement is that in addition to the number of character parameters, we've added a second parameter to allow the calling program to specify what character to print and how many times to print that character. Compare the code for this example and Example 2 to see how we have enhanced this function.

# Functions
def print_line(print_char, num_chars):
    print(print_char * num_chars)

# Main (calling) Program
print_line("-", 10)
print_line("~", 20)
print_line(".", 40)
print_line("=", 80)

Output

----------
~~~~~~~~~~~~~~~~~~~~
........................................
================================================================================

Code & Output Details:

• Code Line 2: Function definition (def) of a Void Function called print_line, which has two parameters print_char and num_dashes.
• Code Line 3: The only line of code inside the function. This line uses the two-parameter values passed to the function to determine what character to print and how many times to print it to create a horizontal line.
• Code Lines 6 thru 9: Demonstrate several calls to the print_line function. Note the different values passed to the function.

Example 4

This example combines our print header and print lines functions above to demonstrate that we can call functions from main programs and other functions. This means functions can call functions. In this example, our main program calls the print_header() function, which calls the print_line() function. This is a good example of the use of functions, that is, it demonstrates that many functions each doing their tasks can be combined to complete more complex work. This concept is widely used in software development.

# Functions
def print_line(print_char, num_chars):
    print(print_char * num_chars)

def print_header():
    print()
    print_line("-", 40)
    print("S u m m a r y  R e p o r t")
    print_line("-", 40)
    print()

# Main (calling) Program
print_header()

Output

----------------------------------------
S u m m a r y  R e p o r t
----------------------------------------

Functions can be called from the main program or any other function as well, as shown in this example:

Code & Output Details:

• Code Line 2: Function definition (def) of a Void Function called print_line, which has two parameters print_char and num_dashes.
• Code Line 3: The only line of code inside the function. This line uses the two-parameter values passed to the function to determine what character to print and how many times to print it to create a horizontal line.
• Code Line 5: Function definition (def) of a Void Function called print_header, which has no parameters.
• Code Lines 6 thru 10: This is the same function as shown in Example 1 above, however this time it uses the print_line function to produce the lines of the report header. This demonstrates functions calling other functions.
• Code Line 13: Demonstrates calling the print_header() function from the main program. Notice that in this program example the print_line function is never called by the main program.

Creating a Value Function

The general form for creating a Value Function is as follows. Notice that it looks the same as the Void Function with the addition of a return statement.

def function_name([var_1, var_2, ... var_n]):
    statement_1
    statement_2
    .
    .
    statement_n
    return return_var

Code Details:

• Code Line 1: The def keyword indicates the definition of a function.
  • The function_name must follow the coding conventions outlined above.
  • Function names must include parenthesis ( ) at the end of the function name.
  • Calling programs can pass optional values (arguments) to a Void Function. When a Void Function can receive arguments, we list variables inside the parentheses of the function signature as placeholders for those values. Inside the function, those variables become local variables the function can use for its tasks.
  • Function signature lines must end with a colon to indicate the end of the function name definition.
• Code Lines 2 thru 6: Void Functions can contain any number of Python code statements.
• Value Functions include a return statement, which returns some result arrived at inside the function.

Calling a Value Function

Here are a couple of examples of general forms for calling a Value Function:

General Form 1:

[local_var] = function_name([var_1, var_2, ... var_n])

General Form 1 Code Details:

• Code Line 1: Calling a Value Function is similar to calling a Void Function, however since a Value Function will return a value to the calling program we need to capture that return value. Most commonly we do this by setting a variable equal to the function call. When the function finishes and returns a value, that value is stored in the variable. We can then use that variable as needed.

General Form 2:

print(["string"] + [cast_function(]function_name([var_1, var_2, ... var_n])[)] + ["string"])

General Form 2 Code Details:

• Code Line 1: This is an example of calling a Value Function inside a print statement. Since a Value Function returns a value, we can place the call in a print statement, and the function return value will be printed the same as if it were a local variable or literal value.

Example 1

In this example, we write a Value Function to calculate a simple math formula. This is an example of a Value Function that we could use any number of times in a program without writing the code for the calculation more than once. The function will return the result of the calculation to the calling program, which we can then use as needed.

# Function
def calc_formula(n):
    # Formula: n * n**3
    ret_value = n * n**3
    return ret_value

# Main (calling) Program
formula_value = calc_formula(4)
print("The result of the formula "
"calculation is " + str(formula_value))
print("We could have put the function "
"call directly in a print statement "
"like this: " + str(calc_formula(4)))

Output

The result of the formula calculation is 256
We could have put the function call directly in a print statement like this: 256

Code & Output Details:

• Code Line 2: Function definition (def) of a Value Function called calc_formula().
• Code Lines 3 thru 5: Lines of code inside the Void Function.
• Code Line 8: In the Main Program, the function is called by the function name with an argument inside the function's set of parentheses. The argument is a literal value, but it could be a variable or expression.
• The value passed to the function is used in the calculation and the return statement returns the result to the calling program.

Example 2

In this example, we combine three Value Functions to format several strings together and return a single formatted string to the calling program. Notice that the three functions are format_phone(), print_line() and customer_card(). The customer_card() function is the primary function and the only one called from the main program. The other two functions are called by the customer_card() function.

See the Execution Flow section below for more information about how the execution of this program works. Also, work through the Code & Output Details below for a line-by-line explanation of the program and its output.

# Functions
def format_phone(phone_no):
    formatted_phone_no = ""
    if len(phone_no) != 10:
        formatted_phone_no = "Invalid Phone Number"
    else:
        formatted_phone_no = "(" + phone_no[:3] + ")" + phone_no[3:6] + "-" + phone_no[6:]
    return formatted_phone_no


def create_line(print_char, num_chars):
    return "\n" + (print_char * num_chars) + "\n"


def customer_card(fn, ln, addr1, addr2, city, st, zip, phone):
    card = ""
    card = card + create_line("-", 40)
    card = card + fn + " " + ln + "\n"
    card = card + addr1 + "\n"
    if addr2 != "":
        card = card + addr2 + "\n"
    card = card + city + ", " + st + " " + zip + "\n"
    card = card + format_phone(phone)
    card = card + create_line("-", 40)
    return card


# Main Program
first_name = input("Enter customer first name: ")
last_name = input("Enter customer last name: ")
address1 = input("Enter customer Address Line 1: ")
address2 = input("Enter customer Address Line 2: ")
city = input("Enter customer City: ")
state = input("Enter customer State: ")
zip_code = input("Enter customer Zip Code: ")
phone_number = input("Enter customer phone number (digits only): ")

print(customer_card(first_name, last_name, address1, address2, city, state, zip_code, phone_number))

Sample Run & Output

Enter your first name: Bob
Enter customer last name: Smith
Enter customer Address Line 1: 1234 Nowhere Street
Enter customer Address Line 2: Apt 9999999999
Enter customer City: Noplace
Enter customer State: UT
Enter customer Zip Code: 84999
Enter customer phone number (digits only): 1112223333

----------------------------------------
Bob Smith
1234 Nowhere Street
Apt 9999999999
Noplace, UT 84999
(111)222-3333
----------------------------------------

Code & Output Details:

• Code Lines 2 thru 8:
  • Code Line 2: Defines a Value Function with one parameter (phone_no), which is expected to be in the form of 10 digits of a standard U.S. phone number (like 9999999999). The function uses these parameters to format those digits into the standardized phone format of (999)999-9999.
  • Code Line 3: We set a return value variable for the formatted phone number.
  • Code Line 4: This is a simplified example of the phone number parameter validation. In a full implementation, we want to expand the validation to ensure all of the digits are numeric and that the phone number is valid in terms of the telephone industry standards.
  • Code Line 5: This is an example of how we might handle invalid phone numbers and set our return value variable to a message indicating the number is not valid.
  • Code Line 6 & 7: The else: portion of our decision statement is where we convert the validated phone number parameter and use slicing to format the phone number.
  • Code Line 8: We use the return statement to return our return value variable.
• Code Lines 11 & 12:
  • Code Line 11: Defines a Value Function with two parameters (print_char and num_chars), which are expected to be a character or string to repeat and a number to indicate how many times to repeat the specified character or string.
  • Code Line 12: The return statement returns a string created based on the two-parameter values. Note that this is similar but different from the print_line() function we've seen before that prints the line. In this example, this function creates the line and returns it as a string, instead of printing it. The calling function then uses it as needed, so printing the line built in this function is left to the calling function to handle.
• Code Lines 15 thru 25:
  • Code Line 15: Defines a Value Function with eight parameters (fn, ln, addr1, addr2, city, st, zip, phone), which are expected to be character strings. We will use these parameter values to create the customer card in the form:
    
    -------------------------
    FirstName LastName
    Address Line 1
    Address Line 2
    City, State zip
    (999)999-9999
    -------------------------
    
    
  • Code Line 16: We set a return value variable (card) to hold the formatted card as one string (which will include \n sequences as well).
  • Code Line 17: This line builds the return value variable string. Note that this line calls the create_line function to get a line based on the specified character and number of characters.
  • Code Line 18: This line continues to build the card string by concatenating the first name (fn) and last name (ln) parameter variables to the card string. Note the use of the \n escape sequence that we include in the string so that when it is returned to the calling program it will be formatted as we want i
  • Code Line 19: Concatenates address line 1 to the card variable.
  • Code Line 20: This line is an example of how we might selectively use the parameter values that were passed to a function. In this example, not all addresses have a second address line, so we only want to concatenate addr2 to the card if there is a value in that parameter variable.
  • Code Line 21: If there is content in the addr2 variable, we concatenate it to the card variable.
  • Code Line 22: Concatenates the city, state, and zip code parameters onto the card variable.
  • Code Line 23: Calls the format_phone function passing the phone parameter variable to it. See the description of that function above.
  • Code Line 24: Calls the create_line function to get a line based on the specified character and number of characters.
  • Code Line 25: We use the return statement to return our card variable.
• Code Lines 29 thru 38:
  • Code Lines 29 thru 36: These lines prompt the user for each customer data value.
  • Code Line 38: We use a print statement and call the customer_card() function and pass the 8 customer data values collected above as arguments.

As a reminder, the execution path is the path through a program that the Python interpreter takes based on our code. So, a program with just a set of print statements, with no decisions or loops, would be a straight execution path from line 1 through the last line of the program. As our programs become more complex, with decisions and loops, and now with functions, it can become increasingly challenging to understand the execution path.

The following list outlines the execution path of Example 2 above. Study the list of steps and the subsequent diagram of the code, along with the code, sample run, output, and code details provided above.

• The execution path in the Example 2 program starts in the main program (labeled (1) in the diagram below). There are eight input statements, one after another, which each executes in order from top to bottom.
• Then, still in the main program, the print statement executes (2), which contains a call to the Value Function named customer_card(). That function call also passes the 8 variables that were created with the input statements above.
• The execution path leaves the main program and is transferred to the customer_card() function (3).
• Inside the customer_card() function, execution starts with the initialization of the variable card.
• The next line calls the Value Function called create_line() and passes two arguments to it.
• The execution path leaves the customer_card() function and is transferred to the create_line() function (4).
• The create_line() function returns a string constructed based on the two parameters passed into the function().
• The execution path leaves the create_line() function and returns to the customer_card() function.
• The next 5 lines of the customer_card() function continue building the card string based on the parameters passed to it initially.
• The next line calls the format_phone() function, which changes the format of the digits-only phone number from the parameter into a formatted version of the phone number string. The call to the format_phone() function includes the phone variable as an argument.
• The execution path leaves the customer_card() function again, this time it is transferred to the format_phone() function.
• The format_phone() function checks if the phone number is valid and if so, it formats the number using string slicing and concatenation.
• The execution path leaves the format_phone() and returns to the customer_card() function.
• The next line in the customer_card() function calls the create_line() function again.
• The execution path leaves the customer_card() function and is transferred to the create_line() function (4).
• The create_line() function returns a string constructed based on the two parameters passed into the function().
• The execution path leaves the create_line() function and returns to the customer_card() function.
• The last line of the customer_card() is the return statement that returns execution to the calling program, the main program.
• When the execution path returns to the main program, where we started, the print statement can be completed by printing the card that was returned to the main program and the print statement. Since the card variable contains the result of the concatenations and function calls, the print statement can print it now.

The diagram below can be confusing at first. Still, if you follow the code details above while reading through the execution path steps above, the diagram depicts how the execution path operates in this example.