Chapter 4 Exercises

Comprehensive exercises covering functions in Python.

By Ali Berro

January 9, 2026 16 min read Section

From: Python Fundamentals: From Zero to Hero

python functions fundamentals exercises

Course Progress

Section 39 of 61

Back to Course

Chapter 4 Exercises

Comprehensive exercises covering functions in Python, sorted from easiest to hardest.

Exercises

Exercise 1: Range Sum Function

Write a function called range_sum that takes in a range of numbers: start (inclusive), end (exclusive), and an optional step (default 1). It should return the sum of all the numbers in the range.

Answer:

1
def range_sum(start, end, step=1):
2
    total = 0
3
    for i in range(start, end, step):
4
        total += i
5
    return total
6

7
start = int(input())
8
end = int(input())
9
step_input = input().strip()
10
step = int(step_input) if step_input else 1
11

12
result = range_sum(start, end, step)
13
print(result)

Exercise 2: Sort Strings by Length

Write a function called sort_by_length that takes a list of strings and returns a list of strings sorted by their length (shortest first).

Answer:

1
def sort_by_length(strings):
2
    return sorted(strings, key=len)
3

4
n = int(input())
5
strings = []
6
for i in range(n):
7
    strings.append(input())
8

9
result = sort_by_length(strings)
10
print(result)

Exercise 3: Check Unique Elements

Write a function called all_unique that takes in a list and returns True if all the elements are unique, otherwise returns False.

Answer:

1
def all_unique(lst):
2
    return len(lst) == len(set(lst))
3

4
n = int(input())
5
numbers = []
6
for i in range(n):
7
    numbers.append(int(input()))
8

9
result = all_unique(numbers)
10
print(result)

Exercise 4: Parse Numbers from Line

Write a function called parse_numbers that takes a string containing space-separated numbers and returns a list of integers. Read a line of space-separated numbers from input, call the function, and print the resulting list.

Answer:

1
def parse_numbers(line):
2
    return [int(num) for num in line.split()]
3

4
line = input()
5
numbers = parse_numbers(line)
6
print(numbers)

Exercise 5: Character to ASCII Dictionary

Write a function called char_to_ascii that creates and returns a dictionary containing the characters from A to Z in uppercase as keys, and their decimal ASCII representation as values. Print the dictionary.

Answer:

1
def char_to_ascii():
2
    result = {}
3
    for i in range(26):
4
        char = chr(ord('A') + i)
5
        result[char] = ord(char)
6
    return result
7

8
dictionary = char_to_ascii()
9
print(dictionary)

Exercise 6: Fibonacci Number

Write a function called fibonacci that takes an integer n and returns the nth Fibonacci number. The Fibonacci sequence starts with 0, 1, 1, 2, 3, 5, 8, … (where fib(0)=0, fib(1)=1, fib(2)=1).

Answer:

1
def fibonacci(n):
2
  if n == 0 or n == 1:
3
    return 0
4
  a, b = 0, 1
5
  for i in range(2, n + 1):
6
    a, b = b, a + b
7
  return b
8

9
n = int(input())
10
result = fibonacci(n)
11
print(result)

Exercise 7: Even Fibonacci Numbers

Write a function called even_fibonacci that takes an integer m and returns a list of all even Fibonacci numbers that are less than m. Use the fibonacci function from the previous exercise or implement it inline.

Answer:

1
def fibonacci(n):
2
  if n == 0 or n == 1:
3
    return n
4
  a, b = 0, 1
5
  for i in range(2, n + 1):
6
    a, b = b, a + b
7
  return b
8

9
def even_fibonacci(m):
10
  result = []
11
  i = 0
12
  while True:
13
    fib = fibonacci(i)
14
    if fib >= m:
15
      break
16
    if fib % 2 == 0:
17
      result.append(fib)
18
    i += 1
19
  return result
20

21
m = int(input())
22
result = even_fibonacci(m)
23
print(result)

Exercise 8: Create Matrix

Write a function called create_matrix that takes the number of rows and columns, and creates a matrix (list of lists) where each entry $a_{ij} = i + j$ (0-indexed). Return and print the matrix.

Answer:

1
def create_matrix(rows, cols):
2
    matrix = []
3
    for i in range(rows):
4
        row = []
5
        for j in range(cols):
6
            row.append(i + j)
7
        matrix.append(row)
8
    return matrix
9

10
rows = int(input())
11
cols = int(input())
12
result = create_matrix(rows, cols)
13
print(result)

Exercise 9: Generate Tuple Pattern

Write a function called generate_tuples that takes an integer n and returns a list of tuples as shown in the example: for n=5, it should return [(1,), (1,2), (1,2,3), (1,2,3,4), (1,2,3,4,5)].

Answer:

1
def generate_tuples(n):
2
    result = []
3
    for i in range(1, n + 1):
4
        result.append(tuple(range(1, i + 1)))
5
    return result
6

7
n = int(input())
8
result = generate_tuples(n)
9
print(result)

Exercise 10: Custom Zip Function

Implement a custom zip function called custom_zip that takes an arbitrary number of iterables as arguments (using *args) and returns a list of tuples, where each tuple contains the i-th element from each iterable. The function should stop when the shortest iterable is exhausted.

