In Python, there are different types of functions. As mentioned above, Python has built-in functions that are available for our use that 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 of our own 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 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 are followed by many developers 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 (_), 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, suggests 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 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.

function_name()

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

# 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
----------------------------------------

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.

• 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
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 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.

# 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 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.

# 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 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 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 that is arrived at inside the function.

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

• 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.

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

• Code Line 1: This is an example of calling a Value Function inside of 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.

# 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)))

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

• 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. In this example, 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.

# 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))

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 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). These parameters are used inside the function to format those digits into the standardized phone format of (999)999-9999.
  • Code Line 3: We set a return value variable to hold the formatted phone number.
  • Code Line 4: This is a simplified example validation of the phone number parameter. In a full implementation, we would 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, that is, 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: We use the return statement to return 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 of the line created 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 starts to build 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 ot 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, then we concatenate it to the card variable.
  • Code Line 22: Concatenates the city, state, and zip code parameter variables 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 of the customer data values.
  • 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, execution path is the path through a program that the Python interpreter takes based on our code. So, for example, 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 8 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 originally.
• 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 very 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 complete by printing the card which is what 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 simply print it now.