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.
  • Book Overview & Buying Functional Python Programming
  • Table Of Contents Toc
  • Feedback & Rating feedback
Functional Python Programming

Functional Python Programming

By : Steven F. Lott
4 (9)
Buy this Book
close
close
Functional Python Programming

Functional Python Programming

4 (9)
By: Steven F. Lott
Buy this Book

Overview of this book

This book is for developers who want to use Python to write programs that lean heavily on functional programming design patterns. You should be comfortable with Python programming, but no knowledge of functional programming paradigms is needed.
Table of Contents (18 chapters)
close
close
close
Preface
Icon
Preface
Icon
What this book covers
Icon
What you need for this book
Icon
Who this book is for
Icon
Conventions
Icon
Reader feedback
Icon
Customer support
Free Chapter
1
1. Introducing Functional Programming
Icon
1. Introducing Functional Programming
Icon
Identifying a paradigm
Icon
Subdividing the procedural paradigm
Icon
A classic example of functional programming
Icon
Exploratory Data Analysis
Icon
Summary
2
2. Introducing Some Functional Features
Icon
2. Introducing Some Functional Features
Icon
First-class functions
Icon
Immutable data
Icon
Strict and non-strict evaluation
Icon
Recursion instead of a explicit loop state
Icon
Functional type systems
Icon
Familiar territory
Icon
Saving some advanced concepts
Icon
Summary
3
3. Functions, Iterators, and Generators
Icon
3. Functions, Iterators, and Generators
Icon
Writing pure functions
Icon
Functions as first-class objects
Icon
Using strings
Icon
Using tuples and namedtuples
Icon
Cleaning raw data with generator functions
Icon
Using lists, dicts, and sets
Icon
Summary
4
4. Working with Collections
Icon
4. Working with Collections
Icon
An overview of function varieties
Icon
Working with iterables
Icon
Using zip() to structure and flatten sequences
Icon
Using reversed() to change the order
Icon
Using enumerate() to include a sequence number
Icon
Summary
5
5. Higher-order Functions
Icon
5. Higher-order Functions
Icon
Using max() and min() to find extrema
Icon
Using Python lambda forms
Icon
Lambdas and the lambda calculus
Icon
Using the map() function to apply a function to a collection
Icon
Using map() with multiple sequences
Icon
Using the filter() function to pass or reject data
Icon
Using filter() to identify outliers
Icon
The iter() function with a sentinel value
Icon
Using sorted() to put data in order
Icon
Writing higher-order functions
Icon
Writing higher-order mappings and filters
Icon
Writing generator functions
Icon
Building higher-order functions with Callables
Icon
Looking at some of the design patterns
Icon
Summary
6
6. Recursions and Reductions
chevron up
Icon
6. Recursions and Reductions
Icon
Simple numerical recursions
Icon
Group-by reductions – from many to fewer
Icon
Summary
7
7. Additional Tuple Techniques
Icon
7. Additional Tuple Techniques
Icon
Using an immutable namedtuple as a record
Icon
Building namedtuples with functional constructors
Icon
Avoiding stateful classes by using families of tuples
Icon
Polymorphism and Pythonic pattern matching
Icon
Summary
8
8. The Itertools Module
Icon
8. The Itertools Module
Icon
Working with the infinite iterators
Icon
Using the finite iterators
Icon
Cloning iterators with tee()
Icon
The itertools recipes
Icon
Summary
9
9. More Itertools Techniques
Icon
9. More Itertools Techniques
Icon
Enumerating the Cartesian product
Icon
Reducing a product
Icon
Permuting a collection of values
Icon
Generating all combinations
Icon
Recipes
Icon
Summary
10
10. The Functools Module
Icon
10. The Functools Module
Icon
Function tools
Icon
Memoizing previous results with lru_cache
Icon
Defining classes with total ordering
Icon
Applying partial arguments with partial()
Icon
Reducing sets of data with reduce()
Icon
Summary
11
11. Decorator Design Techniques
Icon
11. Decorator Design Techniques
Icon
Decorators as higher-order functions
Icon
Cross-cutting concerns
Icon
Composite design
Icon
Adding a parameter to a decorator
Icon
Implementing more complex descriptors
Icon
Recognizing design limitations
Icon
Summary
12
12. The Multiprocessing and Threading Modules
Icon
12. The Multiprocessing and Threading Modules
Icon
What concurrency really means
Icon
The boundary conditions
Icon
Sharing resources with process or threads
Icon
Where benefits will accrue
Icon
Using multiprocessing pools and tasks
Icon
Using a multiprocessing pool for concurrent processing
Icon
Summary
13
13. Conditional Expressions and the Operator Module
Icon
13. Conditional Expressions and the Operator Module
Icon
Evaluating conditional expressions
Icon
Using the operator module instead of lambdas
Icon
Starmapping with operators
Icon
Reducing with operators
Icon
Summary
14
14. The PyMonad Library
Icon
14. The PyMonad Library
Icon
Downloading and installing
Icon
Functional composition and currying
Icon
Functional composition and the PyMonad multiplication operator
Icon
Functors and applicative functors
Icon
Monad concepts, the bind() function and the Binary Right Shift operator
Icon
Implementing simulation with monads
Icon
Additional PyMonad features
Icon
Summary
15
15. A Functional Approach to Web Services
Icon
15. A Functional Approach to Web Services
Icon
The HTTP request-response model
Icon
The WSGI standard
Icon
Defining web services as functions
Icon
Tracking usage
Icon
Summary
16
16. Optimizations and Improvements
Icon
16. Optimizations and Improvements
Icon
Memoization and caching
Icon
Specializing memoization
Icon
Optimizing storage
Icon
Optimizing accuracy
Icon
Case study – making a chi-squared decision
Icon
Computing expected values and displaying a contingency table
Icon
Summary
17
Index
Icon
Index

Simple numerical recursions

We can consider all numeric operations to be defined by recursions. For more depth, read about the Peano axioms that define the essential features of numbers. http://en.wikipedia.org/wiki/Peano_axioms is one place to start.

From these axioms, we can see that addition is defined recursively using more primitive notions of the next number, or successor of a number, n, Simple numerical recursions.

To simplify the presentation, we'll assume that we can define a predecessor function,Simple numerical recursions, such that Simple numerical recursions, as long as Simple numerical recursions

Addition between two natural numbers could be defined recursively as follows:

Simple numerical recursions

If we use more common Simple numerical recursions and Simple numerical recursions instead of Simple numerical recursions and Simple numerical recursions, we can see that Simple numerical recursions.

This translates neatly in Python, as shown in the following command snippet:

def add(a,b):
    if a == 0: return b
    else: return add(a-1, b+1)

We've simply rearranged common mathematical notation into Python. The if clauses are placed to the left instead of the right.

Generally, we don't provide our own functions in Python to do simple...

Unlock full access

Continue reading for free

A Packt free trial gives you instant online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech
Start a 7-day FREE trial
End of Section 2
Next Section

Create a Note

Modal Close icon
You need to login to use this feature.
notes
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

Delete Note

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

Edit Note

Modal Close icon
Write a note (max 255 characters)
Cancel
Update Note

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY