LEARNING PATH: Python: Functional Programming with Python

Name: LEARNING PATH: Python: Functional Programming with Python
Rating: 4.5 (243 reviews)

Perceive functional programming with Python to efficiently solve real-world problems

Created byPackt Publishing

Last updated 5/2019

English

What you'll learn

Higher-order functions and Lambda expressions (nameless functions)
Error handling in Functional Programming
Understand common functional design patterns, and how these apply to Python
Understand what an iterator is in Python
Iterators and iterator functions built into Python
Create your own iterators
Understand what a generator coroutine is
Master list and dict comprehensions and generator expressions

Course content

2 sections • 45 lectures • 5h 37m total length

The Course Overview4:38
This video gives an overview of entire course.
Example – A Functional, Interactive Calculator11:46
In this video, we will see how a basic calculator application can be implement using two different programming styles, procedural and functional. By doing so, we will get a first taste of functional programming.
Pro – Stateless, Referentially Transparent Functions Produce the Same Result7:04
In this video, we will see what statelessness, side-effects, and referential transparency are.
Pro – You Can Prove That Code Is Correct at Least in Theory8:34
In this video, we will consider two ways of testing code, unit testing and through formal proofs.
Con – Complexity and Overly Deep Recursion6:11
In this video, we will consider recursion (functions that call themselves), which is often used in functional programming instead of loops.
Con – Functional Programming Can Be Unintuitive9:14
In this video, we will consider how functional programming doesn’t always match how humans think of the world as consisting of objects.
The Difference Between Statements and Expressions6:29
Functional programming relies heavily on expressions, and eschews statements. But what is the difference between the two? In this video, we will learn exactly how statements and expressions differ.
Diving into Lambda Expressions6:09
In this video, we will look at lambda expressions. This is the purest form of functional programming that Python offers. Lambda expressions are functions that consist of a single expression and which do not need to have a name.
Understanding ‘and’ and ‘or’7:22
In this video, we will take a closer look at ‘and’ and ‘or’.
Diving into Inline ‘if’ Expressions5:20
In this video, we will consider ‘if’ expressions. These are the functional alternatives to the far more commonly used ‘if’ statements.
Passing a Function as an Argument to Another Function9:17
In this video, we will consider how you can pass a function as an argument to another function. The receiving function is by definition a higher-order function.
Nesting a Function in Another Function6:41
In this video, we will look at nested functions, that is, functions that are defined inside other functions. We will also consider variable scope, that is, from which functions variables are accessible. These are important concepts for higher order functions.
Returning a Function from Another Function4:42
In this video, we will see how a higher-order function can return functions as return values.
The Operator Module – Operators as Regular Functions4:59
Because operators (+, -, /, and so on) are syntax and not objects, you cannot pass them as arguments or return values. To bypass this problem, the Python operator module offers all operators also as functions.
Decorators – The @ Prefix4:40
In this video, we will consider decorators. Decorators are an elegant and Pythonic syntax to implement specific kinds of higher-level functions.
Decorators with Arguments6:33
In this video, we will consider decorators that accept arguments. This makes the decorator design pattern even more flexible.
Currying – One Argument per Function7:32
In this video, we will look at currying, a technique for turning a function that takes multiple arguments into a chain of function that each take one argument.
Monads – Variables That Decide How They Should Be Treated7:07
In this video, we will look at monads. Most discussions of monads are complicated, and use lots of mathematical terminology. But, as we will see in this video, the idea of monads is really simple.
Memoization – Remembering Results7:15
In this video, we will look at memoization, which is a technique to optimize code by storing return values of functions.
You Cannot Catch Exceptions in Lambda Expressions4:56
In this video, we will look at exceptions, which are the standard Python approach to error handling.
Handling Errors in Lambda Expressions5:35
In this video, we will look at an alternative approach to error handling, using a Maybe-like decorator. This resembles the Maybe monad, but takes a more Pythonic approach.
Example – A Fully Functional, Interactive Calculator12:40
In this video, we will take everything that we’ve learned, and use this newly acquired knowledge to polish the interactive calculator that we developed at the start of this section with the help of all using a functional programming style.
Functional Programming in Python

