Learn Functional Python Syntax in 10 Minutes [Tutorial]

In this article, you’ll learn what the functional paradigm is and how to use functional programming in Python. You’ll also learn about list comprehensions and other forms of comprehensions.

Functional paradigm

In an imperative paradigm, you do things by giving the computer a sequence of tasks and then it executes them. While executing them, it can change states.

A = 5

A

1 to n

Variables cannot vary. Once you set a variable, it stays that way forever (note, in purely functional languages they are not called variables). Because of this, functions have no side effects in the functional paradigm. A side effect is where the function changes something outside of it.

Let’s look at an example of some typical Python code:

a = 3 
def some_func(): 
    global a 
    a = 5 
some_func() 
print(a)

The output for this code is 5 . In the functional paradigm, changing variables is a big no-no and having functions affect things outside of their scope is also a big no-no. The only thing a function can do is calculate something and return it.

Now you might think: “no variables, no side effects? Why is this good?”. Good question, gnarly stranger reading this.

If a function is called twice with the same parameters, it’s guaranteed to return the same result. If you’ve learnt about mathematical functions , you’ll appreciate this benefit.

func(2)

Typically, in functional programming, we do not use loops. We use recursion. Recursion is a mathematical concept, it means “feeding into itself”. With a recursive function, the function calls itself as a sub-function.

Here’s a nice example of a recursive function in Python:

def factorial_recursive(n): 
    # Base case: 1! = 1 
    if n == 1: 
        return 1 
    # Recursive case: n! = n * (n-1)! 
    else: 
        return n * factorial_recursive(n-1)

2 + 2

Map

To understand map, let’s first look at what iterables are. An iterable is anything you can iterate over. These are lists or arrays, but Python has many different iterables. You can even create your own objects which are iterable by implementing magic methods. A magic method is like an API that helps your objects become more Pythonic.

You need to implement 2 magic methods to make an object an iterable:

class Counter:  
    def __init__(self, low, high): 
        # set class attributes inside the magic method __init__ 
        # for “inistalise” 
        self.current = low 
        self.high = high 
    def __iter__(self): 
        # first magic method to make this object iterable 
        return self 
    def __next__(self): 
        # second magic method 
        if self.current > self.high: 
            raise StopIteration 
        else: 
            self.current += 1 
            return self.current - 1

__iter__

__next__

Let’s go into a quick terminal session and check this out:

for c in Counter(3, 8): 
    print(c)

This will print:

__iter__

__next__

__iter__

Now we know what an iterable object is, let’s go back to the map function. The map function lets us apply a function to every item in an iterable. We want to apply a function to every item in a list, but know that it’s possible for most iterables. Map takes 2 inputs, the function to apply and the iterable object.

map(function, iterable)

[1, 2, 3, 4, 5]

x = [1, 2, 3, 4, 5] 
def square(num): 
    return num*num 
print(list(map(square, x)))

list()

It’s weird to go from non-lazy evaluation to lazy evaluation suddenly in Python. You’ll get used to it if you think more in the functional mindset than an imperative mindset.

square(num)

Lambda expressions

A lambda expression is a one line function. Take, for instance, this lambda expression which squares a number given to it:

square = lambda x: x * x

Now let’s run this:

>>> square(3) 
9

I hear you. “Brandon, where are the arguments? what the heck is this? that looks nothing like a function?”

square

this part:

lambda x:

tells Python that this is a lambda function, and the input is called x . Anything after the colon is what we do with the input, and it returns whatever the resultant of that is.

To simplfy our square program into one line we can do:

x = [1, 2, 3, 4, 5] 
print(list(map(lambda num: num * num, x)))

In a lambda expression, all the arguments go on the left and the stuff you want to do with them go on the right. It gets a little messy, no one can deny that. There’s a certain pleasure in writing code that only other functional programmers can read. Also, it’s super cool to take a function and turn it into a one-liner.

Reduce

Reduce is a function that turns an iterable into one thing. Normally we’ll perform a computation on a list to reduce it down to one number.

Reduce looks like this:

reduce(function, list)

We can (and often will) use lambda expressions as the function.

To program this:

product = 1 
x = [1, 2, 3, 4] 
for num in x: 
    product = product * num

But with reduce we can write:

