Python Functions: Mastering Arguments and Return Values

Learn Python @

Functions are the backbone of Python programming, and understanding how to work with arguments and return values is crucial. In this comprehensive article, we will delve into the world of Python functions, exploring the different types of arguments and how to use return values effectively. Real-world examples with output are provided to illustrate each concept.

Understanding Arguments

In Python, arguments are values that are passed into a function when it’s called. Functions can accept different types of arguments, including positional arguments, keyword arguments, and default arguments.

Positional Arguments

Positional arguments are the most common type and are matched to function parameters based on their order. Here’s an example:

def add(a, b):
    result = a + b
    return result
sum_result = add(3, 5)
print(f"The sum is {sum_result}")


The sum is 8

In this example, 3 and 5 are passed as positional arguments, and they match the a and b parameters of the add function.

Keyword Arguments

Keyword arguments are passed with the parameter names, allowing you to specify values for specific parameters regardless of their order. Here’s an example:

def divide(dividend, divisor):
    result = dividend / divisor
    return result
quotient = divide(divisor=2, dividend=10)
print(f"The quotient is {quotient}")


The quotient is 5.0

Here, we use keyword arguments to specify which value should be assigned to dividend and divisor.

Default Arguments

Default arguments have preset values and are used when no argument is provided for that parameter. Example:

def greet(name="Guest"):
    message = f"Hello, {name}!"
    return message
greeting = greet()


Hello, Guest!

In this case, since no argument is provided, the default value “Guest” is used for the name parameter.

Understanding Return Values

Return values are the values that a function sends back to the caller. In Python, functions can return one or multiple values.

Returning a Single Value

def add(a, b):
    result = a + b
    return result
sum_result = add(3, 5)
print(f"The sum is {sum_result}")

In this case, the calculate function returns multiple values as a tuple, and we can access each value by its index.


Let’s explore real-world examples that showcase the use of different argument types and return values in Python functions.

Example 1: Calculate Average

def calculate_average(*numbers):
    total = sum(numbers)
    average = total / len(numbers)
    return average
avg = calculate_average(5, 10, 15, 20)
print(f"The average is {avg:.2f}")


The average is 12.50

In this example, we use *numbers to accept any number of positional arguments and calculate their average.

Example 2: Find Smallest and Largest

def find_smallest_largest(numbers):
    smallest = min(numbers)
    largest = max(numbers)
    return smallest, largest
values = [17, 42, 8, 95, 23]
min_value, max_value = find_smallest_largest(values)
print(f"Smallest: {min_value}, Largest: {max_value}")


Smallest: 8, Largest: 95

Here, we return both the smallest and largest values from a list.

Example 3: Convert Temperature

def convert_temperature(celsius):
    fahrenheit = (celsius * 9/5) + 32
    kelvin = celsius + 273.15
    return fahrenheit, kelvin
celsius_temperature = 25
fahrenheit_temp, kelvin_temp = convert_temperature(celsius_temperature)
print(f"{celsius_temperature}°C is equal to {fahrenheit_temp:.2f}°F and {kelvin_temp:.2f}K")
25°C is equal to 77.00°F and 298.15K

In this example, we return both Fahrenheit and Kelvin equivalents of a Celsius temperature.

Author: user