如果你是一名想要了解如何利用函数式编程的强大功能并将其应用于自己的程序中的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 ar