Functional Python Programming

Table of Contents

• Preface


• Chapter 1: Introducing 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 Some Functional Features
  
  
  • First-class functions
    
    
    • Pure functions
    
    
    • Higher-order functions
    
    
    
    
  
  
  • Immutable data
  
  
  • Strict and non-strict evaluation
  
  
  • Recursion instead of a explicit loop state
  
  
  • Functional type systems
  
  
  • Familiar territory
  
  
  • Saving some advanced concepts
  
  
  • Summary
  
  
  
  


• Chapter 3: Functions, Iterators, and Generators
  
  
  • Writing pure functions
  
  
  • Functions as first-class objects
  
  
  • Using strings
  
  
  • Using tuples and namedtuples [ ii ]
    
    
    • 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
  
  
  • 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 [ iii ]
  
  
  • 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
    
    
    
    
  
  
  • Looking at some of the 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 via recursion
    
    
    • Tail-call optimization for collections
    
    
    • Reductions and folding – from many to one
    
    
    
    
  
  
  • Group-by reductions – from many 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 an immutable namedtuple as a record
  
  
  • Building namedtuples 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 the Spearman rank-order correlation
    
    
    
    
  
  
  • Polymorphism and Pythonic pattern matching
  
  
  • Summary
  
  
  
  


• Chapter 8: The Itertools Module [ iv ]
  
  
  • Working with the infinite iterators
    
    
    • Counting with count()
    
    
    • Reiterating 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 reduce()
    
    
    • Combining map() and reduce()
    
    
    • Using reduce() and partial()
    
    
    • Using map() and reduce() to sanitize raw data [ v ]
    
    
    • Using groupby() and reduce()
    
    
    
    
  
  
  • Summary
  
  
  
  


• Chapter 11: Decorator Design Techniques
  
  
  • Decorators as higher-order functions
    
    
    • Using functool's update_wrapper() functions
    
    
    
    
  
  
  • Cross-cutting concerns
  
  
  • Composite design
    
    
    • Preprocessing bad data
    
    
    
    
  
  
  • Adding a parameter to a decorator
  
  
  • Implementing more complex descriptors
  
  
  • Recognizing design limitations
  
  
  • Summary
  
  
  
  


• Chapter 12: The Multiprocessing and Threading Modules
  
  
  • 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 map_async(), starmap_async(), and apply_async()
    
    
    • 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
    
    
    
    
  
  
  • Using the operator module instead of lambdas [ vi ]
    
    
    • Getting named attributes when using higher-order functions
    
    
    
    
  
  
  • Starmapping with operators
  
  
  • Reducing with operators
  
  
  • 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 multiplication operator
  
  
  • Functors and applicative functors
    
    
    • Using the lazy List() functor
    
    
    
    
  
  
  • Right Shift operator Monad concepts, the bind() function and the Binary
  
  
  • Implementing simulation with monads
  
  
  • Additional PyMonad features
  
  
  • Summary
  
  
  
  


• Chapter 15: A Functional Approach to Web Services
  
  
  • The HTTP request-response model
    
    
    • Injecting a state via 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 the JSON or CSV format
    
    
    • Serializing data into XML
    
    
    • Serializing data into HTML
    
    
    
    
  
  
  • Tracking usage
  
  
  • Summary
  
  
  
  


• Chapter 16: Optimizations and Improvements [ vii ]
  
  
  • Memoization and caching
  
  
  • Specializing memoization
  
  
  • 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 probabilities from a Counter object
    
    
    • Alternative summary approaches
    
    
    
    
  
  
  • Computing expected values and displaying a contingency table
    
    
    • Computing the chi-squared value
    
    
    • Computing the chi-squared threshold
    
    
    • Computing the partial gamma value
    
    
    • Computing the complete gamma value
    
    
    • Computing the odds of a distribution being random
    
    
    
    
  
  
  • Summary
  
  
  
  


• Index