全部商品分类

您现在的位置: 全部商品分类 > 电子电脑 > 计算机技术 > 程序与语言

函数式Python编程(第2版影印版)(英文版)

  • 定价: ¥99
  • ISBN:9787564183257
  • 开 本:16开 平装
  •  
  • 折扣:
  • 出版社:东南大学
  • 页数:391页
  • 作者:(美)史蒂文·F.洛...
  • 立即节省:
  • 2019-05-01 第1版
  • 2019-05-01 第1次印刷
我要买:
点击放图片

导语

  

内容提要

  

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