Functional Programming in Python

Dan Bader 32 Lessons 1h 25m
advanced python

In this course, you’ll learn how to approach functional programming in Python. You’ll start with the absolute basics of Functional Programming (FP). After that, you’ll see hands-on examples for common FP patterns available, like using immutable data structures and the filter(), map(), and reduce() functions. You’ll end the course with actionable tips for parallelizing your code to make it run faster.

You’ll cover:

What functional programming is
How you can use immutable data structures to represent your data
How to use filter(), map(), and reduce()
How to do parallel processing with multiprocessing and concurrent.futures

Get Started

Section 1: Immutable Data Structures

6 Lessons 17m

1. Functional Programming Course Overview 01:15

2. What Is Functional Programming? 04:02

3. Mutable Data Structures: Lists and Dictionaries 03:48

4. Immutable Data Structures: namedtuple 03:39

5. Danger Zone: Mixing Mutable and Immutable Data Structures 01:35

6. Immutable Data Structures: Tuples 02:56

Section 2: The filter() Function

5 Lessons 13m

1. The filter() Function: Overview 00:43

2. What Is the filter() Function? 03:17

3. Storing Filtered Data in a Tuple 02:39

4. Why Use the filter() Function? 03:46

5. Filtering List Comprehensions 03:33

Section 3: The map() Function

5 Lessons 11m

1. The map() Function: Overview 00:53

2. What Is the map() Function? 02:13

3. How to Use the map() Function 04:25

4. The map() Function vs Generator Expressions 02:28

5. Why Use the map() Function? 01:50

Section 4: The reduce() Function

4 Lessons 16m

1. The reduce() Function: Overview 01:33

2. What Is the reduce() Function? 04:49

3. Why Use the reduce() Function? 06:25

4. Grouping Data With itertools.groupby() 03:20

Section 5: Parallel Processing With multiprocessing

7 Lessons 16m

1. Parallel Processing With multiprocessing: Overview 00:48

2. Multiprocessing Testbed Overview 03:40

3. The multiprocessing Module 01:03

4. Measuring Execution Time in the multiprocessing Testbed 02:07

5. How to Create a multiprocessing.Pool() Object 01:40

6. How to Use multiprocessing.Pool() 05:14

7. Parallel Processing With multiprocessing: Conclusion 01:35

Section 6: Parallel Processing With concurrent.futures

5 Lessons 9m

1. Parallel Processing With concurrent.futures: Overview 01:55

2. The concurrent.futures Module 02:45

3. How Functional Programing Makes Parallel Processing Simple 01:38

4. concurrent.futures vs multiprocessing 01:06

5. When to Use concurrent.futures or multiprocessing 02:24

Get Started

About Dan Bader

Dan Bader is the owner and editor in chief of Real Python and the main developer of the realpython.com learning platform. Dan has been writing code for more than 20 years and holds a master's degree in computer science.

» More about Dan

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Tappan

Joanna

Participant Comments

Ghani on Oct. 14, 2020

This functional programming course is really excellent! Although I need to revise it and chew it again, I learned plenty of ways I can make my code more efficient. Thanks Dan.

milangnjatovic on April 28, 2020

Great course and even greater presentation. Keep it up.

bennjuguna0 on April 13, 2020

Honestly thought it would be harder than this. Many thanks to you for the awesome tutorials.

George Yeboah on April 10, 2020

Good tutorial I really enjoyed watching it and picking up some cool techniques from it Great work keep it up

zorion on April 8, 2020

Awesome, thanks Dan! I finally understand what GIL blocks. It was always a black box for me, I knew that there was something wrong in Python parallelism but I didn’t know that it was restricted to threads while computing. Good to know, Good to know!

tinachoudhary on April 6, 2020

Thanks a lot for the tutorial, it is explained well.

Axel FAUVEL on March 27, 2020

Thanks a lot for this course, very well explained :)

mikesult on March 3, 2020

Great tutorial in functional programming. I learned a lot. I’d like to share a newbie mistake I made in the last section. I typed in the code from the video but I named it concurrent.py (bad mistake) and when I tried to run, it caused an error:

ModuleNotFoundError: 
No module named 'concurrent.futures'
'concurrent' is not a package

I fumbled with this for most of the day trying to figure out the problem before I finally found a post from a few years back on stackoverflow that had the same error and one of the answering comments included ‘…Either that or you’re shadowing concurrent. Do you have a concurrent.py?’

Umm, yes I do.

Once I renamed the file it worked as expected.

So I learned that you shouldn’t name your file the same name as a package name. Of course it seems so obvious now.

Thanks for a great intro to the functional programming style.

Donna van Wyk on Sept. 24, 2019

Wow. I’ve been learning about python a lot of diff ways. Your “simple” explanation of a lambda here finally made it click. I am so excited to go thru all of the courses and really get somewhere.

Shay Elmualem on Aug. 3, 2019

This is great stuff Dan, thanks! I normally, out of habit, just go with the “manual” approach of iterating/looping over and just getting/saving the data I need, I really need to start using these built-ins more! very cool.

senatoduro8 on July 25, 2019

Thanks Dan. This tutorial is great! It did help me learn new was to use the map, reduce and apply functions creatively.

konk on July 5, 2019

Good tutorial. I’d read about python multiprocessing/threading, but had not yet implemented it. Seeing it in action in this tutorial - wow - quite easy to get going. No reason not to implement when it will help.

« Browse All Courses