from functools import reduce 
product = reduce((lambda x, y: x * y),[1, 2, 3, 4])

To get the same product. The code is shorter, and with knowledge of functional programming it is neater.

Filter

The filter function takes an iterable and filters out all the things we don’t want in that iterable.

Filter takes a function and a list. It applies the function to each item in the list and if that function returns True, it does nothing.

If it returns False, it removes that item from the list.

The syntax looks like:

filter(function, list)

Let’s see a small example, without filter we’ll write:

x = range(-5, 5) 
new_list = [] 
for num in x: 
    if num < 0: 
        new_list.append(num)

With filter, this becomes:

x = range(-5, 5) 
all_less_than_zero = list(filter(lambda num: num < 0, x))

Higher order functions

Higher order functions can take functions as parameters and return functions.

A very simple example would look like:

def summation(nums): 
    return sum(nums) 
def action(func, numbers): 
    return func(numbers) 
print(action(summation, [1, 2, 3])) 

# Output is 6

return functions

def rtnBrandon(): 
    return “brandon” 
def rtnJohn(): 
    return “john” 
def rtnPerson(): 
    age = int(input(“What’s your age?”)) 
    if age == 21: 
        return rtnBrandon() 
    else: 
        return rtnJohn()

You know earlier how I said that pure functional programming languages didn’t have variables?

Well, higher order functions makes this easier.

We need not store a variable anywhere if all we’re doing is passing data through a long tunnel of functions.

All functions in Python are first class objects.

We define a first class object as having one or more of these features:

• Created at runtime
• Assigned to a variable or element in a data structure
• Passed as an argument to a function
• Returned as the result of a function

So all functions in Python are first class and can used as a higher order function.

Partial application

Partial application (also called closures) is weird, but is cool. We can call a function without supplying all the arguments it requires. Let’s see this in an example.

We want to create a function which takes 2 arguments, a base and an exponent, and returns base to the power of the exponent, like so:

def power(base, exponent): 
    return base ** exponent

Now we want to have a dedicated square function, to work out the square of a number using the power function:

def square(base): 
  return power(base, 2)

This works, but what if we want a cube function? or a function to the power of 4? Can we keep on writing them forever? Well, we could.

But programmers are lazy. If we repeatedly do the same thing, it’s a sign that there is a much quicker way to speed things up and that will allow us to not repeat things. We can use partial applications here.

Let’s see an example of the square function using a partial application:

from functools import partial 
square = partial(power, exponent=2) 
print(square(2)) 

# output is 4

Isn’t that cool! We can call functions which require 2 arguments, using only 1 argument by telling Python what the second argument is.

We can also use a loop, to generate a power function that works from cubed all the way up to powers of 1000.

from functools import partial 
powers = [] 
for x in range(2, 1001): 
  powers.append(partial(power, exponent = x)) 
print(powers[0](3)) 

# output is 9

Functional programming isn’t Pythonic

You might have noticed, but a lot of the things we want to do in functional programming revolve around lists. Other than the reduce function & partial application, all the functions you have seen generate lists.

Guido (the inventor of Python) dislikes functional stuff in Python because Python already has its own way to generate lists.

If we write “import this” into a Python IDLE session, we’ll get:

>>> import this 
The Zen of Python, by Tim Peters 
Beautiful is better than ugly. 
Explicit is better than implicit. 
Simple is better than complex. 
Complex is better than complicated. 
Flat is better than nested. 
Sparse is better than dense. 
Readability counts. 
Special cases aren’t special enough to break the rules. 
Although practicality beats purity. 
Errors should never pass silently. 
Unless explicitly silenced. 
In the face of ambiguity, refuse the temptation to guess. 
There should be one-- and preferably only one --obvious way to do it. 
Although that way may not be obvious at first unless you’re Dutch. 
Now is better than never. 
Although never is often better than *right* now. 
If the implementation is hard to explain, it’s a bad idea. 
If the implementation is easy to explain, it may be a good idea. 
Namespaces are one honking great idea -- let’s do more of those!

This is the Zen of Python. It’s a poem about what something being Pythonic means.

> There should be one — and preferably only one — obvious way to do it.

In Python, map & filter can do the same things as a list comprehension (discussed next). This breaks one rule of the Zen of Python, so these parts of functional programming ‘pythonic’.

