目錄(265章)
倒序
- 封面
- 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 更新時間：2021-08-27 19:21:04
推薦閱讀
- Learn ECMAScript（Second Edition）
- Advanced Quantitative Finance with C++
- Progressive Web Apps with React
- The Android Game Developer's Handbook
- Azure IoT Development Cookbook
- Ext JS Data-driven Application Design
- Vue.js快速入門與深入實戰
- Java Web應用開發技術與案例教程（第2版）
- Spring Boot Cookbook
- 從0到1：Python數據分析
- Julia高性能科學計算（第2版）
- 編程菜鳥學Python數據分析
- Learning jQuery（Fourth Edition）
- Practical Game Design with Unity and Playmaker
- Kivy Cookbook
- Beginning C++ Game Programming
- DB2SQL性能調優秘笈
- HTML5移動前端開發基礎與實戰（微課版）
- Keil Cx51 V7.0單片機高級語言編程與μVision2應用實踐
- Python算法交易實戰
- Salt Cookbook
- 數據結構：C語言描述（融媒體版)
- web2py Application Development Cookbook
- Unity 5.x 2D Game Development Blueprints
- Ascend C異構并行程序設計：昇騰算子編程指南
- Getting Started with Ionic
- 量子計算實戰
- 計算機軟件技術基礎（第2版）
- Go Cookbook
- 程序設計與問題求解：C語言
