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

微信读书书城Functional Python Programming

首页我的书架登录

翻译完成

切换

Functional Python Programming

Steven F. Lott

扉页
Title Page
+书签
Copyright and Credits
Functional Python Programming Second Edition
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
Understanding 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
Introducing Essential Functional Concepts
First-class functions
Pure functions
Higher-order 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
Writing pure functions
Functions as first-class objects
Using strings
Using tuples and named tuples
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
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
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
Review of some design patterns
Summary
Recursions and Reductions
Simple numerical recursions
Implementing tail-call optimization
Leaving recursion in place
Handling difficult tail-call optimization
Processing collections through recursion
Tail-call optimization for collections
Reductions and folding a collection from many items to one
Group-by reduction from many items 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
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
Assigning statistical ranks
Wrapping instead of state changing
Rewrapping instead of state changing
Computing Spearman rank-order correlation
Polymorphism and type-pattern matching
Summary
The Itertools Module
Working with the infinite iterators
Counting with count()
Counting with float arguments
Re-iterating 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
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
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 the reduce() function
Combining map() and reduce()
Using the reduce() and partial() functions
Using the map() and reduce() functions to sanitize raw data
Using the groupby() and reduce() functions
Summary
Decorator Design Techniques
Decorators as higher-order functions
Using the functools update_wrapper() functions
Cross-cutting concerns
Composite design
Preprocessing bad data
Adding a parameter to a decorator
Implementing more complex decorators
Complex design considerations
Summary
The Multiprocessing and Threading Modules
Functional programming and concurrency
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 the map_async(), starmap_async(), and apply_async() functions
More complex multiprocessing architectures
Using the concurrent.futures module
Using concurrent.futures thread pools
Using the threading and queue modules
Designing concurrent processing
Summary
Conditional Expressions and the Operator Module
Evaluating conditional expressions
Exploiting non-strict dictionary rules
Filtering true conditional expressions
Finding a matching pattern
Using the operator module instead of lambdas
Getting named attributes when using higher-order functions
Starmapping with operators
Reducing with operator module functions
Summary
The PyMonad Library
Downloading and installing
Functional composition and currying
Using curried higher-order functions
Currying the hard way
Functional composition and the PyMonad * operator
Functors and applicative functors
Using the lazy List() functor
Monad bind() function and the >> operator
Implementing simulation with monads
Additional PyMonad features
Summary
A Functional Approach to Web Services
The HTTP request-response model
Injecting state through 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 JSON or CSV formats
Serializing data into XML
Serializing data into HTML
Tracking usage
Summary
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 sums with a Counter object
Computing probabilities from Counter objects
Computing expected values and displaying a contingency table
Computing the chi-squared value
Computing the chi-squared threshold
Computing the incomplete gamma function
Computing the complete gamma function
Computing the odds of a distribution being random
Functional programming design patterns
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think

简介

版权

Functional Python Programming