First-Class Objects

To comprehend first-class objects, it's essential to touch upon functional programming. This programming paradigm emphasizes the importance of functions and encourages problem-solving through a series of function calls.

A function is considered a first-class object if:

• It can be assigned to a variable,
• It can be passed as an argument to another function,
• It can be returned from a function.

In functional programming, a function's purpose is not to alter the state of an existing variable. Instead, it operates on inputs and generates outputs without side effects. Side effects occur when a function alters external resources, which can impact its results.

For example, consider the following Python code:

CONST = 4 # Global variable

def divide_const(n: int) -> int:

global CONST # Non-local variable

CONST = 6

return CONST / n

In this case, the function divide_const modifies the global variable CONST, which directly influences its output, demonstrating a side effect.

In Python, everything is an object, including functions. Therefore, functions possess attributes and can be manipulated like other objects:

CONST = 4 # Global variable

def divide_const(n: int) -> int:

return CONST / n

divide_const.__call__(2) # Treat it as an object

Functions can be stored in data structures, passed as arguments, and returned from other functions:

my_dict = {"divide_const": divide_const}

my_dict["divide_const"](2) # 2.0

We can also pass functions as arguments, as shown in this example:

from typing import Callable

fn = print # Built-in print method

def say_hi(fn: Callable):

fn("Hi there!")

say_hi(fn) # Hi there!

This illustrates how functions can act as first-class citizens within Python.

Higher-Order Functions

Higher-order functions (HOFs) take other functions as parameters or return them as results. The say_hi function we discussed earlier is an example of a higher-order function.

Python includes numerous built-in higher-order functions. For instance, the sort method can accept a function as its key parameter to determine how to sort elements:

names = ["Jane", "Doe"]

names.sort(key=str.lower) # High-order function

Another example of a higher-order function is one that returns a function:

FUNCTIONS = {'sum': sum, 'max': max, 'min': min}

def func_lib(key: str):

return FUNCTIONS.get(key)

numbers = [1, 2, 5, 4, 7, 3]

fn = func_lib('sum') # The function we want to execute

print(fn(numbers)) # 22

A well-known higher-order function is map, which processes an iterable and returns a new one:

def multiply_by_n(n: int) -> int:

return n * n

numbers = [1, 2, 5, 4, 7, 3]

new_numbers = list(map(multiply_by_n, numbers)) # map function

print(new_numbers) # [1, 4, 25, 16, 49, 9]

Alternatively, you can achieve similar results using list comprehension:

numbers = [1, 2, 5, 4, 7, 3]

new_numbers = [n * n for n in numbers]

print(new_numbers) # [1, 4, 25, 16, 49, 9]

Anonymous Functions

The concept of anonymous functions can be traced back to Lambda Calculus, formulated by Alonzo Church in the 1930s. Lambda functions in Python are typically single-use functions that can be defined using the lambda keyword:

numbers = [1, 2, 5, 4, 7, 3]

new_numbers = list(map(lambda n: n * n, numbers)) # map function with lambda

print(new_numbers) # [1, 4, 25, 16, 49, 9]

Anonymous functions are designed to be concise and easy to read. If they become overly complex, it may be better to refactor them into regular functions defined with def.

For example:

fn = lambda n: n * 2 if n % 2 == 0 else n * n

print(fn(3)) # 9

While this function works, it may be too lengthy for a lambda expression. Generally, anonymous functions should be straightforward and readable.

Final Thoughts

The concepts outlined here are foundational to Python programming and are crucial for any programmer to understand. Familiarity with these topics will prepare you for various coding scenarios, enabling you to make informed choices in your development work.

Resources Used

• Functional Programming
• First-Class Citizen
• Lambda Calculus
• Side Effect (Computer Science)
• Higher-Order Function
• Fluent Python

For further insights and discussions, consider subscribing to our newsletter for updates on similar content!

Explore the fundamentals of Python functions in this comprehensive video.

Delve deeper into Python functions with this informative guide.