Python Functions Exercises: 18 Coding Problems with Solutions

A Python function is a block of code that carries out a specific task. Functions make your code reusable, so you can run the same logic whenever you need it without writing it multiple times.

This article provides 18 Python functions practice questions that focus entirely defining functions, calling them, using arguments, working with inner functions, and exploring built-in functions

Each coding challenge includes a Practice Problem, Hint, Solution code, and detailed Explanation, ensuring you don’t just copy code, but genuinely practice and understand how and why it works.

• All solutions have been fully tested on Python 3.
• Interactive Learning: Use our Online Code Editor to solve these exercises in real time.

If you have other solutions, please share them in the comments to help fellow developers.

Exercise 1. Create a Function with Parameters

Practice Problem: Write a function called demo() that accepts two parameters: a name and an age. The function should print these values directly to the console.

Exercise Purpose: This is the foundation of modular programming. It teaches how to pass data from the main program into a function’s local scope, allowing the same logic to be reused with different datasets.

Given Input:

name = "Kelly"
age = 25Code language: Python (python)

Expected Output: Kelly 25

def demo(name, age):
    # Print the values passed into the function
    print(name, age)

# Call the function with specific arguments
demo("Kelly", 25)Code language: Python (python)

Exercise 2. Variable Length of Arguments (*args)

Practice Problem: Create a function func1() such that it can accept a variable number of arguments and print all of them. Whether you pass two numbers or five, the function should handle them all without error.

Exercise Purpose: In real-world programming (like logging or mathematical operations), you often don’t know how many inputs a user will provide. Using *args allows your function to be flexible and “future-proof.”

Read: variable length of arguments in functions

Given Input:

Call 1: func1(20, 40, 60)
Call 2: func1(80, 100)Code language: Python (python)

Expected Output:

Printing values:
20
40
60
Printing values:
80
100

def func1(*args):
    print("Printing values:")
    for i in args:
        print(i)

# Calling with 3 arguments
func1(20, 40, 60)

# Calling with 2 arguments
func1(80, 100)Code language: Python (python)

Exercise 3. Return Multiple Values from a Function

Practice Problem: Write a function calculation() that accepts two variables and calculates both addition and subtraction. The function must return both results in a single return statement.

Exercise Purpose: Unlike many languages (like C or Java) where a function typically returns only one value, Python allows “Tuple Unpacking.” This makes it incredibly efficient to retrieve multiple pieces of processed data at once.

Given Input:

a = 40
b = 10Code language: Python (python)

Expected Output: 50, 30

def calculation(a, b):
    addition = a + b
    subtraction = a - b
    # Return multiple values separated by comma
    return addition, subtraction

# Get results in a single line
res = calculation(40, 10)
print(res)Code language: Python (python)

Exercise 4. Function with Default Argument

Practice Problem: Create a function show_employee() that accepts an employee’s name and salary. If the salary is not provided in the function call, the function should automatically assign a default value of 9000.

Exercise Purpose: Default arguments are essential for creating APIs or functions where certain settings are “standard.” It allows the function to be called with less information, making the code cleaner and reducing errors when data is missing.

Given Input:

Case 1: name="Ben", salary=12000
Case 2: name="Jessa" (salary missing)Code language: Python (python)

Expected Output:

Name: Ben salary: 12000
Name: Jessa salary: 9000

def show_employee(name, salary=9000):
    print("Name:", name, "salary:", salary)

# Calling with both arguments
show_employee("Ben", 12000)

# Calling with default value
show_employee("Jessa")Code language: Python (python)

Exercise 5. Create an Inner Function

Practice Problem: Create an outer function that accepts two parameters, a and b. Inside, create an inner function that calculates the addition of a and b. The outer function should then add 5 to that sum and return the final result.

Exercise Purpose: This introduces “Nested Functions” and “Encapsulation.” Inner functions are hidden from the global scope, meaning they can only be accessed by the outer function. This is the first step toward understanding Python Decorators and Closures.

Given Input:

a = 5
b = 10Code language: Python (python)

Expected Output: 20

def outer_func(a, b):
    # Inner function
    def addition(a, b):
        return a + b

    # Call inner function and add 5 to the result
    add = addition(a, b)
    return add + 5

result = outer_func(5, 10)
print(result)Code language: Python (python)

Exercise 6. Create a Recursive Function

Practice Problem: Write a recursive function addition() that calculates the sum of numbers from 0 to 10. A recursive function is a function that calls itself to solve smaller instances of the same problem.

