Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Functional Python Programming
  • Toc
  • feedback
Functional Python Programming

Functional Python Programming

3.7 (3)
close
Functional Python Programming

Functional Python Programming

3.7 (3)

Overview of this book

If you’re a Python developer who wants to discover how to take the power of functional programming (FP) and bring it into your own programs, then this book is essential for you, even if you know next to nothing about the paradigm. Starting with a general overview of functional concepts, you’ll explore common functional features such as first-class and higher-order functions, pure functions, and more. You’ll see how these are accomplished in Python 3.6 to give you the core foundations you’ll build upon. After that, you’ll discover common functional optimizations for Python to help your apps reach even higher speeds. You’ll learn FP concepts such as lazy evaluation using Python’s generator functions and expressions. Moving forward, you’ll learn to design and implement decorators to create composite functions. You'll also explore data preparation techniques and data exploration in depth, and see how the Python standard library fits the functional programming model. Finally, to top off your journey into the world of functional Python, you’ll at look at the PyMonad project and some larger examples to put everything into perspective.
Table of Contents (18 chapters)
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Understanding Functional Programming
Understanding Functional Programming
Identifying a paradigm
Subdividing the procedural paradigm
A classic example of functional programming
Exploratory data analysis
Summary
2
Introducing Essential Functional Concepts
Introducing Essential Functional Concepts
First-class 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
3
Functions, Iterators, and Generators
Functions, Iterators, and Generators
Writing pure functions
Functions as first-class objects
Using strings
Using tuples and named tuples
Cleaning raw data with generator functions
Using lists, dicts, and sets
Summary
4
Working with Collections
Working with Collections
An overview of function varieties
Working with iterables
Using zip() to structure and flatten sequences
Using reversed() to change the order
Using enumerate() to include a sequence number
Summary
5
Higher-Order Functions
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
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
Writing generator functions
Building higher-order functions with callables
Review of some design patterns
Summary
6
Recursions and Reductions
Recursions and Reductions
Simple numerical recursions
Group-by reduction from many items to fewer
Summary
7
Additional Tuple Techniques
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
Polymorphism and type-pattern matching
Summary
8
The Itertools Module
The Itertools Module
Working with the infinite iterators
Using the finite iterators
Cloning iterators with tee()
The itertools recipes
Summary
9
More Itertools Techniques
More Itertools Techniques
Enumerating the Cartesian product
Reducing a product
Permuting a collection of values
Generating all combinations
Recipes
Summary
10
The Functools Module
The Functools Module
Function tools
Memoizing previous results with lru_cache
Defining classes with total ordering
Applying partial arguments with partial()
Reducing sets of data with the reduce() function
Summary
11
Decorator Design Techniques
chevron up
Decorator Design Techniques
Decorators as higher-order functions
Cross-cutting concerns
Composite design
Adding a parameter to a decorator
Implementing more complex decorators
Complex design considerations
Summary
12
The Multiprocessing and Threading Modules
The Multiprocessing and Threading Modules
Functional programming and concurrency
What concurrency really means
Using multiprocessing pools and tasks
Using a multiprocessing pool for concurrent processing
Summary
13
Conditional Expressions and the Operator Module
Conditional Expressions and the Operator Module
Evaluating conditional expressions
Using the operator module instead of lambdas
Starmapping with operators
Reducing with operator module functions
Summary
14
The PyMonad Library
The PyMonad Library
Downloading and installing
Functional composition and currying
Functional composition and the PyMonad * operator
Functors and applicative functors
Monad bind() function and the >> operator
Implementing simulation with monads
Additional PyMonad features
Summary
15
A Functional Approach to Web Services
A Functional Approach to Web Services
The HTTP request-response model
The WSGI standard
Defining web services as functions
Tracking usage
Summary
16
Optimizations and Improvements
Optimizations and Improvements
Memoization and caching
Specializing memoization
Tail recursion optimizations
Optimizing storage
Optimizing accuracy
Case study–making a chi-squared decision
Computing expected values and displaying a contingency table
Functional programming design patterns
Summary
17
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Composite design

The common mathematical notation for a composite function looks as follows:

 

The idea is that we can define a new function, 

, that combines two other functions,

 and

.

Python's multiple-line definition of a composition function can be done through the following code:

@f_deco
def g(x):
    something

The resulting function can be essentially equivalent to

 . The f_deco() decorator must define and return the composite function by merging an internal definition of f() with the provided g(). 

The implementation details show that Python actually provides a slightly more complex kind of composition. The structure of a wrapper makes it helpful to think of Python decorator composition as follows:

A decorator applied to some application function, 

, will include a wrapper function,

, that has two parts. One portion of the wrapper, 

, applies to the arguments of the wrapped function,

, and the other portion, 

 , applies to the result of the wrapped function.

Here's a more concrete idea, shown...

End of Section 2
Next Section
bookmark search playlist font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete