Python Functions Exercises

Why do we use functions in Python programs?

To make code reusable, modular, and easier to maintain

To store large amounts of data efficiently

To speed up execution by avoiding loops

To replace the need for variables in a program

Functions are mainly used to make programs more reusable, organized, and easier to maintain. Instead of repeating the same code multiple times, we can place it inside a function and call it whenever required.

Option 1: Correct – Functions improve readability, maintainability, and reduce duplication.
Option 2: Incorrect – Data storage is handled by data structures like lists, sets, or dictionaries, not functions.
Option 3: Incorrect – Functions don’t inherently speed up execution; they organize logic.
Option 4: Incorrect – Variables are still needed inside or outside functions.

Key takeaway: Functions help us write clean, structured, and reusable code.

Which of the following is the correct way to define a Python function that prints `"Hello World"`?

function hello():
    print("Hello World")

def hello:
    print("Hello World")

def hello():
    echo "Hello World"

def hello():
    print("Hello World")

This question tests the basic syntax of defining a function in Python:

Option 1: Incorrect – function is not a Python keyword.
Option 2: Incorrect – Missing parentheses () in function definition.
Option 3: Incorrect – Python uses print(), not echo.
Option 4: Correct – def keyword, parentheses, and print() used correctly.

Key takeaway: Always use def function_name(): to define a function in Python, and ensure parentheses are included even if there are no parameters.

Which of the following is the correct way to call a Python function named `greet`?

call greet()

greet

greet[]

greet()

This question checks the correct syntax for calling a Python function:

Option 1: Incorrect – call is not used in Python.
Option 2: Incorrect – This only references the function object, it does not execute it.
Option 3: Incorrect – Square brackets [] are used for lists or indexing, not function calls.
Option 4: Correct – Parentheses () are required to call the function.

Key takeaway: Always use parentheses when calling a function in Python, even if it does not take any parameters.

Which statement correctly describes the syntax for defining a Python function?

Use the keyword func followed by the function name and parentheses

Use the keyword define followed by the function name and a colon

Use the keyword def followed by the function name and parentheses

Use the function name directly without any keyword

In Python, functions are defined using the keyword def, followed by the function name and parentheses. The parentheses may include parameters if needed, and the function body is indented.

Option 1: Incorrect – func is not a Python keyword.
Option 2: Incorrect – define is not used in Python.
Option 3: Correct – def function_name(): is the proper syntax.
Option 4: Incorrect – Function names alone without def cannot define a function.

Key takeaway: Always start a function definition in Python with the def keyword followed by parentheses, even if there are no parameters.

Which of the following functions correctly returns the value `10`?

def get_value():
    print(10)

def get_value():
    return "10"

def get_value():
    10

def get_value():
    return 10

This question tests understanding of returning values from functions in Python:

Option 1: Incorrect – print(10) outputs the value but does not return it.
Option 2: Incorrect – Returns a string "10" instead of integer 10.
Option 3: Incorrect – Writing 10 alone inside a function does nothing; it must use return.
Option 4: Correct – return 10 correctly returns the integer value 10.

Key takeaway: Use return inside a function to send a value back to the caller. print() only displays it on the screen and does not return it.

Which of the following calls to the function `greet(name, age)` correctly uses keyword arguments?

greet("Alice", 25)

greet(name="Alice", age=25)

greet("Alice", age=25)

greet(age=25, "Alice")

This question focuses on the difference between positional and keyword arguments:

Option 1: Incorrect – Uses positional arguments only.
Option 2: Correct – Both arguments are passed by name, so order does not matter.
Option 3: Partially correct – First argument is positional, second is keyword. Python allows it, but fully keyword form is Option 2.
Option 4: Incorrect – Positional argument cannot follow a keyword argument; this causes a syntax error.

Key takeaway: Keyword arguments allow passing values by name, improving readability and avoiding errors related to argument order.

Which of the following function definitions correctly uses a default parameter value for `greeting`?

