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

Exploratory data analysis

Later in this book, we'll use the field of exploratory data analysis (EDA) as a source for concrete examples of functional programming. This field is rich with algorithms and approaches to working with complex datasets; functional programming is often a very good fit between the problem domain and automated solutions.

While details vary from author to author, there are several widely accepted stages of EDA. These include the following:

Data preparation: This might involve extraction and transformation for source applications. It might involve parsing a source data format and doing some kind of data scrubbing to remove unusable or invalid data. This is an excellent application of functional design techniques.
Data exploration: This is a description of the available data. This usually involves the essential statistical functions. This is another excellent place to explore functional programming. We can describe our focus as univariate and bivariate statistics but that sounds too daunting and complex. What this really means is that we'll focus on mean, median, mode, and other related descriptive statistics. Data exploration may also involve data visualization. We'll skirt this issue because it doesn't involve very much functional programming. I'll suggest that you use a toolkit such as SciPy. Visit the following links to get more information how SciPY works and its usage:
- https://www.packtpub.com/big-data-and-business-intelligence/learning-scipy-numerical-and-scientific-computing
- https://www.packtpub.com/big-data-and-business-intelligence/learning-python-data-visualization
Data modeling and machine learning: This tends to be proscriptive as it involves extending a model to new data. We're going to skirt around this because some of the models can become mathematically complex. If we spend too much time on these topics, we won't be able to focus on functional programming.
Evaluation and comparison: When there are alternative models, each must be evaluated to determine which is a better fit for the available data. This can involve ordinary descriptive statistics of model outputs. This can benefit from functional design techniques.

The goal of EDA is often to create a model that can be deployed as a decision support application. In many cases, a model might be a simple function. A simple functional programming approach can apply the model to new data and display results for human consumption.