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

Optimizing storage

There's no general rule for optimization. We often focus on optimizing performance because we have tools such as the Big O measure of complexity that show us whether or not an algorithm is an effective solution to a given problem. Optimizing storage is usually tackled separately: we can look at the steps in an algorithm and estimate the size of the storage required for the various storage structures.

In many cases, the two considerations are opposed. In some cases, an algorithm that has outstandingly good performance requires a large data structure. This algorithm can't scale without dramatic increases in the amount of storage required. Our goal is to design an algorithm that is reasonably fast and also uses an acceptable amount of storage.

We may have to spend time researching algorithmic alternatives to locate a way to make the space-time trade off properly. There are some common optimization techniques. We can often follow links from Wikipedia:

http://en.wikipedia.org...