def greet(name, greeting):
    print(greeting, name)

def greet(name, greeting="Hello"):
    print(name, greeting)

def greet(name="John", greeting):
    print(greeting, name)

def greet(name, greeting="Hello"):
    print(greeting, name)

This question tests understanding of default parameter values in Python functions:

Option 1: Incorrect – No default value is provided for greeting.
Option 2: Incorrect – The order of print arguments is reversed (minor issue) and can be confusing. Prefer standard format.
Option 3: Incorrect – Non-default parameter greeting cannot follow a parameter with a default value name="John".
Option 4: Correct – Default value is assigned properly, and positional arguments come before default parameters.

Key takeaway: In Python, parameters with default values should come after positional parameters. Default values are used when arguments are not provided by the caller.

Which function definition correctly accepts a variable number of positional arguments?

def add_numbers(*args):
    return sum(args)

def add_numbers(args):
    return sum(args)

def add_numbers(**args):
    return sum(args)

def add_numbers(*kwargs):
    return sum(kwargs)

This question tests understanding of variable-length positional arguments using *args:

Option 1: Correct – The *args syntax allows the function to accept any number of positional arguments as a tuple.
Option 2: Incorrect – Only accepts a single argument; cannot handle multiple numbers directly.
Option 3: Incorrect – **args is used for keyword arguments, not positional arguments.
Option 4: Incorrect – *kwargs is invalid; kwargs conventionally refers to keyword arguments (**kwargs).

Key takeaway: Use *args when you want a function to accept an arbitrary number of positional arguments. It is stored as a tuple inside the function.

Which function definition correctly accepts a variable number of keyword arguments?

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

def display_info(*kwargs):
    for key, value in kwargs.items():
        print(key, value)

def display_info(kwargs):
    for key, value in kwargs.items():
        print(key, value)

def display_info(*args):
    for key, value in args.items():
        print(key, value)

This question tests understanding of variable-length keyword arguments using **kwargs:

Option 1: Correct – The **kwargs syntax collects all keyword arguments into a dictionary, allowing iteration with items().
Option 2: Incorrect – *kwargs collects positional arguments, not keyword arguments.
Option 3: Incorrect – Only accepts a single dictionary argument; does not accept arbitrary keyword arguments directly.
Option 4: Incorrect – *args collects positional arguments; using items() on it will cause an error.

Key takeaway: Use **kwargs when you want a function to accept an arbitrary number of keyword arguments. They are stored as a dictionary inside the function.

Which of the following calls correctly uses positional, default, and keyword arguments for the function:

def greet(name, age=25, city="Unknown"):
    print(f"{name}, {age}, {city}")

greet(age=30, "Alice")

greet("Alice", city="New York", 30)

greet("Alice", age=30, city="New York")

greet(name="Alice", 30, city="New York")

This question tests understanding of mixing positional, default, and keyword arguments in Python functions:

Option 1: Incorrect – Positional argument "Alice" cannot follow a keyword argument age=30; this causes a syntax error.
Option 2: Incorrect – Positional argument 30 cannot follow keyword argument city="New York".
Option 3: Correct – Positional argument "Alice" comes first, then keyword arguments age=30 and city="New York".
Option 4: Incorrect – Positional argument 30 cannot follow keyword argument name="Alice".

Key takeaway: In Python, positional arguments must come first, followed by default or keyword arguments. Mixing them correctly avoids syntax errors and ensures clarity.

Which of the following functions correctly returns multiple values that can be unpacked?

def get_stats():
    return [10, 20, 30]
a, b, c = get_stats()

def get_stats():
    return 10, 20, 30
a, b, c = get_stats()

def get_stats():
    print(10, 20, 30)
a, b, c = get_stats()

def get_stats():
    return (10)
a, b, c = get_stats()

This question tests understanding of returning multiple values and tuple unpacking in Python:

