Functional Python Programming电子书

Functional Python Programming

Table of Contents

Functional Python Programming

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Introducing Functional Programming

Identifying a paradigm

Subdividing the procedural paradigm

Using the functional paradigm

Using a functional hybrid

Looking at object creation

The stack of turtles

A classic example of functional programming

Exploratory Data Analysis

Summary

2. Introducing Some Functional Features

First-class functions

Pure functions

Higher-order functions

Immutable data

Strict and non-strict evaluation

Recursion instead of a explicit loop state

Functional type systems

Familiar territory

Saving some advanced concepts

Summary

3. Functions, Iterators, and Generators

Writing pure functions

Functions as first-class objects

Using strings

Using tuples and namedtuples

Using generator expressions

Exploring the limitations of generators

Combining generator expressions

Cleaning raw data with generator functions

Using lists, dicts, and sets

Using stateful mappings

Using the bisect module to create a mapping

Using stateful sets

Summary

4. Working with Collections

An overview of function varieties

Working with iterables

Parsing an XML file

Parsing a file at a higher level

Pairing up items from a sequence

Using the iter() function explicitly

Extending a simple loop

Applying generator expressions to scalar functions

Using any() and all() as reductions

Using len() and sum()

Using sums and counts for statistics

Using zip() to structure and flatten sequences

Unzipping a zipped sequence

Flattening sequences

Structuring flat sequences

Structuring flat sequences—an alternative approach

Using reversed() to change the order

Using enumerate() to include a sequence number

Summary

5. 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

Working with lambda forms and map()

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

Unwrapping data while mapping

Wrapping additional data while mapping

Flattening data while mapping

Structuring data while filtering

Writing generator functions

Building higher-order functions with Callables

Assuring good functional design

Looking at some of the design patterns

Summary

6. Recursions and Reductions

Simple numerical recursions

Implementing tail-call optimization

Leaving recursion in place

Handling difficult tail-call optimization

Processing collections via recursion

Tail-call optimization for collections

Reductions and folding – from many to one

Group-by reductions – from many to fewer

Building a mapping with Counter

Building a mapping by sorting

Grouping or partitioning data by key values

Writing more general group-by reductions

Writing higher-order reductions

Writing file parsers

Parsing CSV files

Parsing plain text files with headers

Summary

7. Additional Tuple Techniques

Using an immutable namedtuple as a record

Building namedtuples with functional constructors

Avoiding stateful classes by using families of tuples

Assigning statistical ranks

Wrapping instead of state changing

Rewrapping instead of state changing

Computing the Spearman rank-order correlation

Polymorphism and Pythonic pattern matching

Summary

8. The Itertools Module

Working with the infinite iterators

Counting with count()

Reiterating a cycle with cycle()

Repeating a single value with repeat()

Using the finite iterators

Assigning numbers with enumerate()

Running totals with accumulate()

Combining iterators with chain()

Partitioning an iterator with groupby()

Merging iterables with zip_longest() and zip()

Filtering with compress()

Picking subsets with islice()

Stateful filtering with dropwhile() and takewhile()

Two approaches to filtering with filterfalse() and filter()

Applying a function to data via starmap() and map()

Cloning iterators with tee()

The itertools recipes

Summary

9. More Itertools Techniques

Enumerating the Cartesian product

Reducing a product

Computing distances

Getting all pixels and all colors

Performance analysis

Rearranging the problem

Combining two transformations

Permuting a collection of values

Generating all combinations

Recipes

Summary

10. The Functools Module

Function tools

Memoizing previous results with lru_cache

Defining classes with total ordering

Defining number classes

Applying partial arguments with partial()

Reducing sets of data with reduce()

Combining map() and reduce()

Using reduce() and partial()

Using map() and reduce() to sanitize raw data

Using groupby() and reduce()

Summary

11. Decorator Design Techniques

Decorators as higher-order functions

Using functool's update_wrapper() functions

Cross-cutting concerns

Composite design

Preprocessing bad data

Adding a parameter to a decorator

Implementing more complex descriptors

Recognizing design limitations

Summary

12. The Multiprocessing and Threading Modules

What concurrency really means

The boundary conditions

Sharing resources with process or threads

Where benefits will accrue

Using multiprocessing pools and tasks

Processing many large files

Parsing log files – gathering the rows

Parsing log lines into namedtuples

Parsing additional fields of an Access object

Filtering the access details

Analyzing the access details

The complete analysis process

Using a multiprocessing pool for concurrent processing

Using apply() to make a single request

Using map_async(), starmap_async(), and apply_async()

More complex multiprocessing architectures

Using the concurrent.futures module

Using concurrent.futures thread pools

Using the threading and queue modules

Designing concurrent processing

Summary

13. Conditional Expressions and the Operator Module

Evaluating conditional expressions

Exploiting non-strict dictionary rules

Filtering true conditional expressions

Using the operator module instead of lambdas

Getting named attributes when using higher-order functions

Starmapping with operators

Reducing with operators

Summary

14. The PyMonad Library

Downloading and installing

Functional composition and currying

Using curried higher-order functions

Currying the hard way

Functional composition and the PyMonad multiplication operator

Functors and applicative functors

Using the lazy List() functor

Monad concepts, the bind() function and the Binary Right Shift operator

Implementing simulation with monads

Additional PyMonad features

Summary

15. A Functional Approach to Web Services

The HTTP request-response model

Injecting a state via cookies

Considering a server with a functional design

Looking more deeply into the functional view

Nesting the services

The WSGI standard

Throwing exceptions during WSGI processing

Pragmatic WSGI applications

Defining web services as functions

Creating the WSGI application

Getting raw data

Applying a filter

Serializing the results

Serializing data into the JSON or CSV format

Serializing data into XML

Serializing data into HTML

Tracking usage

Summary

16. Optimizations and Improvements

Memoization and caching

Specializing memoization

Tail recursion optimizations

Optimizing storage

Optimizing accuracy

Reducing accuracy based on audience requirements

Case study – making a chi-squared decision

Filtering and reducing the raw data with a Counter object

Reading summarized data

Computing probabilities from a Counter object

Alternative summary approaches

Computing expected values and displaying a contingency table

Computing the chi-squared value

Computing the chi-squared threshold

Computing the partial gamma value

Computing the complete gamma value

Computing the odds of a distribution being random

Summary

Index