Skip to content

Practical Examples of Functions with Different Parameter Types and Return Values in Python

Updated: at 04:34 AM

Functions are one of the fundamental building blocks in Python. They allow you to encapsulate reusable pieces of code and improve modularity and code organization. Defining functions with parameters of different types and return values is a common practice in Python programming.

This guide will provide a practical overview of using functions with different parameter types like positional, keyword, default, variable-length, and more. We will also cover examples of functions that return values of various data types like strings, numbers, lists, dictionaries, etc.

Understanding parameter passing and return values is essential to writing cleaner, more modular Python code. The examples and explanations in this guide will help you learn these function concepts in a hands-on manner. Let’s get started!

Table of Contents

Open Table of Contents

Positional Parameters

Positional parameters allow you to pass arguments to a function based on the order in which they are defined in the function signature.

Here is an example function that calculates the area of a rectangle using two positional parameters - length and breadth:

def calculate_area(length, breadth):
  area = length * breadth
  return area

rectangle_area = calculate_area(4, 5)
# Output: 20

The length and breadth parameters are positional - their order matters during function calls. The values 4 and 5 are passed to length and breadth respectively based on the position.

Positional parameters enable you to write functions that accept inputs in a defined, ordered way.

Keyword Parameters

Keyword parameters allow you to pass arguments to a function by the parameter name, without worrying about the order.

Here’s an example:

def calculate_area(length, breadth):
  area = length * breadth
  return area

# Call function using keyword arguments
rectangle_area = calculate_area(breadth=5, length=4)

# Output: 20

By using keywords length and breadth during the function call, the order does not matter anymore. The values get mapped to the right parameter names.

Keyword parameters provide more readability, especially when a function has many parameters.

Default Parameters

Default parameters allow you to assign a default value to a parameter in the function definition. If no argument is passed for that parameter, the default value is used.

def calculate_area(length, breadth=2):
  area = length * breadth
  return area

# Calculate area with default breadth
rectangle_area = calculate_area(4)
#Output: 8

# Calculate area by passing breadth value
rectangle_area = calculate_area(4, 5)
#Output: 20

By setting breadth to default to 2, we can call the function without passing the breadth value - it will take 2 by default.

Default parameters are useful when a parameter has a standard default that doesn’t need to be passed frequently.

Variable-length Parameters

Unlike positional and default parameters, variable-length parameters allow you to pass an arbitrary number of arguments to a function. The *args syntax is commonly used for this.

def calculate_areas(*lengths, breadth):
  areas = []
  for length in lengths:
    area = length * breadth

  return areas

rect_areas = calculate_areas(2, 4, 5, 6, breadth=5)
# Output: [10, 20, 25, 30]

The *lengths parameter gathers all positional arguments passed during the function call into a tuple named lengths. This allows accepting and looping through any number of length values.

Variable-length parameters provide flexibility when the number of arguments is not fixed beforehand.

Keyword Variable-length Parameters

We can also use the **kwargs syntax to accept an arbitrary number of keyword arguments.

def print_student_data(**kwargs):
  for key, value in kwargs.items():
    print(f"{key} = {value}")

print_student_data(name="John", age=20, hobbies=["football", "chess", "hiking"])

# Output:
# name = John
# age = 20
# hobbies = ['football', 'chess', 'hiking']

The **kwargs collects all keyword arguments passed to the function into a dictionary. We can loop through and print each key: value pair.

This technique is common when writing flexible functions that accept variable user-supplied data.

Parameter Unpacking

Parameter unpacking allows you to unpack iterables like lists, tuples, and dictionaries into separate function parameters using the * and ** operators.

For example:

coordinates = [(2, 3), (5, 7), (9, 1)]

for x, y in coordinates:
  print(f"X: {x}, Y: {y}")

# Output:
# X: 2, Y: 3
# X: 5, Y: 7
# X: 9, Y: 1

Here, the (x, y) tuple gets unpacked into separate x and y parameters for each iteration.

We can similarly unpack dictionaries:

def display_student(**kwargs):
  print(f"Name: {kwargs['name']}")
  print(f"Age: {kwargs['age']}")
  print(f"Major: {kwargs['major']}")

student = {'name': 'John', 'age': 20, 'major': 'Computer Science'}

# Output:
# Name: John
# Age: 20
# Major: Computer Science

The **student unpacks the dictionary into separate keyword arguments.

Unpacking iterables allows passing them easily as function arguments.

Returning Values

The return statement is used to return a value from the function back to the caller. The returned value can be stored in a variable or used in an expression.

Here are some examples of functions returning commonly used data types:

Returning a string

def format_name(first, last):
  full_name = f"{first} {last}"
  return full_name

name = format_name("John", "Doe")
# Output: John Doe

Returning a number

from math import pi

def calculate_circle_area(radius):
  area = pi * radius * radius
  return area

circle_area = calculate_circle_area(5)
print(round(circle_area, 2))
# Output: 78.54

Returning a list

def get_multiples(number, limit):
  multiples = []
  for i in range(1, limit+1):
    multiples.append(number * i)
  return multiples

nums = get_multiples(7, 5)
# Output: [7, 14, 21, 28, 35]

Returning a dictionary

def create_student(name, age, major):
  student = {
    'name': name,
    'age': age,
    'major': major
  return student

john = create_student('John Doe', 20, 'Computer Science')
# Output: {'name': 'John Doe', 'age': 20, 'major': 'Computer Science'}

The return value gets assigned to the name, circle_area, nums, john variables after function calls.

Return values allow the caller to further operate on the output of a function.

Real-World Examples

Let’s now look at some real-world examples of using functions with different parameter types and return values.

A BMI Calculator

Here is a calculate_bmi function that uses positional and keyword arguments along with default values:

def calculate_bmi(weight, height, metric=True):
  if metric:
    bmi = weight / (height ** 2)
    bmi = 703 * (weight / (height ** 2))

  return bmi

# Metric BMI
metric_bmi = calculate_bmi(weight=70, height=1.69)
# Output: 24.49

# Imperial BMI
imperial_bmi = calculate_bmi(weight=150, height=5.6, metric=False)
# Output: 26.88073394495413

Finding the Highest Number

This function uses *args to accept any number of arguments and returns the highest:

def find_max(*nums):
  highest = float("-inf")
  for num in nums:
    if num > highest:
      highest = num
  return highest

max_num = find_max(4, 55, 2, -9, 100)
# Output: 100

Parsing Key-Value Pairs

We can parse a string of key-value pairs into a dictionary using **kwargs:

def parse_kv_pairs(**kwargs):
  return kwargs

pairs = "name=John,age=20,major=Computer Science"
kv_dict = parse_kv_pairs(**pairs.split(','))

# Output: {'name': 'John', 'age': '20', 'major': 'Computer Science'}

The real-world examples highlight how various parameter techniques and return values help write reusable and practical functions.


To recap, here are some key takeaways:

Learning function parameters and return values is crucial for expertly organizing, reusing, and structuring code in Python. This guide covered practical examples of different parameter types and return value usage. Use these learnings to write clean, readable, and maintainable functions in your own Python code.