Python Functions Exercise Solutions | KalviGavani

(a) Hello, (b) Hello, World (c) Error (d) None

(a) 10 (b) (1, 2, 3, 4) (c) Error (d) [1, 2, 3, 4]

(a) 33 (b) 28 (c) 13 (d) Error

(a) 9 (b) 20 (c) Error (d) 54

A function is a named, self-contained block of code that performs a specific task. It may accept inputs (parameters) and produce outputs (return values).

Advantages:

• Reusability: Write once, call many times — avoids code duplication.
• Modularity: Large programs are broken into smaller, manageable units.
• Readability: Well-named functions make code easier to understand.
• Debugging: Errors can be isolated to specific functions, making debugging easier.
• Maintainability: Changes to a function affect all calls, simplifying updates.

Python supports four types of function arguments:

(i) Positional arguments — matched by order:

def add(a, b):
    return a + b
print(add(3, 5))  # a=3, b=5 → 8

(ii) Keyword arguments — matched by name:

def greet(name, msg):
    return msg + ", " + name
print(greet(msg="Hello", name="Kavi"))  # Hello, Kavi

(iii) Default arguments — have a pre-set value:

def power(base, exp=2):
    return base ** exp
print(power(5))    # 25 (exp defaults to 2)
print(power(5, 3)) # 125 (exp = 3)

(iv) Variable-length arguments:

• *args collects extra positional arguments as a tuple.
• **kwargs collects extra keyword arguments as a dictionary.

def show(*args, **kwargs):
    print(args)    # (1, 2, 3)
    print(kwargs)  # {'a': 10, 'b': 20}
show(1, 2, 3, a=10, b=20)

Recursion is a technique where a function calls itself to solve a smaller instance of the same problem. Every recursive function must have:

• A base case: the condition that stops recursion.
• A recursive case: the function calls itself with a smaller input.

def factorial(n):
    if n == 0 or n == 1:   # Base case
        return 1
    else:                    # Recursive case
        return n * factorial(n - 1)

print(factorial(5))  # 5 * 4 * 3 * 2 * 1 = 120

Trace for factorial(5):

A lambda function is an anonymous (nameless), single-expression function defined using the lambda keyword. It has the syntax:

Examples:

# Square of a number
square = lambda x: x * x
print(square(5))  # 25

# Add two numbers
add = lambda a, b: a + b
print(add(3, 7))  # 10

# Lambda with default argument
greet = lambda name="World": "Hello, " + name
print(greet())      # Hello, World
print(greet("Kavi"))  # Hello, Kavi

# Lambda used with sorted()
students = [("Kavi", 85), ("Arun", 92), ("Bala", 78)]
ranked = sorted(students, key=lambda x: x[1], reverse=True)
print(ranked)  # [('Arun', 92), ('Kavi', 85), ('Bala', 78)]

def with_return(a, b):
    return a + b

def with_print(a, b):
    print(a + b)

result = with_return(3, 4)  # result = 7
result2 = with_print(3, 4)   # prints 7, but result2 = None

A user-defined function is created by the programmer to perform a specific task.

Syntax:

def function_name(parameters):
    """Docstring (optional)"""
    # Function body
    return value  # optional

Components:

• def — keyword that starts the function definition.
• function_name — identifier following Python naming rules.
• parameters — optional input variables listed in parentheses.
• Docstring — optional description of the function (triple-quoted).
• return — optional statement to send a value back.

Types of user-defined functions:

Examples:

# 1. No parameter, no return
def greet():
    print("Welcome to Python!")

greet()  # Output: Welcome to Python!

# 2. With parameter, no return
def display_square(n):
    print(f"Square of {n} is {n*n}")

display_square(5)  # Output: Square of 5 is 25

# 3. No parameter, with return
def get_pi():
    return 3.14159

print(get_pi())  # Output: 3.14159

# 4. With parameter, with return
def multiply(a, b):
    return a * b

result = multiply(4, 6)
print(result)  # Output: 24

Python functions can receive data through arguments. There are four types:

(i) Positional Arguments Arguments are matched to parameters by their position (order).

def subtract(a, b):
    return a - b

print(subtract(10, 3))  # a=10, b=3 → 7
# Order matters: subtract(3, 10) gives -7

(ii) Keyword Arguments Arguments are passed by explicitly naming the parameter. Order does not matter.

def greet(name, msg):
    print(msg + ", " + name + "!")

greet(name="Kavi", msg="Good morning")  # Good morning, Kavi!
greet(msg="Hello", name="Bala")         # Hello, Bala!

(iii) Default Arguments Parameters are given default values. If no argument is passed, the default is used.

def power(base, exp=2):
    return base ** exp

print(power(5))     # 25  (exp defaults to 2)
print(power(5, 3))  # 125 (exp is 3)

Important rule: Non-default arguments must come before default arguments.

# Correct:
def func(a, b=10, c=20): pass