Exercise Purpose: Recursion is a fundamental computer science concept used to solve complex problems by breaking them into simpler sub-problems. It is essential for understanding algorithms like tree traversals and sorting. This exercise focuses on the “Base Case” (when to stop) and the “Recursive Case” (how to progress).

Given Input: num = 10

Expected Output: 55

def addition(num):
    if num:
        # Recursive Case: add current num to the result of addition(num - 1)
        return num + addition(num - 1)
    else:
        # Base Case: stop at 0
        return 0

res = addition(10)
print(res)Code language: Python (python)

Exercise 7. Assign a Different Name to Function and Call It

Practice Problem: Assign a different name to the function display_student(name, age) and call it using the new name. For example, assign it to a variable called show_student.

Exercise Purpose: In Python, functions are “first-class objects.” This means they can be treated like any other variable—passed as arguments, returned from other functions, or renamed. This is useful for aliasing long function names or passing logic into different modules.

Given Input:

def display_student(name, age):
    print(name, age)Code language: Python (python)

Expected Output:

Emma 26

def display_student(name, age):
    print(name, age)

# Assign the function object to a new variable name
show_student = display_student

# Call the function using the new name
show_student("Emma", 26)Code language: Python (python)

Exercise 8. Generate a List of Even Numbers (Range Function)

Practice Problem: Create a function that generates a list of all even numbers between 4 and 30.

Exercise Purpose: This exercise teaches the use of the range() function and how to convert range objects into lists. Understanding how to generate sequences of data is vital for data processing and automated loops.

Expected Output:

[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

def even_numbers():
    # range(start, stop, step)
    # Use 30 as stop to exclude 30, or 31 to include it if required
    return list(range(4, 30, 2))

print(even_numbers())Code language: Python (python)

Exercise 9. Find the Largest Item in a List

Practice Problem: Create a function that takes a list of numbers as input and returns the largest item from that list without using the built-in max() function (to practice manual logic).

Exercise Purpose: Finding a maximum value is one of the most common tasks in programming (e.g., finding the highest price, the top score, or the oldest record). Implementing this manually builds an understanding of “Accumulator Patterns”—keeping track of a state while iterating through data.

Given Input: x = [4, 6, 8, 24, 12, 2]

Expected Output: 24

def find_largest(list_input):
    # Assume the first item is the largest
    largest = list_input[0]
    for num in list_input:
        if num > largest:
            largest = num
    return largest

x = [4, 6, 8, 24, 12, 2]
print(find_largest(x))Code language: Python (python)

Exercise 10. Call Function using Positional and Keyword Arguments

Practice Problem: Define a function describe_pet(animal_type, pet_name) that prints a description of a pet. Call this function twice: once using positional arguments and once using keyword arguments.

Exercise Purpose: This exercise demonstrates the flexibility of Python’s calling conventions. Positional arguments rely on the order of the data, while Keyword arguments use the parameter names to ensure data goes to the right place regardless of order.

Given Input:

# Call 1 (Positional): "hamster", "Harry"
# Call 2 (Keyword): animal_type="dog", pet_name="Willie"Code language: Python (python)

Expected Output:

I have a hamster.
My hamster's name is Harry.

I have a dog.
My dog's name is Willie.

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name}.\n")

# Positional arguments: Order matters
describe_pet("hamster", "Harry")

# Keyword arguments: Order does not matter
describe_pet(pet_name="Willie", animal_type="dog")Code language: Python (python)

Exercise 11. Create a Function with Keyword Arguments

Practice Problem: Create a function print_info(**kwargs) that accepts an arbitrary number of keyword arguments and prints the key-value pairs.

Exercise Purpose: While *args handles a list of values, **kwargs (keyword arguments) handles named data as a dictionary. This is standard practice in Python for functions that need to handle optional configuration settings or metadata.

The exercise requires you to create a function that can accept any number of keyword arguments. A keyword argument is where you specify the name of the argument along with its value (e.g., name="Alice", age=30). Inside the function, you need to access these arguments and print them in a key-value format.

Given Input: print_info(name="Alice", age=30, city="New York")

Expected Output:

name: Alice
age: 30
city: New York

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

# Calling with three different pieces of named data
print_info(name="Alice", age=30, city="New York")Code language: Python (python)

Exercise 12. Modifying Global Variables

Practice Problem: Define a global variable global_var = 10. Write a function that successfully changes the value of this global variable to 20.

Exercise Purpose: Normally, variables created inside a function are “Local”—they disappear when the function ends. To modify a variable that lives outside the function, you must use the global keyword. This exercise teaches you how to manage data persistence across different parts of your program.

Given Input: global_var = 10

Expected Output:

Initial: 10
Modified: 20

global_var = 10

def modify_variable():
    global global_var  # Access the variable from the global scope
    global_var = 20

print("Initial:", global_var)
modify_variable()
print("Modified:", global_var)Code language: Python (python)

Exercise 13. Recursive Factorial (Non-Negative Integers)

Practice Problem: Write a recursive function to calculate the factorial of a non-negative integer.

Exercise Purpose: Factorials (5! = 5 * 4 * 3 * 2 * 1) are the textbook example of recursion. This exercise reinforces the concept of a “Base Case” (stopping at 1) to prevent the function from running forever and crashing the memory stack.

Given Input: number = 5

Expected Output: The factorial of 5 is 120

def recur_factorial(n):
    if n <= 1:
        return 1
    else:
        return n * recur_factorial(n - 1)

num = 5
print(f"The factorial of {num} is {recur_factorial(num)}")Code language: Python (python)

Exercise 14. Create a Lambda Function to Square a Number

Practice Problem: Use the lambda keyword to create a small, anonymous function that takes one number and returns its square.

Exercise Purpose: Sometimes you need a simple function for a split second (like when sorting a list or filtering data) and don’t want to write a full def block. Lambda functions are “one-liners” that make your code more concise and “Pythonic.”

Given Input: number = 5

Expected Output: 25

# Define the lambda and assign it to a variable
square_num = lambda x: x * x

# Call the lambda just like a regular function
result = square_num(5)
print(result)Code language: Python (python)

Exercise 15. Filter a List Using Lambda and filter()

Practice Problem: Use the filter() function combined with a lambda to extract all even numbers from the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

Exercise Purpose: The filter() function is a specialized tool for “weeding out” data. Instead of writing a bulky for loop with an if statement, filter() allows you to define a “rule” (the lambda) and apply it to an entire collection. This is a core concept in data science for cleaning datasets.

Given Input: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Expected Output: [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# filter(function, iterable)
even_nums = list(filter(lambda x: x % 2 == 0, numbers))

print(even_nums)Code language: Python (python)

Exercise 16. Transform a List Using Lambda and map()

Practice Problem: Use the map() function and a lambda to double every element in the list [1, 2, 3, 4, 5].

Exercise Purpose: While filter removes items, map transforms them. It applies a specific operation to every single item in a list simultaneously. It’s like an assembly line where every item gets the same “upgrade” as it passes through.

Given Input: numbers = [1, 2, 3, 4, 5]

Expected Output: [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5]

# map(function, iterable)
doubled_numbers = list(map(lambda x: x * 2, numbers))

print(doubled_numbers)Code language: Python (python)

Exercise 17. Sort Complex Data with sorted() and Lambda

Practice Problem: You have a list of tuples representing students and their grades: [("Alice", 88), ("Bob", 75), ("Charlie", 92)]. Use the sorted() function and a lambda to sort this list based on the grades (the second element) in ascending order.

Exercise Purpose: Real-world data is rarely just a simple list of numbers; it’s usually “messy” objects or tuples. This exercise teaches you how to tell Python exactly which part of a complex object it should use for sorting.

Given Input: students = [("Alice", 88), ("Bob", 75), ("Charlie", 92)]

Expected Output: [('Bob', 75), ('Alice', 88), ('Charlie', 92)]

students = [("Alice", 88), ("Bob", 75), ("Charlie", 92)]

# Sort using the second element (index 1) of each tuple
sorted_students = sorted(students, key=lambda student: student[1])

print(sorted_students)Code language: Python (python)

Exercise 18. Create a Higher-Order Function

Practice Problem: Write a function apply_operation(func, x, y) that takes another function (func) and two numbers (x, y) as arguments. It should return the result of calling func(x, y). Show how this works by passing in different operations like addition and multiplication.

Exercise Purpose: This is where you truly become a Python “Power User.” A Higher-Order Function is a function that treats other functions as parameters. This allows you to write extremely generic code that can do anything depending on what logic you “plug into” it.

Given Input:

# Function 1: add(a, b)
# Function 2: multiply(a, b)
# Values: 5, 3Code language: Python (python)

Expected Output:

Addition Result: 8
Multiplication Result: 15

def apply_operation(func, x, y):
    return func(x, y)

# Define simple operations
def add(a, b): return a + b
def multiply(a, b): return a * b

# Use the higher-order function
res_add = apply_operation(add, 5, 3)
res_mult = apply_operation(multiply, 5, 3)

print("Addition Result:", res_add)
print("Multiplication Result:", res_mult)Code language: Python (python)