Functional Python Programming - Second Edition

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.

Title Page

Packt Upsell

Contributors

Preface

Free Chapter

Understanding Functional Programming

Understanding Functional Programming

Identifying a paradigm

Subdividing the procedural paradigm

A classic example of functional programming

Exploratory data analysis

Introducing Essential Functional Concepts

Introducing Essential Functional Concepts

First-class functions

Strict and non-strict evaluation

Recursion instead of an explicit loop state

Functional type systems

Familiar territory

Learning some advanced concepts

Functions, Iterators, and Generators

Functions, Iterators, and Generators

Writing pure functions

Functions as first-class objects

Using tuples and named tuples

Cleaning raw data with generator functions

Using lists, dicts, and sets

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

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

Recursions and Reductions

Recursions and Reductions

Simple numerical recursions

Group-by reduction from many items to fewer

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

The Itertools Module

The Itertools Module

Working with the infinite iterators

Using the finite iterators

Cloning iterators with tee()

The itertools recipes

More Itertools Techniques

More Itertools Techniques

Enumerating the Cartesian product

Reducing a product

Permuting a collection of values

Generating all combinations

The Functools Module

The Functools Module

Memoizing previous results with lru_cache

Defining classes with total ordering

Applying partial arguments with partial()

Reducing sets of data with the reduce() function

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

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

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

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

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

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

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Functional programming design patterns

There are a number of common design patterns for functional programming. These are typical approaches to functional programming that are used in a variety of contexts.

Note the important distinction from object-oriented design patterns. Many OO design patterns are designed to make management of state more explicit, or aid in composition of complex, emergent behavior. For functional design patterns, the focus is almost always on creating complex behavior from simpler pieces.

There are many common functional design approaches shown throughout this book. Most have not been presented with a particular name or story. In this section, we'll review a number of these patterns.

Currying: This can be called a partial function application and is implemented with the partial() function in the functools module. The idea is to create a new function based on an existing function plus some (but not all) of the function's arguments.
Closures: In Python, it's very easy...