book

Functional Python Programming

Name: Functional Python Programming
Author: Steven F. Lott
ISBN: 9781784396992

by Steven F. Lott

January 2015

Intermediate to advanced

360 pages

8h 50m

English

Packt Publishing

Read now

Unlock full access

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 moreWhy 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 codeErrataPiracyQuestions
1. Introducing Functional Programming
Identifying a paradigm
Subdividing the procedural paradigm
Using the functional paradigmUsing a functional hybridLooking at object creationThe stack of turtles
A classic example of functional programming
Exploratory Data Analysis
Summary
2. Introducing Some Functional Features
First-class functionsPure functionsHigher-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 expressionsExploring the limitations of generatorsCombining generator expressions
Cleaning raw data with generator functions
Using lists, dicts, and sets
Using stateful mappingsUsing the bisect module to create a mappingUsing stateful sets
Summary
4. Working with Collections
An overview of function varieties
Working with iterables
Parsing an XML fileParsing a file at a higher levelPairing up items from a sequenceUsing the iter() function explicitlyExtending a simple loopApplying generator expressions to scalar functionsUsing any() and all() as reductionsUsing len() and sum()Using sums and counts for statistics
Using zip() to structure and flatten sequences
Unzipping a zipped sequenceFlattening sequencesStructuring flat sequencesStructuring 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 mappingWrapping additional data while mappingFlattening data while mappingStructuring 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 recursionsImplementing tail-call optimizationLeaving recursion in placeHandling difficult tail-call optimizationProcessing collections via recursionTail-call optimization for collectionsReductions and folding – from many to one
Group-by reductions – from many to fewer
Building a mapping with CounterBuilding a mapping by sortingGrouping or partitioning data by key valuesWriting more general group-by reductionsWriting higher-order reductionsWriting file parsersParsing CSV filesParsing 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 ranksWrapping instead of state changingRewrapping instead of state changingComputing the Spearman rank-order correlation
Polymorphism and Pythonic pattern matching
Summary
8. The Itertools Module
Working with the infinite iteratorsCounting 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 distancesGetting all pixels and all colorsPerformance analysisRearranging the problemCombining 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 dataUsing groupby() and reduce()
Summary
11. Decorator Design Techniques
Decorators as higher-order functionsUsing 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 filesParsing log files – gathering the rowsParsing log lines into namedtuplesParsing additional fields of an Access objectFiltering the access detailsAnalyzing the access detailsThe complete analysis process
Using a multiprocessing pool for concurrent processing
Using apply() to make a single requestUsing map_async(), starmap_async(), and apply_async()More complex multiprocessing architecturesUsing the concurrent.futures moduleUsing concurrent.futures thread poolsUsing the threading and queue modulesDesigning concurrent processing
Summary
13. Conditional Expressions and the Operator Module
Evaluating conditional expressionsExploiting non-strict dictionary rulesFiltering 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 functionsCurrying 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 modelInjecting a state via cookiesConsidering a server with a functional designLooking more deeply into the functional viewNesting the services
The WSGI standard
Throwing exceptions during WSGI processingPragmatic WSGI applications
Defining web services as functions
Creating the WSGI applicationGetting raw dataApplying a filterSerializing the resultsSerializing data into the JSON or CSV formatSerializing data into XMLSerializing 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 objectReading summarized dataComputing probabilities from a Counter objectAlternative summary approaches
Computing expected values and displaying a contingency table
Computing the chi-squared valueComputing the chi-squared thresholdComputing the partial gamma valueComputing the complete gamma valueComputing the odds of a distribution being random
Summary
Index

Content preview from Functional Python Programming

Permuting a collection of values

When we permute a collection of values, we'll elaborate all the possible orders for the items. There are ways to permute items. We can use permutations as a kind of brute-force solution to a variety of optimization problems.

By visiting http://en.wikipedia.org/wiki/Combinatorial_optimization, we can see that the exhaustive enumeration of all permutations isn't appropriate for larger problems. The use of the itertools.permutations() function is a handy way to explore very small problems.

One popular example of these ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Functional Python Programming - Second Edition

Publisher Resources

ISBN: 9781784396992

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Functional Python Programming

by Steven F. Lott

Permuting a collection of values

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.