Defining and Calling Functions with Parameters and Return Values

The Power of Reusable Code

The main reason to use functions is to keep your code "DRY" – Don't Repeat Yourself. By defining a piece of logic once, you can reuse it anywhere, and if you need to make a change, you only have to update it in one place.

The following video from Corey Schafer's beginner series provides an excellent demonstration of this principle.

This idea of packaging functionality is the foundation of modern software. For your chatbot, you might have functions like get_ticket_status, format_user_greeting, or log_conversation_history.

Defining and Calling a Simple Function

Creating a function in Python is straightforward. You use the def keyword, followed by the function's name, a pair of parentheses (), and a colon :. The code that belongs to the function is indented on the following lines.

Let's look at the basic syntax. This video from Programming with Mosh clearly explains how to define and call a function.

As you saw, the basic structure looks like this:

# Function definition
def greet_user():
    print("Hi there!")
    print("Welcome aboard.")

# Calling the function
print("Process starting...")
greet_user()
print("Process finished.")

When you run this script, Python first defines greet_user. Then it prints "Process starting...", executes the two print statements inside greet_user(), and finally prints "Process finished.".

Passing Information to Functions: Parameters and Arguments

Our greet_user function is a bit rigid; it does the same thing every time. To make functions more flexible, we can pass information into them. We do this by defining parameters in the function's parentheses. When we call the function, we provide actual values, called arguments, for those parameters.

It's a common point of confusion, but the distinction is simple:

• Parameters are the variables listed inside the parentheses in the function definition. They are placeholders.
• Arguments are the actual values that are sent to the function when it is called.

This next clip from Programming with Mosh makes this distinction crystal clear.

Here is an example relevant to our chatbot project:

# 'first_name' and 'ticket_id' are parameters
def generate_support_greeting(first_name, ticket_id):
    print(f"Hello, {first_name}. Your support ticket ID is {ticket_id}.")

# "Alice" and 12345 are arguments
generate_support_greeting("Alice", 12345) 

When calling functions with multiple arguments, Python matches them by their position. In the example above, "Alice" is assigned to first_name (position 1) and 12345 to ticket_id (position 2). You can also use keyword arguments to make your code more readable by explicitly naming the parameters, which allows you to pass them in any order.

# Using keyword arguments - the order doesn't matter
generate_support_greeting(ticket_id=54321, first_name="Bob")

Getting a Result: The return Statement

So far, our functions have only performed an action (printing text). This is useful, but often we want a function to perform a calculation and give us back a result that we can use elsewhere in our program. To do this, we use the return statement.

There are two main types of functions:

1. Functions that perform a task (e.g., printing to the screen, saving a file).
2. Functions that calculate and return a value.

The get_ticket_status function in a support bot should return the status, not print it. This allows the main program to decide what to do with that status—display it to the user, check if it's 'closed', etc.

This article from 365 Data Science provides an excellent conceptual breakdown of print versus return.

When a function doesn't have an explicit return statement, it implicitly returns a special value called None.

Let's build a function that returns a value.

def format_customer_name(first_name, last_name):
    # This function formats a name and returns the full name as a string.
    # The calling code can then decide what to do with it.
    full_name = f"{first_name.capitalize()} {last_name.capitalize()}"
    return full_name

# Call the function and store the returned value in a variable
customer_name = format_customer_name("john", "smith")

# Now we can use the returned value
print(f"Welcome, {customer_name}!")

Because format_customer_name returns a string, you can treat the function call format_customer_name("john", "smith") as if it were a string itself. This is a powerful concept.

Practice Exercise

Time to put these concepts together. Let's create a couple of functions that would be useful for a support chatbot.

Create a new Python file named support_functions.py.

1. Define a function create_welcome_message(name, ticket_id):

   • It should accept two parameters: name (a string) and ticket_id (a number).
   • It should return a single formatted string: f"Welcome, {name}! Your ticket number is {ticket_id}."

2. Define a function estimate_resolution_time(priority):

   • It should accept one parameter: priority (a string, e.g., 'High', 'Medium', or 'Low').
   • Inside the function, use an if/elif/else block to check the priority:
     • If priority is 'High', return the string "Estimated resolution: 1-2 hours".
     • If priority is 'Medium', return "Estimated resolution: 2-4 hours".
     • For any other priority (like 'Low'), return "Estimated resolution: within 24 hours".

3. Call your functions:

   • In the main part of your script (after the function definitions), call create_welcome_message with a sample name and ticket ID. Store the result in a variable and print it.
   • Call estimate_resolution_time for each of the three priority levels ('High', 'Medium', 'Low') and print each result.

A template to get you started:

def create_welcome_message(name, ticket_id):
    # Your code here to create and return the message string
    pass # Remove this 'pass' statement

def estimate_resolution_time(priority):
    # Your if/elif/else logic here to return the correct time estimate
    pass # Remove this 'pass' statement

# --- Main part of the script ---

# Call create_welcome_message and print the result
welcome_text = create_welcome_message("Jane Doe", 98765)
print(welcome_text)

# Call estimate_resolution_time for each priority and print the results
high_priority_time = estimate_resolution_time('High')
print(f"For High priority: {high_priority_time}")

medium_priority_time = estimate_resolution_time('Medium')
print(f"For Medium priority: {medium_priority_time}")

low_priority_time = estimate_resolution_time('Low')
print(f"For Low priority: {low_priority_time}")

Conclusion

You've just learned one of the most important concepts in programming. Functions allow you to write cleaner, more organized, and more reusable code. By breaking down a large problem into smaller, manageable functions, you make your code easier to write, read, and debug.

Here are the key takeaways:

• Functions package code into reusable blocks, following the DRY (Don't Repeat Yourself) principle.
• You define a function with def and call it using its name followed by parentheses ().
• Parameters are the placeholders in a function's definition, while arguments are the actual values you pass when calling it.
• The return statement sends a value back from a function, allowing you to use the result in other parts of your code.
• Giving your functions clear, descriptive names (like calculate_tax instead of ct) makes your code vastly more understandable.

In the next lesson, we'll look at how to handle collections of data. You've been working with single values like numbers and strings, but what if you need to manage a list of open support tickets or a sequence of messages in a conversation? For that, we'll need Python lists, a versatile tool for storing ordered data.