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.

In this video, we will see what statelessness, side-effects, and referential transparency are.

In this video, we will consider two ways of testing code, unit testing and through formal proofs.

In this video, we will consider recursion (functions that call themselves), which is often used in functional programming instead of loops.

In this video, we will consider how functional programming doesn’t always match how humans think of the world as consisting of objects.

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.

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. 

In this video, we will take a closer look at ‘and’ and ‘or’. 

In this video, we will consider ‘if’ expressions. These are the functional alternatives to the far more commonly used ‘if’ statements.

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.

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.

In this video, we will see how a higher-order function can return functions as return values.

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.

In this video, we will consider decorators. Decorators are an elegant and Pythonic syntax to implement specific kinds of higher-level functions.

In this video, we will consider decorators that accept arguments. This makes the decorator design pattern even more flexible.

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.

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.

In this video, we will look at memoization, which is a technique to optimize code by storing return values of functions.

In this video, we will look at exceptions, which are the standard Python approach to error handling.

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.

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.

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.

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).

In this video, we will consider the dict, another common Python iterator; but very different from lists and tuples.

In this video, we will introduce the set, another built-in iterator, but one that is focused more on mathematical situations.

In this video, we consider theiterator protocol, which formally defines iterator objects, and describes the (minimum) functionality that iterators provide.

In this video, we will see how you can write a class that implements theiterator protocol.

In this video, we will considergenerators, which are functions that implement theiterator protocol in an elegant and simple way.

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.

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.

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.

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.

In this video, we will look at the Dict comprehension, which is similar to the list comprehension, but for Dict objects.

In this video, we will considergenerators expressions which are similar to list comprehensions but use generator.

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.

In this video, we will look at four functions for working with iterators that are built into Python: zip(), map(), enumerate(), and filter().

In this video, we will look at several built-in functions for performing numerical and logical operations on iterators.

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. 

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.

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.       

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.

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.