消息首页搜索举报

正版现货新书函数式Python编程 9787564183257 Steven F. Lott著

全新正版现货，以书名为准，放心购买，购书咨询18931383650朱老师

69.3 7.0折 99 全新

仅1件

北京丰台

认证卖家担保交易快速发货售后保障

作者Steven F. Lott著

出版社东南大学出版社

ISBN9787564183257

出版时间2019-05

装帧平装

开本其他

定价99元

货号9539402

上书时间2024-12-17

黎明书店

十五年老店

已实名已认证进店收藏店铺

在售商品暂无
平均发货时间 9小时
好评率暂无

最新上架

正版现货新书大地星辰 9787540989750 汤松波 ¥9.33

正版现货新书现代实用职业英语实训教程:二 9787303245369 赵玲玲，陈晓红主编

正版现货新书中国社会体制改革报告:2016版:No.4(2016):No.4(2016) 9787509790045 龚维斌主编

正版现货新书小海蒂 9787501586516 （瑞士）斯比丽 ¥12.36

正版现货新书分享秘密大会 9787539776002 伍美珍编著 ¥8.55

正版现货新书中国城乡发展一体化指数 9787509776926 朱钢,张军,王小映

正版现货新书高等职业教育会计专业教学质量标准包构建研究 9787518407262 贺旭红,何

正版现货新书云南30年的沿边开放历程、成就和经验 9787509764152 陈铁军著

正版现货新书民营力量璀璨想:100位对民族产业贡献卓著的民营功勋企业家 9787515805795 《中国工商》杂志社，华商韬略(北京)国际文化传媒中心，中华工商联合出版社出品

商品详情

品相描述：全新

商品描述: 作者简介
史蒂文？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

精彩内容
如果你是一名想要了解如何利用函数式编程的强大功能并将其应用于自己的程序中的Python开发人员，那么这是一本你不容错过的书，哪怕你对这种编程范式几乎一无所知。

本书一开始先概述了函数式概念，你会了解到一些常见的函数式特性，例如头等函数、高阶函数、纯函数等。接下来，你将看到如何在Python中运用这些特性，以此为你提供立足的核心基础知识。在这之后，你将学习用于Python的常见函数式优化，以帮助你的应用程序达到更高的运行速度。

你会学习到函数式编程的概念，例如使用Python的生成器函数和表达式实现惰性求值，然后学习如何设计和实现装饰器来创建复合函数。此外你还将深入探索数据预备技术和数据探查，了解Python标准库如何适应函数式编程模型。最后，为了结束Python函数式编程世界的探索旅程，本书会向你展示PyMonad项目和一些更大规模的示例，以开阔你的视野。