Option 1: Incorrect – Returns a list, which cannot be unpacked into multiple variables without indexing.
Option 2: Correct – Returns a tuple implicitly (10, 20, 30) that can be unpacked into a, b, c.
Option 3: Incorrect – print() outputs values but does not return them, so unpacking fails.
Option 4: Incorrect – Returns a single integer (10), cannot unpack into three variables.

Key takeaway: Python functions can return multiple values as tuples. These tuples can be unpacked into separate variables directly for easy access.

Which of the following examples correctly demonstrates modifying a global variable inside a function?

count = 0
def increment():
    count += 1
increment()

count = 0
def increment():
    count = count + 1
increment()

count = 0
def increment():
    local count = count + 1
increment()

count = 0
def increment():
    global count
    count += 1
increment()

This question tests understanding of local vs global scope in Python functions:

Option 1: Incorrect – Modifying a global variable without global causes an UnboundLocalError.
Option 2: Incorrect – Same issue as Option 1; assignment creates a local variable by default.
Option 3: Incorrect – local is not a Python keyword; this will cause a syntax error.
Option 4: Correct – Using global count allows the function to modify the global variable.

Key takeaway: To modify a global variable inside a function, you must declare it as global. Otherwise, Python treats the variable as local within the function.

Which of the following correctly defines a nested function and calls it from the outer function?

def outer():
    def inner():
        print("Hello")
inner()

def outer():
    print("Hello")
    def inner():
        print("Inner")
outer.inner()

def outer():
    def inner():
        print("Inner")
    return inner
outer()

def outer():
    def inner():
        print("Inner")
    inner()
outer()

This question tests understanding of nested functions in Python:

Option 1: Incorrect – inner() is called outside outer(), so it is not in scope.
Option 2: Incorrect – Calling outer.inner() is invalid in Python; nested functions are not attributes.
Option 3: Incorrect – Returns the inner function, but it is never called inside outer().
Option 4: Correct – inner() is defined and called inside outer(), then outer() is called to execute both.

Key takeaway: Nested functions are functions defined inside other functions. They are only accessible within the scope of the outer function.

Which statement correctly describes first-class functions in Python?

Functions can only be defined inside classes and cannot be passed as arguments

Functions cannot be assigned to variables in Python

Functions in Python are objects and can be passed as arguments, returned from other functions, and assigned to variables

Functions must always return a value to be considered first-class

This question tests understanding of first-class functions in Python:

Option 1: Incorrect – Functions can be defined anywhere, not just inside classes.
Option 2: Incorrect – Functions can be assigned to variables in Python.
Option 3: Correct – Python treats functions as objects, allowing them to be passed as arguments, returned from other functions, and assigned to variables.
Option 4: Incorrect – Functions do not need to return a value to be considered first-class.

Key takeaway: In Python, functions are first-class objects, enabling higher-order programming patterns like passing functions as arguments, returning them, and storing them in variables.

Which of the following correctly defines a lambda function to add two numbers?

def add = lambda x, y: x + y

lambda add(x, y):
    return x + y

add = function(x, y): x + y

add = lambda x, y: x + y

This question tests understanding of lambda (anonymous) functions in Python:

Option 1: Incorrect – Syntax is invalid; you cannot use def with = lambda.
Option 2: Incorrect – Lambda does not use return or parentheses like this.
Option 3: Incorrect – function is not a Python keyword.
Option 4: Correct – lambda x, y: x + y defines an anonymous function assigned to add.

Key takeaway: Lambda functions are concise, single-expression functions. They do not use def or return and are often used for short operations or as arguments to higher-order functions.

Which of the following functions correctly implements recursion to calculate the factorial of a number?

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

def factorial(n):
    result = 1
    for i in range(n):
        result *= i
    return result

def factorial(n):
    if n == 0:
        return 0
    else:
        return n * factorial(n-1)

def factorial(n):
    return n * factorial(n)

This question tests understanding of recursive functions in Python:

Option 1: Correct – Proper base case (n == 0) prevents infinite recursion. The function multiplies n by the factorial of n-1.
Option 2: Incorrect – This uses iteration, not recursion.
Option 3: Incorrect – Base case returns 0, so factorial(0) = 0, which is wrong.
Option 4: Incorrect – Calls itself with the same n endlessly, causing infinite recursion.

Key takeaway: Recursive functions require a base case to stop recursion. Each recursive call should move toward this base case to avoid infinite loops.

Which of the following correctly demonstrates a closure in Python?

def outer(x):
    def inner(y):
        return y * 2
    return inner

def outer(x):
    def inner(y):
        return x + y
    return inner
f = outer(10)
print(f(5))  # Output: 15

def outer(x):
    return x + 5

def inner(y):
    return y + 5
def outer(x):
    inner(x)

This question tests understanding of closures in Python:

Option 1: Incorrect – The inner function does not reference the outer function’s parameter, so it is not a closure.
Option 2: Correct – The inner function references x from the enclosing scope, forming a closure. Calling f(5) uses the value of x preserved from outer(10).
Option 3: Incorrect – No inner function; not a closure.
Option 4: Incorrect – The inner function is not returned; no closure is formed.

Key takeaway: A closure occurs when an inner function remembers and uses variables from its enclosing function even after the outer function has finished executing.

Which of the following correctly defines and uses a decorator in Python?

def decorator(func):
    func()
def say_hello():
    print("Hello")
say_hello = decorator(say_hello)

def decorator(func):
    print("Decorating")
@decorator
def say_hello():
    print("Hello")

def decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

@decorator
def say_hello():
    print("Hello")

say_hello()

def decorator(func):
    func = func()

This question tests understanding of decorators in Python:

Option 1: Incorrect – The decorator does not return a wrapper function; it only calls the function once.
Option 2: Incorrect – Decorator must return a function; this code only prints text, it does not wrap the original function.
Option 3: Correct – Defines a wrapper function inside the decorator, adds behavior before and after calling func, returns wrapper, and uses @decorator syntax correctly.
Option 4: Incorrect – The decorator incorrectly tries to call func immediately and does not return a wrapper.

Key takeaway: A decorator is a function that wraps another function to modify its behavior. The decorator must return a function, and the @decorator syntax applies it to the target function.

What will be the output of the following recursive function call?

def countdown(n):
    if n <= 0:
        return
    print(n)
    countdown(n-2)

countdown(5)

5 4 3 2 1

5 3 1

5 3 1 -1

5 4 3 2

This question tests understanding of recursive calls with modified step sizes:

Option 1: Incorrect – This would be correct if the function decreased by 1, but it decreases by 2.
Option 2: Correct – Function prints n, then calls itself with n-2, producing 5 → 3 → 1.
Option 3: Incorrect – The function stops when n <= 0, so -1 is not printed.
Option 4: Incorrect – This would happen if the function decreased by 1 and stopped before 0.

Key takeaway: Carefully track the recursive call changes and base case to predict the correct sequence of outputs. Step sizes affect the printed values.

What will be the output of the following function call?

def func(a, *args, **kwargs):
    print(a, args, kwargs)

func(1, 2, 3, x=4, y=5)

1 (2, 3) {'x': 4, 'y': 5}

1 [2, 3] {'x': 4, 'y': 5}

1 2 3 x=4 y=5

1 2 3 {'x': 4, 'y': 5}

This question tests understanding of positional, *args, and **kwargs in Python functions:

Option 1: Correct – a receives the first positional argument (1), *args collects remaining positional arguments as a tuple (2, 3), and **kwargs collects keyword arguments as a dictionary.
Option 2: Incorrect – *args is always a tuple, not a list.
Option 3: Incorrect – Positional arguments beyond the first are not printed individually; args groups them as a tuple.
Option 4: Incorrect – Same issue; *args must be a tuple.

Key takeaway: In Python, *args collects extra positional arguments as a tuple, and **kwargs collects keyword arguments as a dictionary. Understanding this helps in designing flexible functions.