|
|
|
|
| LEADER |
00000cam a2200000 i 4500 |
| 001 |
on1032707716 |
| 003 |
OCoLC |
| 005 |
20241006213017.0 |
| 006 |
m o d |
| 007 |
cr |n|---||||| |
| 008 |
180428s2018 enk o 001 0 eng d |
| 040 |
|
|
|a EBLCP
|b eng
|e pn
|c EBLCP
|d OCLCQ
|d MERUC
|d IDB
|d OCLCF
|d VT2
|d OCLCQ
|d LVT
|d C6I
|d YDX
|d N$T
|d UKMGB
|d ZCU
|d UKAHL
|d OCLCQ
|d K6U
|d OCLCO
|d OCLCQ
|d OCLCO
|d OCLCQ
|d SXB
|
| 015 |
|
|
|a GBB877786
|2 bnb
|
| 016 |
7 |
|
|a 018847176
|2 Uk
|
| 019 |
|
|
|a 1032660598
|a 1032720633
|a 1065326113
|
| 020 |
|
|
|a 9781788621854
|
| 020 |
|
|
|a 1788621859
|
| 020 |
|
|
|a 9781788627061
|
| 020 |
|
|
|a 1788627067
|
| 024 |
3 |
|
|a 9781788627061
|
| 035 |
|
|
|a (OCoLC)1032707716
|z (OCoLC)1032660598
|z (OCoLC)1032720633
|z (OCoLC)1065326113
|
| 037 |
|
|
|a B09385
|b 01201872
|
| 050 |
|
4 |
|a QA76.73.P98
|b L688 2018
|
| 072 |
|
7 |
|a COM
|x 051360
|2 bisacsh
|
| 049 |
|
|
|a HCDD
|
| 100 |
1 |
|
|a Lott, Steven F.,
|e author.
|
| 245 |
1 |
0 |
|a Functional Python programming :
|b discover the power of functional programming, generator functions, lazy evaluation, the built-in itertools library, and monads /
|c Steven F. Lott.
|
| 250 |
|
|
|a Second edition.
|
| 260 |
|
|
|a Birmingham, UK :
|b Packt Publishing,
|c 2018.
|
| 300 |
|
|
|a 1 online resource
|
| 336 |
|
|
|a text
|b txt
|2 rdacontent
|
| 337 |
|
|
|a computer
|b c
|2 rdamedia
|
| 338 |
|
|
|a online resource
|b cr
|2 rdacarrier
|
| 500 |
|
|
|a Includes index.
|
| 520 |
|
|
|a Python is an easy-to-learn and extensible programming language that offers a number of functional programming features. This practical guide demonstrates the Python implementation of a number of functional programming techniques and design patterns. Through this book, you'll understand what functional programming is all about, its impact on ...
|
| 505 |
0 |
|
|a Cover -- Copyright and Credits -- Packt Upsell -- Contributors -- Table of Contents -- 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 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.
|
| 505 |
8 |
|
|a Using enumerate() to include a sequence number -- Summary -- Chapter 5: 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 -- 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.
|
| 505 |
8 |
|
|a 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 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 -- 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 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 -- Chapter 11: Decorator Design Techniques -- Decorators as higher-order functions -- Using the functools update_wrapper() functions -- Cross-cutting concerns -- Composite design -- Preprocessing bad data.
|
| 505 |
8 |
|
|a 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_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 -- 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.
|
| 505 |
8 |
|
|a 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.
|
| 588 |
0 |
|
|a Print version record.
|
| 650 |
|
0 |
|a Python (Computer program language)
|
| 650 |
|
0 |
|a Application software
|x Development.
|
| 650 |
|
7 |
|a COMPUTERS
|x Programming Languages
|x Python.
|2 bisacsh
|
| 650 |
|
7 |
|a Application software
|x Development
|2 fast
|
| 650 |
|
7 |
|a Python (Computer program language)
|2 fast
|
| 776 |
0 |
8 |
|i Print version:
|a F. Lott, Steven.
|t Functional Python Programming : Discover the power of functional programming, generator functions, lazy evaluation, the built-in itertools library, and monads, 2nd Edition.
|d Birmingham : Packt Publishing, ©2018
|
| 856 |
4 |
0 |
|u https://ebookcentral.proquest.com/lib/holycrosscollege-ebooks/detail.action?docID=5353672
|y Click for online access
|
| 903 |
|
|
|a EBC-AC
|
| 994 |
|
|
|a 92
|b HCD
|