Functional Programming With Python

A beginner-friendly introduction to functional constructs in python

What you'll learn

Practical fluency with map, filter, reduce, zip, any, all, list, set, dictionary, and generator comprehensions, and generator expressions

Complete coverage of intermediate functional constructs in Python: generators, iterators, decorators, closures, recursion, and much more!

A practical exploration of advanced topics: closures, recursion, partial function application, currying, memoization, infinite iterators, and overloading

A conceptual understanding of the key tenets of functional programming: immutability, purity, higher-order functions, recursion, and referential transparency

Requirements

No prior Python programming experience is required - this course is beginner friendly

A basic understanding of programming concepts is helpful, but not required

Description

Welcome to the best and most comprehensive introduction to functional programming in Python!In this beginner-friendly course, you will get to learn and practice Python's functional capabilities step-by-step, from the ground up. The course will begin with a conceptual understanding of the key tenets of functional programming: immutability: the idea that data should not be modified in placepurity: the practice of writing functions that do not cause side effectshigher-order functions: treating functions as pari passu with other data typesrecursion: the pattern of writing functions that call themselvesreferential transparency: the principle that a function call can be replaced with its return value without changing the program's behaviorThen, we will explore practical utilities that Python offers to help us write functional code, including:map, filter, reduce, zip, any, all: utilities for working with iterableslist, set, dictionary, and generator comprehensions: concise ways of creating lists, sets, dictionaries, and generatorsgenerator functions and iterators: functions that can be paused and resumedvariable arity: functions that can take a variable number of arguments, unknown at the time of writing the function In the final, and longest part of the course, we will take a look at more advanced topics, including:closures: higher-order functions that can access non-local variablesrecursion: functions that call themselvespartial function application: functions that return other functions, with some arguments pre-filledcurrying: a special case of partial function applicationmemoization: caching the results of function calls to speed up executioninfinite iterators: iterators that never endfunctional overloading: functions that behave differently depending on their inputsThroughtout the course, you will get to practice your newly acquired skills through a set of more than 20 skill challenges, each of which will be followed with a detailed video explanation of the solution that we will walk through together.This course is very beginner-friendly and no python experience is assumed. If you've never worked with Python before, there's a full length introduction to Python programming included as an appendix, covering the fundamentals of the language from the basic data types to containers, control flow, loops, classes, and more. See you inside!

Overview

Section 1: PLEASE DO NOT SKIP

Lecture 1 Very Short Intro

Lecture 2 All Course Notebooks

Section 2: The Five Tenets Of Functional Programming

Lecture 3 The Functional Paradigm

Lecture 4 Section Notebook

Section 3: Functions As First-Class Objects

Lecture 5 Passing Functions As Arguments

Lecture 6 Functions Returning Functions

Lecture 7 Skill Challenge

Lecture 8 Solution

Lecture 9 Section Notebook

Section 4: Functions In Data Structures

Lecture 10 Lists Of Functions

Lecture 11 Skill Challenge

Lecture 12 Solution

Lecture 13 Section Notebook

Section 5: HOFs At A Glance

Lecture 14 Order And Higher-Order Functions

Lecture 15 Skill Challenge

Lecture 16 Solution

Lecture 17 Section Notebook

Section 6: Purity And Side Effects

Lecture 18 Impure Functions

Lecture 19 Purity Is Eliminating (Realistically, Isolating) The Side Effects

Lecture 20 Section Notebook

Section 7: Laziness

Lecture 21 Lazy vs Eager Evaluation

Lecture 22 Chaining Lazy Operations

Lecture 23 Section Notebook

Section 8: Immutability

Lecture 24 Mutable Lists

Lecture 25 Skill Challenge

Lecture 26 Solution

Lecture 27 Extra: Undo/Redo Operations With Immutable Data

Lecture 28 Section Notebook

Section 9: Aliasing

Lecture 29 Aliasing And Unintended Side Effects

Lecture 30 Section Notebook

Section 10: Lambdas

Lecture 31 Anonymous Functions

Lecture 32 A Single Expression

Lecture 33 Good And Bad Uses

Lecture 34 Nesting And In-Place Lambdas

Lecture 35 Skill Challenge

Lecture 36 Solution

Lecture 37 Section Notebook

Section 11: Map

Lecture 38 Transformations

Lecture 39 Mapping Over Multiple Iterables

Lecture 40 Built-Ins

Lecture 41 Skill Challenge

Lecture 42 Solution

Lecture 43 Section Notebook

Section 12: Zip

Lecture 44 The Basic Zip

Lecture 45 Strict Mode

Lecture 46 Unzipping With Splat

Lecture 47 Building Dicts

Lecture 48 Extra: Functional Pipelining

Lecture 49 Skill Challenge

Lecture 50 Solution

Lecture 51 Section Notebook

Section 13: Filter

Lecture 52 Declarative Select

Lecture 53 Multiple Conditions

Lecture 54 Extra: Nested Lambdas

Lecture 55 Chained Filtering

Lecture 56 Skill Challenge

Lecture 57 Solution

Lecture 58 Extra: Alternative Solution With namedtuple

Lecture 59 Section Notebook

Section 14: Any And All

Lecture 60 Any

Lecture 61 All

Lecture 62 Any And All With Filter And Map

Lecture 63 Negation

Lecture 64 Short Circuiting Logic

Lecture 65 Skill Challenge

Lecture 66 Solution

Lecture 67 Section Notebook

Section 15: Reduce

Lecture 68 Accumulate

Lecture 69 The Initial Accumulator

Lecture 70 Skill Challenge

Lecture 71 Solution