Answer:

1
def custom_zip(*args):
2
    if not args:
3
        return []
4

5
    min_length = min(map(len, args))
6
    result = []
7

8
    for i in range(min_length):
9
        tuple_items = tuple(map(lambda x: x[i], args))
10
        result.append(tuple_items)
11

12
    return result

Exercise 11: Counter Closure

Write a function called counter that takes a start value, creates an internal counter from the start, and returns a function. Each time the returned function is invoked, it returns the current counter value and then increments it.

Answer:

1
def counter(start):
2
    count = start
3
    def increment():
4
        nonlocal count
5
        current = count
6
        count += 1
7
        return current
8
    return increment

Exercise 12: Once Function

Write a function called once that takes a function fn and returns a new function. The returned function should be identical to the original function except that it ensures fn is called at most once. The first time it’s called, it should return the same result as fn. Every subsequent time it’s called, it should return None. The function should work with functions that have no parameters, multiple parameters, keyword arguments, or both.

Answer:

1
def once(fn):
2
    called = False
3
    result = None
4

5
    def wrapper(*args, **kwargs):
6
        nonlocal called, result
7
        if not called:
8
            result = fn(*args, **kwargs)
9
            called = True
10
            return result
11
        return None
12

13
    return wrapper

Exercise 13: Function Composition

Write a function called compose that takes multiple functions as input (each only taking one argument), and returns a new function which is the composition of them. The composition should apply functions from right to left: compose(f, g, h)(x) = f(g(h(x))).

Answer:

1
def compose(*functions):
2
    def composed(x):
3
        result = x
4
        for func in reversed(functions):
5
            result = func(result)
6
        return result
7
    return composed

Exercise 14: Function Currying

Write a function called curry that takes a function fn and returns a curried version. A curried function can be called with one argument at a time. For example, if add(a, b, c) adds three numbers, curried_add = curry(add) allows curried_add(1)(2)(3) to return 6.

Hint: To get the number of arguments a function expects, you can use fn.__code__.co_argcount. This accesses the function’s code object which contains information about the function’s parameters.

Answer:

1
def curry(fn):
2
    def curried(*args):
3
        if len(args) >= fn.__code__.co_argcount:
4
            return fn(*args)
5
        else:
6
            def partial(*more_args):
7
                return curried(*(args + more_args))
8
            return partial
9
    return curried

Exercise 15: Common Elements

Write a function called common that takes an arbitrary number of lists and tuples (using *args), and returns a list of all common elements found in all of them. The elements returned should be unique (no duplicates).

Answer:

1
def common(*args):
2
    if not args:
3
        return []
4

5
    # Convert all to sets and find intersection
6
    sets = [set(iterable) for iterable in args]
7
    result_set = sets[0]
8

9
    for s in sets[1:]:
10
        result_set = result_set & s
11

12
    return sorted(list(result_set))

Exercise 16: Custom Map Function

Implement a custom map function called custom_map that takes a function and one or more iterables, and applies the function to corresponding elements from each iterable. It should return a list of results.

Answer:

1
def custom_map(func, *iterables):
2
    if not iterables:
3
        return []
4

5
    min_length = min(map(len, iterables))
6
    result = []
7

8
    for i in range(min_length):
9
        args = tuple(map(lambda it: it[i], iterables))
10
        result.append(func(*args))
11

12
    return result

Exercise 17: Custom Filter Function

Implement a custom filter function called custom_filter that takes a function (or None) and an iterable, and returns a list of elements for which the function returns True (or truthy values if function is None).

Answer:

1
def custom_filter(func, iterable):
2
    if func is None:
3
        func = bool
4

5
    result = []
6
    for item in iterable:
7
        if func(item):
8
            result.append(item)
9
    return result

Exercise 18: Memoization Decorator

Write a function called memoize that takes a function and returns a memoized version. The memoized function should cache results based on arguments, so if the same arguments are passed again, it returns the cached result instead of recalculating.

Answer:

1
def memoize(fn):
2
    cache = {}
3

4
    def memoized(*args):
5
        key = args
6
        if key not in cache:
7
            cache[key] = fn(*args)
8
        return cache[key]
9

10
    return memoized

Course Progress

Section 39 of 61

Back to Course

Table of Contents

Table of Contents

Course Progress

Chapter 4 Exercises

Exercises

Exercise 1: Range Sum Function

Exercise 2: Sort Strings by Length

Exercise 3: Check Unique Elements

Exercise 4: Parse Numbers from Line

Exercise 5: Character to ASCII Dictionary

Exercise 6: Fibonacci Number

Exercise 7: Even Fibonacci Numbers

Exercise 8: Create Matrix

Exercise 9: Generate Tuple Pattern

Exercise 10: Custom Zip Function

Exercise 11: Counter Closure

Exercise 12: Once Function

Exercise 13: Function Composition

Exercise 14: Function Currying

Exercise 15: Common Elements

Exercise 16: Custom Map Function

Exercise 17: Custom Filter Function

Exercise 18: Memoization Decorator

Course Progress