Introduction Four Advanced Function Concepts in Python
Python functions are a block of code that executes particular operations when they’re requested to run, which we term calling a function. Most of the time, we declare and call a function using the following syntax:
>>> # define a function using the def keyword
>>> def add_up(num1, num2):
... print("called the add_up function")
... sum_n = num1+num2
... return sum_n
...
>>> sum0 = add_up(3, 5)
called the add_up function
>>> print(sum0)
8
In the code above, we declare a function called add_up using the def keyword. This function takes two numbers (num1 and num2) as the input arguments, calculates their sum as the defined operation, and returns this value as the function’s output. Pretty straightforward, right?
Besides these regular functions, there are other kinds of functions in Python that can benefit our development. Let’s review them in this article.
1. Lambda Functions
Lambda functions are small anonymous one-line functions. Sometimes, we can simply refer to them as lambdas. Lambdas have the following syntax:
lambda arguments: expression
We declare a lambda function using the lambda keyword. Following this keyword, we specify the list of arguments, the number of which can vary from zero to multiple. We then specify the operations that we want to perform, which is known as the expression for the lambda function.
As you can see, lambdas have very concise syntax and thus they are most suitable for scenarios where a brief, single-time-use function is needed. Let’s consider the following example. The sorted() function is to sort an iterable based on the key function specified by the key argument:
>>> # define a list of tuples
>>> records = [(1, 'John'), (2, 'Aaron'), (5, 'Ian')]
>>> # sort with a lambda
>>> sorted(records, key=lambda x: len(x[1]))
[(5, 'Ian'), (1, 'John'), (2, 'Aaron')]
In the code above, we first define a list to store the records of some students with their student IDs and names. We then sort them with a lambda function, which sorts the list by the length of the student’s name.
For information about sorting using lambda functions, you can refer to my previous article. It’s also important to know that lambdas can be misused.
2. Closures
Closures are nested functions that capture non-local variables of the outer functions. I don’t think that it’s easy to understand closures conceptually. A thorough understanding requires in-depth knowledge of scopes and functions being first-class objects in Python. For the purpose of this article, let’s have an overall idea of closures by going over a tangible example:
>>> # create a closure
>>> def make_multiplier(coefficient):
... product = 1
...
... def multiplier():
... nonlocal product
... product *= coefficient
... return product
...
... return multiplier
...
In the code above, we define a function called make_multiplier. Because it contains the other function multiplier, we can call make_multiplier an outer function and call multiplier a nested function. The outer function returns the nested function as its return value. Importantly, the nested function uses and modifies a non-local variable (i.e. product) defined within the scope of the outer function. To sum up, there are three key elements to creating closures in Python:
- Declare a nested function within the scope of the outer function.
- The binding of non-local variables outside the scope of the nested function.
- Return the nested function to output the closure function.
How can we use closures? Let’s see the trivial example below:
>>> multipler3 = make_multiplier(3)
>>> multipler3()
3
>>> multipler3()
9
>>> multipler3()
27
>>> multipler3.__code__.co_freevars
('coefficient', 'product')
>>> multipler3.__closure__[1].cell_contents
27
We then declare a closure called multiplier3. Every time we call this closure, the product is multiplied by three. In other words, the closure “remembers” the state of the product after its last use. Related concepts include variable binding and value capturing. We can check the pertinent information by calling __code__.co_freevars and __closure__[1].cell_contents.
3. Decorators
Decorators are functions that extend the behavior of other functions without explicitly modifying them. In essence, decorators are a kind of higher-order function, which is defined as a function that either takes other functions as input or returns other functions as output. Let’s get a real feel for decorators through the example below:
>>> def clap():
... print("Clap! Clap!")
...
>>> # define a higher order function
>>> def triple_repeat_wrapper(func):
... def wrapper():
... print(f"Before calling func {func.__name__}")
... func()
... func()
... func()
... print(f"After calling func {func.__name__}")
... return wrapper
...
In the code above, we define two functions (clap and triple_repeat_wrapper), the latter of which is a higher-order function that calls the passed func three times within the nested wrapper function and returns the wrapper function as the higher-order function’s output.
How can we use these functions? As shown in the code below, we create a function called wrapped_clap that passes the clap function to the higher-order function triple_repeat_wrapper. As you can see, calling the wrapped_clap function will result in the code inside the nested wrapper function to be called. Consistent with the printed output, we get to know that the wrapped_clap function references the nested function wrapper.
>>> wrapped_clap = triple_repeat_wrapper(clap)
>>> wrapped_clap()
Before calling func clap
Clap! Clap!
Clap! Clap!
Clap! Clap!
After calling func clap
>>> wrapped_clap
<function triple_repeat_wrapper.<locals>.wrapper at 0x1038f0680>
But if you recall, when you’ve seen some example code about decorators, you must have seen the use of the @ symbol. How does this symbol come into play with the functions that we defined above? Let’s address this question by referring to the following code:
>>> @triple_repeat_wrapper
... def hooray():
... print("Hooray! Hooray!")
...
>>> hooray()
Before calling func hooray
Hooray! Hooray!
Hooray! Hooray!
Hooray! Hooray!
After calling func hooray
>>> hooray
<function triple_repeat_wrapper.<locals>.wrapper at 0x1038f0830>
In the code above, we declare a function called hooray. When we call this function, the output has the same format as the previous wrapped_clap function’s output. Similarly, the hooray function references the nested wrapper function.
Why does this happen? As you may have noticed, right above the declaration of this hooray function, we use the @ symbol prefixing the triple_repeat_wrapper function name. It’s just syntax sugar for the decorators. In essence, we’re telling the Python interpreter that the function that we’re going to define will be wrapped by the decorator function.
4. Currying
Named after the mathematician Haskell Curry, currying refers to creating new functions from existing functions by applying partial arguments. Thus, this concept is sometimes also termed partial functions.
Compared to the concepts above, this one is slightly easier to understand. Let’s consider the simplified example below, using the same function add_up that we defined above:
>>> # define a function returns a value
>>> def add_up(num1, num2):
... sum_n = num1+num2
... return sum_n
...
>>> # define a partial function that adds seven
>>> add_seven = lambda x: add_up(7, x)
>>> add_seven(10)
17
>>> add_seven(72)
79
>>> # use a regular def keyword
>>> def add_eight(x):
... return add_up(8, x)
...
>>> add_eight(10)
18
In the code above, we use the lambda function to set the number 7 as the first argument for the add_up function. In other words, the created add_seven function is a partial function of the original add_up with the first argument constantly set to be 7. Besides using the lambda function, it’s certainly acceptable to use the regular way to define a function with the def keyword.
Another handy tool to create partial functions is available in the functools module. Consider the following example. We use the partial function to create the add_ten function that has a default argument of 10 that’s calling the add_up function:
>>> # import the module
>>> from functools import partial
>>> # using the partial function
>>> add_ten = partial(add_up, 10)
>>> add_ten(100)
110
In this article, we reviewed four advanced concepts beyond the basics of Python functions. Here is a quick recap of these concepts:
- Lambdas are anonymous functions that are handy in scenarios where a simple one-time inline function is needed.
- Closures are nested functions that bind non-local variables of the surrounding scope.
- Decorators are higher-order functions that modify the behaviors of other functions.
- Currying is how we create partial functions from existing functions by setting some default arguments.
Thank you for reading!
#python #artificial intelligence #technology