Lecture 72 More Applications

Lecture 73 Skill Challenge - Run Length Encoding

Lecture 74 Solution

Lecture 75 Section Notebook

Section 16: Comprehensions

Lecture 76 Introduction To Comprehensions

Lecture 77 Nested List Comprehensions

Lecture 78 Comprehensions Over Multiple Iterables

Lecture 79 Skill Challenge

Lecture 80 Solution

Lecture 81 Section Notebook

Section 17: Set Comprehensions

Lecture 82 From Lists To Sets

Lecture 83 More Advanced Operations

Lecture 84 Skill Challenge

Lecture 85 Solution

Lecture 86 Extra Skill Challenge: Efficient Primes

Lecture 87 Solution

Lecture 88 Section Notebook

Section 18: Dictionary Comprehensions

Lecture 89 Building New Dictionaries

Lecture 90 More Use Cases

Lecture 91 Skill Challenge

Lecture 92 Solution

Lecture 93 Alternative Solution

Lecture 94 Section Notebook

Section 19: Iterators

Lecture 95 Concepts And Foundations

Lecture 96 Implementing The Iterator Protocol

Lecture 97 Section Notebook

Section 20: Generators

Lecture 98 Introduction To Generator Functions

Lecture 99 Generator Expressions

Lecture 100 Two-Way Communication With Generators

Lecture 101 Skill Challenge: Infinite Fibonacci Generator

Lecture 102 Solution

Lecture 103 Alternative Solution

Lecture 104 Extra: Sliding Window Fibonacci With Deque

Lecture 105 Data Pipelining Using Generators

Lecture 106 Section Notebook

Section 21: Variadics

Lecture 107 *args and **kwargs

Lecture 108 Skill Challenge

Lecture 109 Solution

Lecture 110 Section Notebook

Section 22: Nested HOFs

Lecture 111 Higher Order Functions Revisited

Lecture 112 Skill Challenge

Lecture 113 Solution

Lecture 114 Section Notebook

Section 23: Closures

Lecture 115 What Is A Closure?

Lecture 116 Skill Challenge

Lecture 117 Solution

Lecture 118 Section Notebook

Section 24: Decorators

Lecture 119 Introduction To Decorators

Lecture 120 Decorating Parameterized Functions

Lecture 121 Skill Challenge

Lecture 122 Solution

Lecture 123 Section Notebook

Section 25: Advanced Decorators

Lecture 124 Advanced Decorators

Lecture 125 Chaining Multiple Decorators

Lecture 126 Preserving Identity With @wraps

Lecture 127 Skill Challenge

Lecture 128 Solution

Lecture 129 Section Notebook

Section 26: Recursion

Lecture 130 Introduction To Recursion

Lecture 131 Recursion Trees And Recurrence Relations

Lecture 132 Skill Challenge

Lecture 133 Solution

Lecture 134 Tail Recursion And Recursion Limits In Python

Lecture 135 Mutual Recursion

Lecture 136 Parsing Structured Data With Recursive Functions

Lecture 137 A Slight Improvement

Lecture 138 Skill Challenge - Recursive Binary Search

Lecture 139 Solution

Lecture 140 Skill Challenge - Refactored Signature

Lecture 141 Solution

Lecture 142 Section Notebook

Section 27: Memoization

Lecture 143 A Conceptual Understanding

Lecture 144 Defining A Memoization Function

Lecture 145 Predefined Caching Utilities

Lecture 146 Extra: Inline Memoization

Lecture 147 Section Notebook

Section 28: Currying And Partials

Lecture 148 Partial Function Application

Lecture 149 Skill Challenge

Lecture 150 Solution

Lecture 151 Section Notebook

Section 29: Overloading And Polymorphism With singledispatch

Lecture 152 Polymorphic Functions

Lecture 153 A Quick Gotcha

Lecture 154 Skill Challenge

Lecture 155 Solution

Lecture 156 Section Notebook

Section 30: Infinite Iterators

Lecture 157 Count

Lecture 158 Infinite Cycles

Lecture 159 Finite Cycles With Repeat

Lecture 160 Skill Challenge

Lecture 161 Solution

Lecture 162 Section Notebook

Section 31: Appendix: Complete Python Fundamentals In Less Than 3 Hours

Lecture 163 Please Note

Lecture 164 Section Intro

Lecture 165 Data Types

Lecture 166 Variables

Lecture 167 Arithmetic And Augmented Assignment Operators

Lecture 168 Ints And Floats

Lecture 169 Booleans And Comparison Operators

Lecture 170 Strings

Lecture 171 Methods

Lecture 172 Containers I: Lists

Lecture 173 Lists vs. Strings

Lecture 174 List Methods And Functions

Lecture 175 Containers II: Tuples

Lecture 176 Containers III: Sets

Lecture 177 Containers IV: Dictionaries

Lecture 178 Dictionary Keys And Values

Lecture 179 Membership Operators

Lecture 180 Controlling Flow: if, else, And elif

Lecture 181 Truth Value Of Non-booleans

Lecture 182 For Loops

Lecture 183 The range() Immutable Sequence

Lecture 184 While Loops

Lecture 185 Break And Continue

Lecture 186 Zipping Iterables

Lecture 187 List Comprehensions

Lecture 188 Defining Functions

Lecture 189 Function Arguments: Positional vs Keyword

Lecture 190 Lambdas

Lecture 191 Importing Modules

This course is for anyone who wants to learn functional programming in Python from the very basics,Beginners to programming interested in writing concise, readable, and maintainable Python,Beginner Python developers with an interest in functional programming,Intermediate programmers with no exposure to functional constructs in Python