函数式PYTHON编程(第2版 影印版)

如果你是一名想要了解如何利用函数式编程的强大功能并将其应用于自己的程序中的Python开发人员，那么这是一本你不容错过的书，哪怕你对这种编程范式几乎一无所知。
本书一开始先概述了函数式概念，你会了解到一些常见的函数式特性，例如头等函数、高阶函数、纯函数等。接下来，你将看到如何在Python中运用这些特性，以此为你提供立足的核心基础知识。在这之后，你将学习用于Python的常见函数式优化，以帮助你的应用程序达到更高的运行速度。
你会学习到函数式编程的概念，例如使用Python的生成器函数和表达式实现惰性求值，然后学习如何设计和实现装饰器来创建复合函数。此外你还将深入探索数据预备技术和数据探查，了解Python标准库如何适应函数式编程模型。 很后，为了结束Python函数式编程世界的探索旅程，本书会向你展示PyMonad项目和一些更大规模的示例，以开阔你的视野。

史蒂文？F.洛特，has been programming since the '70s, when computers were large,expensive, and rare. He's been using Python to solve business problems for over 10 years.His other titles with Packt Publishing include Python Essentials, Mastering Object-OrientedPython, Functional Python Programming, and Python for Secret Agents. Steven is currently atechnomad who lives in city along the east coast of the U.S. You can follow his technologyblog (slott-softwarearchitect).

Copyright and Credits
Preface
Chapter 1: 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
Chapter 2: 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
Chapter 3: 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
Chapter 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 iterO function explicitly
Extending a simple loop
Applying generator expressions to scalar functions
Using any() and all() as reductions
Using lenO 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
Chapter 5: Higher-Order Functions
Using max() and min0 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 iter0 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
Chapter 6: 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
Chapter 7: 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
Chapter 8: 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 groupby0
Merging iterables with zip_longest0 and zip()
Filtering with compress()
Picking subsets with islice()
Stateful filtering with dropwhile0 and takewhile0
Two approaches to filtering with filterfalse() and filter()
Applying a function to data via starmap0 and map()
Cloning iterators with tee()
The itertools recipes
Summary
Chapter 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
Chapter 10: The Functools Module
Function tools
Memoizing previous results with Iru_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 groupby0 and reduce() functions
Summary
Chapter 11: Decorator Design Techniques
Decorators as higher-order functions
Using the functools update_wrapper0 functions
Cross-cutting concerns
Composite design
Preprocessing bad data
Adding a parameter to a decorator
Implementing more complex decorators
CompLex design considerations
Summary
Chapter 12: 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_async0, starmap_async(), and apply_async0 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
Chapter 13: 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
Chapter 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 * operator
Functors and applicative functors
Using the lazy List() functor
Monad bind() function and the >> operator
Implementing simulation with monads
Additional PyMonad features
Summary
Chapter 15: 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
Chapter 16: Optimizations and Improvements
Memoization and caching
Speizing 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
Index