Python First-Class Functions Tutorial – Complete Guide

On their coding journey, many learners encounter the term ‘first-class functions’ in Python, often met with curiosity, uncertainty, or even apprehension. Rest assured, while this concept may appear daunting at first, it is not only accessible, but also a powerful and versatile feature of Python. This tutorial aims to demystify first-class functions by breaking down the concept, showcasing examples, and demonstrating its value in your coding toolbox.

Demystifying First-Class Functions

So, what is a first-class function? In the realm of Python, functions are first-class objects. This simply means that functions are treated just like any other object, such as integers, strings, or lists.

Now you may be wondering, why the buzz around first-class functions? These functions, treated like any other object, can be passed as arguments, returned from other functions, or even stored in data structures. This results in enhanced modularity and code reusability, and marks a key principle in functional programming.

With first-class functions, you can create higher-order functions, which accept other functions as parameters or return them as results, enabling you to modify or extend the behavior of functions. Imagine having game mechanics where various components can interact differently based on the functions passed into them, offering you the ability to create dynamic and interactive gaming experiences.

CTA Small Image

Basics of First-Class Functions in Python

Let’s dive into the nuts and bolts of first-class functions in Python by exploring simple examples:

Functions as Objects

As stated, functions are objects and can be assigned to variables, just like any other data type:

def greet():
    print("Hello, world!")
say_hello = greet

In the example above, we’ve assigned the function greet() to the variable say_hello, and calling say_hello() would print “Hello, world!.

Functions as Arguments

In Python, functions can be passed as arguments into other functions:

def add(x, y):
    return x + y
def calculate(func, x, y):
    return func(x, y)

print(calculate(add, 2, 3))

Here, we’ve passed the function add as an argument into calculate. calculate has then executed add and returned the result, outputting 5.

Delving Deeper into First-Class Functions

Functions in Data Structures

First-class functions can also be stored within data structures such as lists or dictionaries:

def multiply(x, y):
    return x * y
function_list = [add, multiply]
print(function_list[0](2, 3))
print(function_list[1](2, 3))

This example demonstrates storing different functions within a list and then calling them with arguments, resulting in the outputs of 5 and 6 respectively.

Functions as Return Values

A powerful feature of first-class functions is the ability to create and return new functions:

def power(n):
    def raise_to_power(x):
        return x ** n
    return raise_to_power

square = power(2)
cube = power(3)
print(square(4))  # outputs: 16
print(cube(4))  # outputs: 64

In this example, a function power(n) creates a new function raise_to_power that raises its argument to the power of n and returns this new function. We then use power to create square and cube functions that square and cube numbers respectively.

Mastering First-Class Functions

Nested Functions

With first-class functions, you can create nested functions, also known as inner functions:

def outer_function(msg):
    def inner_function():
        print(f"Message is: {msg}")
    return inner_function

hello_func = outer_function('Hello')

In this example, we’ve created an outer function that contains an inner function. The inner function is returned when the outer function is called, which prints the passed message when executed.


A closure occurs when a nested function references a value in its containing function:

def outer_function(msg):
    def inner_function():
        print(f"Message is: {msg}")
    return inner_function

hello_func = outer_function('Hello')
bye_func = outer_function('Bye')

Here, we have two closures: hello_func and bye_func. Each closure remembers the value of msg from its containing function, even after the outer function has finished executing.

Closures in Practice

Closures can be used for data hiding and encapsulation:

def make_multiplier(x):
    def multiplier(n):
        return x * n
    return multiplier

times3 = make_multiplier(3)
times5 = make_multiplier(5)

print(times3(9))  # Outputs: 27
print(times5(3))  # Outputs: 15

This example demonstrates closures in action, keeping a “record” of the environment they were created in. times3() and times5() each “remember” the value of x that was passed to make_multiplier().


Decorators in Python are a practical application of first-class functions, allowing you to modify or extend the behavior of a function without changing its source code:

def decorator_func(original_func):
    def wrapper_func():
        print(f"{original_func.__name__} function is about to run:")
        return original_func()
    return wrapper_func

def display():
    print("display function ran")

Here, @decorator_func is Python’s syntax for applying a decorator to a function. Our decorator wraps display() with wrapper_func(), enhancing its behavior with a print statement each time it is called.

Mastering first-class functions can immensely enhance your Python prowess. Whether it’s fostering code reusability through higher-order functions, creating dynamic lists of functions for later use, or leveraging Python’s powerful decorators, these aspects of the language offer you flexibility and opportunities for clever solutions to coding challenges.

Continuing Your Python Journey

With your newfound understanding of first-class functions in Python, you are well on your way to mastering Python’s powerful features. However, the adventure doesn’t end here!

Want to delve deeper into Python? Consider our Python Mini-Degree, a comprehensive collection of courses designed to teach Python programming.

This repertoire covers the coding basics to advanced topics like algorithms, object-oriented programming, game development, and app development. The curriculum includes hands-on projects, such as devising arcade games, creating a medical diagnosis bot, or even building a to-do list app.

Zenva is known for high-quality instructors and a project-based learning approach. Upon completion, not only will you possess a solid grasp on Python programming, but you’ll also have a professional portfolio to showcase your newly cultivated skills. Our content is consistently updated, ensuring you are learning industry-relevant skills.

Perhaps you’re looking to venture beyond the realm of our Mini-Degree? Discover our expansive range of Python courses to unearth more of Python’s treasures and capabilities.


The world of Python and its first-class functions may initially seem like a formidable beast to tackle. However, with our tutorials and courses, that dragon soon shrinks to the size of a household pet. Let’s continue this thrilling journey of discovery together!

Whether you’re just starting out or are a seasoned coder, our Python Mini-Degree is an invaluable companion on your coding adventure. It’s time to unlock your potential and harness the power of Python with Zenva!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.