The Course Overview5:20
This video gives an overview of entire course.
Using a List – Mutable Sequences of Elements with a Fixed Order10:39
In this video, we will first introduce important concepts –iterators, mutability, and order. Next, we will consider Python’s most common built-in iterator – the list.
Using a Tuple – Immutable Sequences of Elements with a Fixed Order5:10
In this video, we will take a look at the tuple, another very common iterator. We also consider some things you can do with Iterators in general (not only tuples).
Using a Dict – Mutable, Key-value Mappings Without a Fixed Order5:34
In this video, we will consider the dict, another common Python iterator; but very different from lists and tuples.
Using a Set – Immutable Collections of Unique Elements Without a Fixed Order4:11
In this video, we will introduce the set, another built-in iterator, but one that is focused more on mathematical situations.
Unpacking Iterators by Assigning to Multiple Variables6:11
In this video, we will consider iterator unpacking, a neat and, Python trick to assign multiple elements from an iterator to multiple variables – in a single statement.
What Is an Iterator?5:46
In this video, we consider theiterator protocol, which formally defines iterator objects, and describes the (minimum) functionality that iterators provide.
Creating Your Own Iterator6:49
In this video, we will see how you can write a class that implements theiterator protocol.
Exploring Generators9:09
In this video, we will considergenerators, which are functions that implement theiterator protocol in an elegant and simple way.
Lazy Evaluation6:28
In this video, we will show how you can use generators to implement lazy evaluation – evaluating elements from aniterator only if and when they are required.
Coroutines – Implementing Concurrency through Generators12:28
In this video, we will consider generator coroutines, which are generator functions that run in rapidly alternating suspend-resume cycles. This is sometimes called light-weight threading.
Convenience Iterators – The Collections Module10:02
In this video, we will consider the collections module, which is part of the Python standard library, and which provides several convenient predefined iterator objects.
List Comprehensions6:41
In this video, we first consider the difference between statements and expression. We then look at the list comprehension, which is an expressive alternative to the ‘for’ statement.
Dict Comprehensions4:16
In this video, we will look at the Dict comprehension, which is similar to the list comprehension, but for Dict objects.
Generator Expressions5:54
In this video, we will considergenerators expressions which are similar to list comprehensions but use generator.
Nested Comprehensions3:46
In this video, we will look at nested loops. Nested loops (that is a ‘for’ loop within a ‘for’ loop) are mostly used when you need all possible combinations of the elements of two lists. Nested comprehensions allow you to implement this very elegantly.
Using Convenience Functions11:23
In this video, we will look at four functions for working with iterators that are built into Python: zip(), map(), enumerate(), and filter().
Using Numerical and Logical Functions6:40
In this video, we will look at several built-in functions for performing numerical and logical operations on iterators.
The Itertools Module15:12
In this video, we will consider the most important functions from the itertools module, which is part of the Python standard library. The itertools module provides many convenient functions for working with iterators.
The Functools Module8:03
In this video, we first consider higher-order functions, which are functions that use other functions as arguments or return values. Then we move on to consider the most important functions from the functools module, which is part of the Python standard library, and provides convenient higher-order functions.
A Functional, Iterator-Based, Interactive Calculator12:20
In this video, we will consider generator coroutines, which are generator functions that run in rapidly alternating suspend-resume cycles. This is sometimes called light-weight threading.
Recognize the Most Suitable Programming Technique for the Job13:16
In this video, we will consider good coding practice. For most problems, many different solutions exist. In this course, we have considered solutions that rely on iterators. But, while iterators are powerful, they are not always the best solution to a given problem.
A Sensible Interactive Calculator Built with Various Programming Techniques7:16
In this video, we will consider an interactive calculator that is implemented using a sensible mix of programming techniques, including those that we’ve learned in this course.
Iterators in Functional Programming with Python

Requirements

Basic programming knowledge of Python is needed.

Description

Python is not a functional programming language, but it is a multi-paradigm language that makes functional programming easy to perform, and easy to mix with other programming styles. Python is a high level language used in many development areas, like web development, data analysis, desktop UI and system administration. Functional programming is a style of programming that is characterized by short functions, lack of statements, and little reliance on variables. You will learn what functional programming is, and how you can apply functional programming in Python. If you're interested to use Functional Programming as a powerful tool to solve many real-world problems by writing robust and bug-free code, then go for this Learning Path.

Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

The highlights of this Learning Path are:

Understand common functional design patterns, and how these apply to Python
Learn the important role that iterators play in functional programming

In this Learning Path, you’ll learn what functional programming is, and how it differs from other programming styles, such as procedural and object-oriented programming. Then you’ll go on to explore lambda expressions, which are short one-line functions, and are the purest form of functional programming that Python offers. Next, you’ll learn about higher-order functions: functions that accept other functions as an argument, or return other functions as return values. You’ll also encounter important concepts from functional programming, such as monads, currying, statelessness, side-effects, memorization, and referential transparency; these concepts may initially seem odd to Python programmers, but you’ll see how they are elegantly supported by the language.

Further, you’ll learn everything there is to know about iterators in Python and how crucial they are in functional programming, where they are used, among other things, to implement repetitive logic and coroutines. You’ll learn about all standard iterators and iterator functions that Python offers. You’ll also learn to implement your own iterators. Functional programming makes heavy use of iterators, and you’ll learn how you can use them in functional programming through an interactive calculator application.

By the end of this Learning Path, you will get a thorough understanding of iterators to solve many real-world problems by writing robust, testable, and bug-free code.

Meet Your Expert:

We have combined the best works of the following esteemed authors to ensure that your learning journey is smooth:

SebastiaanMathôt currently works as assistant professor at the University of Groningen in the Netherlands. He is the lead developer at OpenSesame, which is an open-source, Python-based program for implementing psychology and neuroscience experiments. Sebastiaan is also the designer of DataMatrix, a Python library for numeric computing that is focused on elegance and readability. Sebastiaan also gives regular workshops on using OpenSesame and Python for scientific purposes, and regularly publishes Python tutorials on his YouTube channel. As such, he has extensive experience in teaching Python and making advanced topics seem as easy as possible.

Who this course is for:

This Learning Path is intended for developers who have a basic understanding of Python and want to expand their developer toolbox with important new techniques.

LEARNING PATH: Python: Functional Programming with Python

What you'll learn

Explore related topics

Course content

Functional Programming in Python22 lectures • 2hr 35min

Iterators in Functional Programming with Python23 lectures • 3hr 3min

Requirements

Description

Who this course is for: