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%

Recursions and Reductions

In previous chapters, we've looked at several related kinds of processing designs; some of them are as follows:

Mapping and filtering, which creates collections from collections
Reductions that create a scalar value from a collection

The distinction is exemplified by functions such as map() and filter() that accomplish the first kind of collection processing. There are several specialized reduction functions, which include min(), max(), len(), and sum(). There's a general-purpose reduction function as well, functools.reduce().

We'll also consider a collections.Counter() function as a kind of reduction operator. It doesn't produce a single scalar value per se, but it does create a new organization of the data that eliminates some of the original structure. At heart, it's a kind of count-group-by operation that has more in common...

Search

Your notes and bookmarks