# Wrong — causes SyntaxError:
# def func(a=10, b, c): pass

(iv) Variable-length Arguments args collects extra positional arguments into a tuple; *kwargs collects extra keyword arguments into a dictionary.

def total(*args):
    print(args)       # (10, 20, 30)
    print(sum(args))  # 60

total(10, 20, 30)

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

display_info(name="Kavi", age=17, grade="A")
# name = Kavi
# age = 17
# grade = A

Combined example:

def mixed(a, b, *args, c=10, **kwargs):
    print(f"a={a}, b={b}")       # a=1, b=2
    print(f"args={args}")         # args=(3, 4, 5)
    print(f"c={c}")               # c=10
    print(f"kwargs={kwargs}")     # kwargs={'x': 100, 'y': 200}

mixed(1, 2, 3, 4, 5, x=100, y=200)

Recursion is a programming technique where a function calls itself to solve a problem by breaking it down into smaller sub-problems.

Essential components: 1. Base case: The condition that stops the recursion. 2. Recursive case: The function calls itself with a modified (smaller) argument.

Example — Fibonacci series:

def fibonacci(n):
    if n <= 0:
        return 0          # Base case 1
    elif n == 1:
        return 1          # Base case 2
    else:
        return fibonacci(n-1) + fibonacci(n-2)  # Recursive case

for i in range(10):
    print(fibonacci(i), end=" ")
# Output: 0 1 1 2 3 5 8 13 21 34

Example — Sum of digits:

def sum_digits(n):
    if n == 0:
        return 0                    # Base case
    else:
        return (n % 10) + sum_digits(n // 10)  # Recursive case

print(sum_digits(1234))  # 1+2+3+4 = 10

Advantages:

• Code is simpler and more elegant for problems that have a natural recursive structure (e.g., tree traversal, factorial, Fibonacci).
• Complex problems like Tower of Hanoi and DFS can be expressed concisely.
• Reduces the need for complex loop structures.

Disadvantages:

• Recursive calls consume stack memory; deep recursion can cause RecursionError.
• Generally slower than iterative solutions due to function call overhead.
• Can be harder to debug because of multiple nested calls.
• Each call adds overhead (saving state, returning).

Comparison table:

A lambda function is an anonymous, single-expression function defined using the lambda keyword.

Syntax:

lambda arguments: expression

Characteristics:

• Anonymous — no function name (though it can be assigned to a variable).
• Single expression only — cannot contain multiple statements or a block.
• No explicit return — the expression's result is automatically returned.
• Can take any number of arguments but only one expression.

Examples:

# Basic lambda
square = lambda x: x * x
print(square(6))  # 36

# Lambda with multiple arguments
add = lambda a, b, c: a + b + c
print(add(1, 2, 3))  # 6

# Lambda with default argument
greet = lambda name="World": "Hello, " + name
print(greet())        # Hello, World
print(greet("Kavi"))  # Hello, Kavi

# Immediately invoked lambda (IIFE)
result = (lambda x, y: x * y)(4, 5)
print(result)  # 20

# Lambda used with filter()
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# Lambda used with map()
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Lambda used with sorted()
students = [("Kavi", 85), ("Arun", 92), ("Bala", 78)]
ranked = sorted(students, key=lambda s: s[1], reverse=True)
print(ranked)  # [('Arun', 92), ('Kavi', 85), ('Bala', 78)]

# Conditional expression in lambda
max_of_two = lambda a, b: a if a > b else b
print(max_of_two(15, 9))  # 15

Lambda vs def:

Scope refers to the region of a program where a variable is accessible.

(i) Local Scope A variable defined inside a function is local to that function. It cannot be accessed outside.

def my_func():
    x = 10    # Local variable
    print(x)  # 10

my_func()
# print(x)  # NameError: name 'x' is not defined

(ii) Global Scope A variable defined outside all functions is global and can be accessed anywhere.

x = 50   # Global variable

def my_func():
    print(x)  # 50 (reading global x)

my_func()
print(x)  # 50

(iii) The global Keyword To modify a global variable inside a function, use the global keyword. Without it, assignment inside a function creates a new local variable.

count = 0   # Global

def increment():
    global count       # Declare count as global
    count = count + 1  # Modifies global count

increment()
increment()
print(count)  # 2

Without global — creates a local variable (shadowing):

x = 10

def modify():
    x = 20    # Creates a new local x, does NOT modify global x
    print("Inside:", x)  # 20

modify()
print("Outside:", x)  # 10 (global x unchanged)

With global — modifies the global variable:

x = 10

def modify():
    global x   # Refers to the global x
    x = 20     # Modifies global x
    print("Inside:", x)  # 20

modify()
print("Outside:", x)  # 20

Key rules:

• Reading a global variable inside a function does not require global.
• Modifying (assigning to) a global variable inside a function does require global.
• Local variables are destroyed when the function exits.
• Avoid excessive use of global — prefer passing parameters and returning values.