Sign In Start Free Trial

Functional Python Programming

3.7 (3)

Functional Python Programming

3.7 (3)

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.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Understanding Functional Programming

Understanding Functional Programming

Identifying a paradigm

Subdividing the procedural paradigm

A classic example of functional programming

Exploratory data analysis

Summary

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

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

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

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

Recursions and Reductions

Recursions and Reductions

Simple numerical recursions

Group-by reduction from many items to fewer

Summary

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

The Itertools Module

The Itertools Module

Working with the infinite iterators

Using the finite iterators

Cloning iterators with tee()

The itertools recipes

Summary

More Itertools Techniques

More Itertools Techniques

Enumerating the Cartesian product

Reducing a product

Permuting a collection of values

Generating all combinations

Recipes

Summary

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

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

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

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

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

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

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

Customer Reviews

3.7 (3)

5 star

66.7%

4 star

0

3 star

0

2 star

0

1 star

33.3%

An overview of function varieties

We need to distinguish between two broad species of functions, as follows:

Scalar functions: They apply to individual values and compute an individual result. Functions such as abs(), pow(), and the entire math module are examples of scalar functions.
Collection functions: They work with iterable collections.

We can further subdivide the collection functions into three subspecies:

Reduction: This uses a function to fold values in the collection together, resulting in a single final value. For example, if we fold (+) operations into a sequence of integers, this will compute the sum. This can be also be called an aggregate function, as it produces a single aggregate value for an input collection.
Mapping: This applies a scalar function to each individual item of a collection; the result is a collection of the same size.
Filter: This...

Search

Your notes and bookmarks