Advanced Function Concepts

Learn about nested functions, closures, functions as first-class objects, and function documentation in Python.

By Ali Berro

January 9, 2026 8 min read Section 5

From: Python Fundamentals: From Zero to Hero

python functions nested-functions closures

Course Progress

Section 36 of 61

Back to Course

Advanced Function Concepts

Python treats functions as first-class objects, meaning they can be assigned to variables, passed as arguments, returned from functions, and stored in data structures. This section explores these powerful concepts.

Functions as First-Class Objects

In Python, functions are objects just like integers, strings, or lists. This means you can:

Assign Functions to Variables

1
def greet(name):
2
    return f"Hello, {name}!"
3

4
say_hello = greet  # Assign function to variable
5
print(say_hello("Alice"))  # Hello, Alice!

Pass Functions as Arguments

1
def apply_operation(x, y, operation):
2
    return operation(x, y)
3

4
def add(a, b):
5
    return a + b
6

7
def multiply(a, b):
8
    return a * b
9

10
print(apply_operation(5, 3, add))       # 8
11
print(apply_operation(5, 3, multiply)) # 15

Return Functions from Functions

1
def get_operation(operation_type):
2
    def add(x, y):
3
        return x + y
4

5
    def subtract(x, y):
6
        return x - y
7

8
    if operation_type == "add":
9
        return add
10
    else:
11
        return subtract
12

13
operation = get_operation("add")
14
print(operation(5, 3))  # 8

Store Functions in Data Structures

Functions can be stored in lists and dictionaries:

1
def add(x, y):
2
    return x + y
3

4
def sub(x, y):
5
    return x - y
6

7
def mul(x, y):
8
    return x * y
9

10
ops = [add, sub, mul]
11

12
print("Choose any operation", "0. Add", "1. Sub", "2. Mul", sep="\n")
13
operation = int(input())
14
num1 = int(input())
15
num2 = int(input())
16
res = ops[operation](num1, num2)
17
print(res)

Nested Functions

Functions can be defined inside other functions. These are called nested or inner functions:

1
def outer_function(x):
2
    def inner_function(y):
3
        return y * 2
4

5
    return inner_function(x)
6

7
result = outer_function(5)
8
print(result)  # 10

Why Use Nested Functions?

Encapsulation: Hide implementation details
Helper functions: Create utility functions specific to the outer function
Closures: Create functions that remember their environment

1
def process_data(data, operation):
2
    def validate(item):
3
        return type(item) in (type(int), type(float))
4

5
    def transform(item):
6
        return operation(item)
7

8
    validated = []
9
    for item in data:
10
        if validate(item):
11
            validated.append(item)
12
    transformed = []
13
    for item in validated:
14
        transformed.append(transform(item))
15
    return transformed
16

17
numbers = [1, 2, "three", 4, 5.5]
18
result = process_data(numbers, lambda x: x * 2)
19
print(result)  # [2, 4, 8, 11.0]

Closures

A closure is a nested function that remembers and has access to variables from its enclosing scope, even after the outer function has finished executing:

1
def outer_function(x):
2
    def inner_function(y):
3
        return x + y  # x is from enclosing scope
4
    return inner_function
5

6
add_five = outer_function(5)
7
print(add_five(3))  # 8
8
print(add_five(10)) # 15

How Closures Work

The inner function “closes over” the variables from the outer function’s scope:

1
def create_multiplier(factor):
2
    def multiplier(number):
3
        return number * factor  # factor is "captured" from outer scope
4
    return multiplier
5

6
double = create_multiplier(2)
7
triple = create_multiplier(3)
8

9
print(double(5))   # 10
10
print(triple(5))   # 15

Some examples:

1
def create_counter():
2
    count = 0
3

4
    def counter():
5
        nonlocal count
6
        count += 1
7
        return count
8

9
    return counter
10

11
counter1 = create_counter()
12
counter2 = create_counter()
13

14
print(counter1())  # 1
15
print(counter1())  # 2
16
print(counter2())  # 1 (independent counter)
17
print(counter1())  # 3

1
def create_validator(min_value, max_value):
2
    def validate(value):
3
        if min_value <= value <= max_value:
4
            return True
5
        return False
6
    return validate
7

8
validate_age = create_validator(0, 120)
9
validate_percentage = create_validator(0, 100)
10

11
print(validate_age(25))        # True
12
print(validate_age(150))      # False
13
print(validate_percentage(75)) # True
14
print(validate_percentage(150)) # False

Lambda Functions

A lambda is a small anonymous function which can take any number of arguments but can only have one expression as the body.

Syntax: lambda var1, var2, …: expression

1
operations = {
2
    'add': lambda x, y: x + y,
3
    'subtract': lambda x, y: x - y,
4
    'multiply': lambda x, y: x * y
5
}
6

7
result = operations['add'](3, 4)
8
print(result)  # 7

Higher-Order Functions

Higher-order functions are functions that take other functions as arguments or return functions:

1
def apply_twice(func, value):
2
    """Apply a function twice to a value"""
3
    return func(func(value))
4

5
def square(x):
6
    return x ** 2
7

8
result = apply_twice(square, 3)
9
print(result)  # 81 (square(square(3)) = square(9) = 81)

Function Factories

Function factories create and return new functions:

1
def create_power_function(exponent):
2
    def power(base):
3
        return base ** exponent
4
    return power
5

6
square = create_power_function(2)
7
cube = create_power_function(3)
8

9
print(square(4))  # 16
10
print(cube(4))    # 64

Function Documentation

Docstrings

A docstring or documentation string is a multi-line string inserted on the first line of a function. It serves as documentation for the function. It’s what gets printed when we write help(fun). We can also access it using fun.__doc__:

1
def custom_max(x, y):
2
    """This function returns the maximum between 2 numbers"""
3
    return x if x > y else y
4

5
print(custom_max(1, 2))  # 2
6
help(custom_max)

Docstrings are string literals that Python stores and can access at runtime, making them different from regular comments. They provide a way to document what a function does, how to use it, and what it returns.

Exercises

Exercise 1: Functions as Objects

Create a list of three functions: add, subtract, and multiply. Then call the function at index 1 with arguments 10 and 5.

Answer:

1
def add(x, y):
2
    return x + y
3

4
def subtract(x, y):
5
return x - y
6

7
def multiply(x, y):
8
return x \* y
9

10
ops = [add, subtract, multiply]
11
result = ops[1](10, 5) # subtract(10, 5)
12
print(result) # 5

Exercise 2: Nested Functions

Write a function called outer that defines an inner function inner which prints a message. Call inner from within outer.

Answer:

1
def outer():
2
    def inner():
3
        print("This is the inner function")
4
    inner()
5

6
outer()  # This is the inner function

Exercise 3: Closures

Write a function called create_multiplier that takes a factor and returns a function that multiplies any number by that factor. Use it to create a function that doubles numbers. Read the factor and the number to multiply.

Answer:

1
def create_multiplier(factor):
2
    def multiplier(number):
3
        return number * factor
4
    return multiplier
5

6
factor = int(input())
7
number = int(input())
8
double = create_multiplier(factor)
9
print(double(number))

Exercise 4: Lambda Functions

Create a dictionary called operations with keys ‘add’, ‘subtract’, and ‘multiply’, where each value is a lambda function that performs that operation on two numbers. Then use it to calculate 10 + 5.

Answer:

1
operations = {
2
    'add': lambda x, y: x + y,
3
    'subtract': lambda x, y: x - y,
4
    'multiply': lambda x, y: x * y
5
}
6

7
result = operations['add'](10, 5)
8
print(result) # 15

Exercise 5: Function Factory

Write a function called create_power_function that takes an exponent and returns a function that raises any number to that exponent. Read the exponent and base from input.

Answer:

1
def create_power_function(exponent):
2
    def power(base):
3
        return base ** exponent
4
    return power
5

6
exponent = int(input())
7
base = int(input())
8
power_func = create_power_function(exponent)
9
print(power_func(base))

Exercise 6: Writing a Docstring

Write a function called calculate_area that takes length and width as parameters, returns the area, and includes a docstring explaining what the function does.

Answer:

1
def calculate_area(length, width):
2
    """This function calculates and returns the area of a rectangle"""
3
    return length * width
4

5
print(calculate_area(5, 3)) # 15

Exercise 7: Accessing Docstring

Given the following function, write code to access its docstring using both __doc__ and help().

1
def greet(name):
2
    """This function greets a person by name"""
3
    print(f"Hello, {name}!")

Answer:

1
def greet(name):
2
    """This function greets a person by name"""
3
    print(f"Hello, {name}!")
4

5
print(greet.__doc__)  # This function greets a person by name
6
help(greet)  # Shows help information

Exercise 8: Function Without Docstring

What will be the value of __doc__ for a function that doesn’t have a docstring?

Answer:

1
def no_docstring():
2
    pass
3

4
print(no_docstring.__doc__) # None

Functions without docstrings have __doc__ set to None.

Course Progress

Section 36 of 61

Back to Course

Advanced Function Concepts

Table of Contents

Table of Contents

Course Progress

Advanced Function Concepts

Functions as First-Class Objects

Assign Functions to Variables

Pass Functions as Arguments

Return Functions from Functions

Store Functions in Data Structures

Nested Functions

Why Use Nested Functions?

Closures

How Closures Work

Lambda Functions

Higher-Order Functions

Function Factories

Function Documentation

Docstrings

Exercises

Exercise 1: Functions as Objects

Exercise 2: Nested Functions

Exercise 3: Closures

Closures

Exercise 4: Lambda Functions

Exercise 5: Function Factory

Function Factory

Exercise 6: Writing a Docstring

Exercise 7: Accessing Docstring

Exercise 8: Function Without Docstring

Course Progress