Book Image

Functional Python Programming - Second Edition

By : Steven F. Lott
Book Image

Functional Python Programming - Second Edition

By: Steven F. Lott

Overview of this book

If you’re a Python developer who wants to discover how to take the power of functional programming (FP) and bring it into your own programs, then this book is essential for you, even if you know next to nothing about the paradigm. Starting with a general overview of functional concepts, you’ll explore common functional features such as first-class and higher-order functions, pure functions, and more. You’ll see how these are accomplished in Python 3.6 to give you the core foundations you’ll build upon. After that, you’ll discover common functional optimizations for Python to help your apps reach even higher speeds. You’ll learn FP concepts such as lazy evaluation using Python’s generator functions and expressions. Moving forward, you’ll learn to design and implement decorators to create composite functions. You'll also explore data preparation techniques and data exploration in depth, and see how the Python standard library fits the functional programming model. Finally, to top off your journey into the world of functional Python, you’ll at look at the PyMonad project and some larger examples to put everything into perspective.

Related Content you might be interested in

Current Title:

Small book image
Functional Python Programming - Second Edition
Steven F. Lott
Apr, 2018 | 408 pages
Small book image
Modern Python Cookbook.
Steven F Lott
Jul, 2020 | 822 pages
Small book image
Mastering Object-Oriented Python.
Steven F Lott
Jun, 2019 | 770 pages
Small book image
Python Object-Oriented Programming
Steven F Lott | Dusty Phillips
Jul, 2021 | 714 pages
Table of Contents (22 chapters)
Title Page
Title Page
Packt Upsell
Packt Upsell
Contributors
Contributors
Preface
Preface
Free Chapter
1
Understanding Functional Programming
Understanding Functional Programming
Identifying a paradigm
Subdividing the procedural paradigm
A classic example of functional programming
Exploratory data analysis
Summary
2
Introducing Essential Functional Concepts
Introducing Essential Functional Concepts
First-class functions
Immutable data
Strict and non-strict evaluation
Recursion instead of an explicit loop state
Functional type systems
Familiar territory
Learning some advanced concepts
Summary
3
Functions, Iterators, and Generators
Functions, Iterators, and Generators
Writing pure functions
Functions as first-class objects
Using strings
Using tuples and named tuples
Cleaning raw data with generator functions
Using lists, dicts, and sets
Summary
4
Working with Collections
Working with Collections
An overview of function varieties
Working with iterables
Using zip() to structure and flatten sequences
Using reversed() to change the order
Using enumerate() to include a sequence number
Summary
5
Higher-Order Functions
Higher-Order Functions
Using max() and min() to find extrema
Using Python lambda forms
Lambdas and the lambda calculus
Using the map() function to apply a function to a collection
Using map() with multiple sequences
Using the filter() function to pass or reject data
Using filter() to identify outliers
The iter() function with a sentinel value
Using sorted() to put data in order
Writing higher-order functions
Writing higher-order mappings and filters
Writing generator functions
Building higher-order functions with callables
Review of some design patterns
Summary
6
Recursions and Reductions
Recursions and Reductions
Simple numerical recursions
Group-by reduction from many items to fewer
Summary
7
Additional Tuple Techniques
Additional Tuple Techniques
Using tuples to collect data
Using named tuples to collect data
Building named tuples with functional constructors
Avoiding stateful classes by using families of tuples
Polymorphism and type-pattern matching
Summary
8
The Itertools Module
The Itertools Module
Working with the infinite iterators
Using the finite iterators
Cloning iterators with tee()
The itertools recipes
Summary
9
More Itertools Techniques
More Itertools Techniques
Enumerating the Cartesian product
Reducing a product
Permuting a collection of values
Generating all combinations
Recipes
Summary
10
The Functools Module
The Functools Module
Function tools
Memoizing previous results with lru_cache
Defining classes with total ordering
Applying partial arguments with partial()
Reducing sets of data with the reduce() function
Summary
11
Decorator Design Techniques
Decorator Design Techniques
Decorators as higher-order functions
Cross-cutting concerns
Composite design
Adding a parameter to a decorator
Implementing more complex decorators
Complex design considerations
Summary
12
The Multiprocessing and Threading Modules
The Multiprocessing and Threading Modules
Functional programming and concurrency
What concurrency really means
Using multiprocessing pools and tasks
Using a multiprocessing pool for concurrent processing
Summary
13
Conditional Expressions and the Operator Module
Conditional Expressions and the Operator Module
Evaluating conditional expressions
Using the operator module instead of lambdas
Starmapping with operators
Reducing with operator module functions
Summary
14
The PyMonad Library
The PyMonad Library
Downloading and installing
Functional composition and currying
Functional composition and the PyMonad * operator
Functors and applicative functors
Monad bind() function and the >> operator
Implementing simulation with monads
Additional PyMonad features
Summary
15
A Functional Approach to Web Services
A Functional Approach to Web Services
The HTTP request-response model
The WSGI standard
Defining web services as functions
Tracking usage
Summary
16
Optimizations and Improvements
Optimizations and Improvements
Memoization and caching
Specializing memoization
Tail recursion optimizations
Optimizing storage
Optimizing accuracy
Case study–making a chi-squared decision
Computing expected values and displaying a contingency table
Functional programming design patterns
Summary
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Lambdas and the lambda calculus

In a book on a purely functional programming language, it would be necessary to explain lambda calculus, and the technique invented by Haskell Curry that we call currying. Python, however, doesn't stick closely to this kind of lambda calculus. Functions are not curried to reduce them to single-argument lambda forms.

Python lambda forms are not restricted to single argument functions. They can have any number of arguments. They are restricted to a single expression, however.

We can, using thefunctools.partialfunction, implement currying. We'll save this forChapter 10,The Functools Module.

Previous Section
End of Section 4
Next Section