Another talking point is Lambda. In Python, a lambda function is a normal function. Lambda is syntactic sugar.

Both are equivalent:

foo = lambda a: 2 
def foo(a): 
  return 2

A regular function can do everything a lambda function can, but it doesn’t work the other way around. A lambda function cannot do everything that a regular function can do.

This was a short argument about why functional programming doesn’t fit into the whole Python ecosystem very well.

You may have noticed I mentioned list comprehensions earlier, we’ll discuss them now.

List comprehensions

Earlier, I mentioned that anything you could do with map or filter, you could do with a list comprehension. This is the part where we’ll learn about them. A list comprehension is a way to generate lists in Python.

The syntax is:

[function for item in iterable]

So let’s square every number in a list, as an example:

print([x * x for x in [1, 2, 3, 4]])

Okay, so we can see how we can apply a function to every item in a list. How do we go around applying a filter?

Well, look at this code from earlier:

x = range(-5, 5) 
all_less_than_zero = list(filter(lambda num: num < 0, x)) 
print(all_less_than_zero)

We can convert this into a list comprehension like so:

x = range(-5, 5) 
all_less_than_zero = [num for num in x if num < 0]

List comprehensions support if statements like this. You no longer need to apply a million functions to something to get what you want. In fact, if we’re trying to make some kind of list chances are that it’ll look cleaner and easier using a list comprehension.

What if we want to square every number below 0 in a list?

Well, with lambda, map and filter we’ll write:

x = range(-5, 5) 
all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))

This is long and complicated. With a list comprehension it is:

x = range(-5, 5) 
all_less_than_zero = [num * num for num in x if num < 0]

A list comprehension is only good for, well, lists. Map and filter work on any iterable, so what’s up with that? We can use any comprehension for any iterable object we encounter.

Other comprehensions

We can generate any iterable using a comprehension. Since Python 2.7, we can even generate a dictionary ( hashmap ).

# Taken from page 70 chapter 3 of Fluent Python by Luciano Ramalho 
DIAL_CODES = [     (86, ‘China’), 
    (91, ‘India’), 
    (1, ‘United States’), 
    (62, ‘Indonesia’), 
    (55, ‘Brazil’), 
    (92, ‘Pakistan’), 
    (880, ‘Bangladesh’), 
    (234, ‘Nigeria’), 
    (7, ‘Russia’), 
    (81, ‘Japan’), 
    ] 
>>> country_code = {country: code for code, country in DIAL_CODES} 
>>> country_code 
{’Brazil’: 55, ‘Indonesia’: 62, ‘Pakistan’: 92, ‘Russia’: 7, ‘China’: 86, ‘United States’: 1, ‘Japan’: 81, ‘India’: 91, ‘Nigeria’: 234, ‘Bangladesh’: 880} 
>>> {code: country.upper() for country, code in country_code.items() if code < 66} 
{1: ‘UNITED STATES’, 7: ‘RUSSIA’, 62: ‘INDONESIA’, 55: ‘BRAZIL’}

If it’s an iterable, we can generate it. Let’s look at one last example of sets. If you don’t know what a set is, check out this other article I wrote .

The TL;DR is:

• Sets are lists of elements, no element is repeated twice in that list
• The order in sets do not matter

# taken from page 87, chapter 3 of Fluent Python by Luciano Ramalho 
>>> from unicodedata import name 
>>> {chr(i) for i in range(32, 256) if ‘SIGN’ in name(chr(i), ‘’)} 
{’×’, ‘¥’, ‘°’, ‘£’, ‘©’, ‘¬’, ‘%’, ‘µ’, ‘>‘, ‘¤’, ‘±’, ‘¶’, ‘§’, ‘<’, ‘=’, ‘®’, ‘$’, ‘÷’, ‘¢’, ‘+’}

You may notice that sets have the same curly braces as dictionaries. Python is smart. It’ll know whether you’re writing a dictionary comprehension or a set comprehension based on whether you provide the extra value for the ditionary or not.

If you want to learn more about comprehensions, check out this visual guide .

If you want to learn more about comprehensions & generators, check out this article .

Conclusion

Functional programming is beautiful and pure. Functional code can be clean, but it can also be messy.

Some hardcore Python programmers dislike the functional paradigm in Python.

You should use what you want to use, use the best tool for the job.