Functional programming in Python (David Mertz) (Z-Library)

Functional Programming in Python David Mertz

Additional Resources 4 Easy Ways to Learn More and Stay Current Programming Newsletter Get programming related news and content delivered weekly to your inbox. oreilly.com/programming/newsletter Free Webcast Series Learn about popular programming topics from experts live, online. webcasts.oreilly.com O’Reilly Radar Read more insight and analysis about emerging technologies. radar.oreilly.com Conferences Immerse yourself in learning at an upcoming O’Reilly conference. conferences.oreilly.com ©2015 O’Reilly Media, Inc. The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. #15305

David Mertz Functional Programming in Python

978-1-491-92856-1 [LSI] Functional Programming in Python by David Mertz Copyright © 2015 O’Reilly Media, Inc. All rights reserved. Attribution-ShareAlike 4.0 International (CC BY-SA 4.0). See: http://creativecommons.org/licenses/by-sa/4.0/ Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://safaribooksonline.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com. Editor: Meghan Blanchette Production Editor: Shiny Kalapurakkel Proofreader: Charles Roumeliotis Interior Designer: David Futato Cover Designer: Karen Montgomery May 2015: First Edition Revision History for the First Edition 2015-05-27: First Release The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. Functional Pro‐ gramming in Python, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc. While the publisher and the author have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the author disclaim all responsibility for errors or omissions, including without limi‐ tation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsi‐ bility to ensure that your use thereof complies with such licenses and/or rights.

Table of Contents Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v (Avoiding) Flow Control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Encapsulation 1 Comprehensions 2 Recursion 5 Eliminating Loops 7 Callables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Named Functions and Lambdas 12 Closures and Callable Instances 13 Methods of Classes 15 Multiple Dispatch 19 Lazy Evaluation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 The Iterator Protocol 27 Module: itertools 29 Higher-Order Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Utility Higher-Order Functions 35 The operator Module 36 The functools Module 36 Decorators 37 iii

Preface What Is Functional Programming? We’d better start with the hardest question: “What is functional pro‐ gramming (FP), anyway?” One answer would be to say that functional programming is what you do when you program in languages like Lisp, Scheme, Clojure, Scala, Haskell, ML, OCAML, Erlang, or a few others. That is a safe answer, but not one that clarifies very much. Unfortunately, it is hard to get a consistent opinion on just what functional program‐ ming is, even from functional programmers themselves. A story about elephants and blind men seems apropos here. It is also safe to contrast functional programming with “imperative programming” (what you do in languages like C, Pascal, C++, Java, Perl, Awk, TCL, and most others, at least for the most part). Functional program‐ ming is also not object-oriented programming (OOP), although some languages are both. And it is not Logic Programming (e.g., Prolog), but again some languages are multiparadigm. Personally, I would roughly characterize functional programming as having at least several of the following characteristics. Languages that get called functional make these things easy, and make other things either hard or impossible: • Functions are first class (objects). That is, everything you can do with “data” can be done with functions themselves (such as passing a function to another function). • Recursion is used as a primary control structure. In some lan‐ guages, no other “loop” construct exists. v

• There is a focus on list processing (for example, it is the source of the name Lisp). Lists are often used with recursion on sublists as a substitute for loops. • “Pure” functional languages eschew side effects. This excludes the almost ubiquitous pattern in imperative languages of assign‐ ing first one, then another value to the same variable to track the program state. • Functional programming either discourages or outright disal‐ lows statements, and instead works with the evaluation of expressions (in other words, functions plus arguments). In the pure case, one program is one expression (plus supporting defi‐ nitions). • Functional programming worries about what is to be computed rather than how it is to be computed. • Much functional programming utilizes “higher order” functions (in other words, functions that operate on functions that oper‐ ate on functions). Advocates of functional programming argue that all these character‐ istics make for more rapidly developed, shorter, and less bug-prone code. Moreover, high theorists of computer science, logic, and math find it a lot easier to prove formal properties of functional languages and programs than of imperative languages and programs. One cru‐ cial concept in functional programming is that of a “pure function”—one that always returns the same result given the same arguments—which is more closely akin to the meaning of “function” in mathematics than that in imperative programming. Python is most definitely not a “pure functional programming lan‐ guage”; side effects are widespread in most Python programs. That is, variables are frequently rebound, mutable data collections often change contents, and I/O is freely interleaved with computation. It is also not even a “functional programming language” more generally. However, Python is a multiparadigm language that makes functional programming easy to do when desired, and easy to mix with other programming styles. Beyond the Standard Library While they will not be discussed withing the limited space of this report, a large number of useful third-party Python libraries for vi | Preface

functional programming are available. The one exception here is that I will discuss Matthew Rocklin’s multipledispatch as the best current implementation of the concept it implements. Most third-party libraries around functional programming are col‐ lections of higher-order functions, and sometimes enhancements to the tools for working lazily with iterators contained in itertools. Some notable examples include the following, but this list should not be taken as exhaustive: • pyrsistent contains a number of immutable collections. All methods on a data structure that would normally mutate it instead return a new copy of the structure containing the requested updates. The original structure is left untouched. • toolz provides a set of utility functions for iterators, functions, and dictionaries. These functions interoperate well and form the building blocks of common data analytic operations. They extend the standard libraries itertools and functools and borrow heavily from the standard libraries of contemporary functional languages. • hypothesis is a library for creating unit tests for finding edge cases in your code you wouldn’t have thought to look for. It works by generating random data matching your specification and checking that your guarantee still holds in that case. This is often called property-based testing, and was popularized by the Haskell library QuickCheck. • more_itertools tries to collect useful compositions of iterators that neither itertools nor the recipes included in its docs address. These compositions are deceptively tricky to get right and this well-crafted library helps users avoid pitfalls of rolling them themselves. Resources There are a large number of other papers, articles, and books written about functional programming, in Python and otherwise. The Python standard documentation itself contains an excellent intro‐ duction called “Functional Programming HOWTO,” by Andrew Kuchling, that discusses some of the motivation for functional pro‐ gramming styles, as well as particular capabilities in Python. Preface | vii

Mentioned in Kuchling’s introduction are several very old public domain articles this author wrote in the 2000s, on which portions of this report are based. These include: • The first chapter of my book Text Processing in Python, which discusses functional programming for text processing, in the section titled “Utilizing Higher-Order Functions in Text Pro‐ cessing.” I also wrote several articles, mentioned by Kuchling, for IBM’s devel‐ operWorks site that discussed using functional programming in an early version of Python 2.x: • Charming Python: Functional programming in Python, Part 1: Making more out of your favorite scripting language • Charming Python: Functional programming in Python, Part 2: Wading into functional programming? • Charming Python: Functional programming in Python, Part 3: Currying and other higher-order functions Not mentioned by Kuchling, and also for an older version of Python, I discussed multiple dispatch in another article for the same column. The implementation I created there has no advantages over the more recent multipledispatch library, but it provides a longer conceptual explanation than this report can: • Charming Python: Multiple dispatch: Generalizing polymor‐ phism with multimethods A Stylistic Note As in most programming texts, a fixed font will be used both for inline and block samples of code, including simple command or function names. Within code blocks, a notional segment of pseudo- code is indicated with a word surrounded by angle brackets (i.e., not valid Python), such as <code-block>. In other cases, syntactically valid but undefined functions are used with descriptive names, such as get_the_data(). viii | Preface

(Avoiding) Flow Control In typical imperative Python programs—including those that make use of classes and methods to hold their imperative code—a block of code generally consists of some outside loops (for or while), assign‐ ment of state variables within those loops, modification of data structures like dicts, lists, and sets (or various other structures, either from the standard library or from third-party packages), and some branch statements (if/elif/else or try/except/finally). All of this is both natural and seems at first easy to reason about. The problems often arise, however, precisely with those side effects that come with state variables and mutable data structures; they often model our concepts from the physical world of containers fairly well, but it is also difficult to reason accurately about what state data is in at a given point in a program. One solution is to focus not on constructing a data collection but rather on describing “what” that data collection consists of. When one simply thinks, “Here’s some data, what do I need to do with it?” rather than the mechanism of constructing the data, more direct reasoning is often possible. The imperative flow control described in the last paragraph is much more about the “how” than the “what” and we can often shift the question. Encapsulation One obvious way of focusing more on “what” than “how” is simply to refactor code, and to put the data construction in a more isolated place—i.e., in a function or method. For example, consider an exist‐ ing snippet of imperative code that looks like this: 1

# configure the data to start with collection = get_initial_state() state_var = None for datum in data_set: if condition(state_var): state_var = calculate_from(datum) new = modify(datum, state_var) collection.add_to(new) else: new = modify_differently(datum) collection.add_to(new) # Now actually work with the data for thing in collection: process(thing) We might simply remove the “how” of the data construction from the current scope, and tuck it away in a function that we can think about in isolation (or not think about at all once it is sufficiently abstracted). For example: # tuck away construction of data def make_collection(data_set): collection = get_initial_state() state_var = None for datum in data_set: if condition(state_var): state_var = calculate_from(datum, state_var) new = modify(datum, state_var) collection.add_to(new) else: new = modify_differently(datum) collection.add_to(new) return collection # Now actually work with the data for thing in make_collection(data_set): process(thing) We haven’t changed the programming logic, nor even the lines of code, at all, but we have still shifted the focus from “How do we con‐ struct collection?” to “What does make_collection() create?” Comprehensions Using comprehensions is often a way both to make code more com‐ pact and to shift our focus from the “how” to the “what.” A compre‐ hension is an expression that uses the same keywords as loop and conditional blocks, but inverts their order to focus on the data 2 | (Avoiding) Flow Control

rather than on the procedure. Simply changing the form of expres‐ sion can often make a surprisingly large difference in how we reason about code and how easy it is to understand. The ternary operator also performs a similar restructuring of our focus, using the same keywords in a different order. For example, if our original code was: collection = list() for datum in data_set: if condition(datum): collection.append(datum) else: new = modify(datum) collection.append(new) Somewhat more compactly we could write this as: collection = [d if condition(d) else modify(d) for d in data_set] Far more important than simply saving a few characters and lines is the mental shift enacted by thinking of what collection is, and by avoiding needing to think about or debug “What is the state of col lection at this point in the loop?” List comprehensions have been in Python the longest, and are in some ways the simplest. We now also have generator comprehen‐ sions, set comprehensions, and dict comprehensions available in Python syntax. As a caveat though, while you can nest comprehen‐ sions to arbitrary depth, past a fairly simple level they tend to stop clarifying and start obscuring. For genuinely complex construction of a data collection, refactoring into functions remains more reada‐ ble. Generators Generator comprehensions have the same syntax as list comprehen‐ sions—other than that there are no square brackets around them (but parentheses are needed syntactically in some contexts, in place of brackets)—but they are also lazy. That is to say that they are merely a description of “how to get the data” that is not realized until one explicitly asks for it, either by calling .next() on the object, or by looping over it. This often saves memory for large sequences and defers computation until it is actually needed. For example: log_lines = (line for line in read_line(huge_log_file) if complex_condition(line)) Comprehensions | 3

For typical uses, the behavior is the same as if you had constructed a list, but runtime behavior is nicer. Obviously, this generator compre‐ hension also has imperative versions, for example: def get_log_lines(log_file): line = read_line(log_file) while True: try: if complex_condition(line): yield line line = read_line(log_file) except StopIteration: raise log_lines = get_log_lines(huge_log_file) Yes, the imperative version could be simplified too, but the version shown is meant to illustrate the behind-the-scenes “how” of a for loop over an iteratable—more details we also want to abstract from in our thinking. In fact, even using yield is somewhat of an abstrac‐ tion from the underlying “iterator protocol.” We could do this with a class that had .__next__() and .__iter__() methods. For example: class GetLogLines(object): def __init__(self, log_file): self.log_file = log_file self.line = None def __iter__(self): return self def __next__(self): if self.line is None: self.line = read_line(log_file) while not complex_condition(self.line): self.line = read_line(self.log_file) return self.line log_lines = GetLogLines(huge_log_file) Aside from the digression into the iterator protocol and laziness more generally, the reader should see that the comprehension focu‐ ses attention much better on the “what,” whereas the imperative ver‐ sion—although successful as refactorings perhaps—retains the focus on the “how.” Dicts and Sets In the same fashion that lists can be created in comprehensions rather than by creating an empty list, looping, and repeatedly call‐ 4 | (Avoiding) Flow Control

ing .append(), dictionaries and sets can be created “all at once” rather than by repeatedly calling .update() or .add() in a loop. For example: >>> {i:chr(65+i) for i in range(6)} {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F'} >>> {chr(65+i) for i in range(6)} {'A', 'B', 'C', 'D', 'E', 'F'} The imperative versions of these comprehensions would look very similar to the examples shown earlier for other built-in datatypes. Recursion Functional programmers often put weight in expressing flow con‐ trol through recursion rather than through loops. Done this way, we can avoid altering the state of any variables or data structures within an algorithm, and more importantly get more at the “what” than the “how” of a computation. However, in considering using recursive styles we should distinguish between the cases where recursion is just “iteration by another name” and those where a problem can readily be partitioned into smaller problems, each approached in a similar way. There are two reasons why we should make the distinction men‐ tioned. On the one hand, using recursion effectively as a way of marching through a sequence of elements is, while possible, really not “Pythonic.” It matches the style of other languages like Lisp, def‐ initely, but it often feels contrived in Python. On the other hand, Python is simply comparatively slow at recursion, and has a limited stack depth limit. Yes, you can change this with sys.setrecursion limit() to more than the default 1000; but if you find yourself doing so it is probably a mistake. Python lacks an internal feature called tail call elimination that makes deep recursion computation‐ ally efficient in some languages. Let us find a trivial example where recursion is really just a kind of iteration: def running_sum(numbers, start=0): if len(numbers) == 0: print() return total = numbers[0] + start print(total, end=" ") running_sum(numbers[1:], total) Recursion | 5

There is little to recommend this approach, however; an iteration that simply repeatedly modified the total state variable would be more readable, and moreover this function is perfectly reasonable to want to call against sequences of much larger length than 1000. However, in other cases, recursive style, even over sequential opera‐ tions, still expresses algorithms more intuitively and in a way that is easier to reason about. A slightly less trivial example, factorial in recursive and iterative style: def factorialR(N): "Recursive factorial function" assert isinstance(N, int) and N >= 1 return 1 if N <= 1 else N * factorialR(N-1) def factorialI(N): "Iterative factorial function" assert isinstance(N, int) and N >= 1 product = 1 while N >= 1: product *= N N -= 1 return product Although this algorithm can also be expressed easily enough with a running product variable, the recursive expression still comes closer to the “what” than the “how” of the algorithm. The details of repeat‐ edly changing the values of product and N in the iterative version feels like it’s just bookkeeping, not the nature of the computation itself (but the iterative version is probably faster, and it is easy to reach the recursion limit if it is not adjusted). As a footnote, the fastest version I know of for factorial() in Python is in a functional programming style, and also expresses the “what” of the algorithm well once some higher-order functions are familiar: from functools import reduce from operator import mul def factorialHOF(n): return reduce(mul, range(1, n+1), 1) Where recursion is compelling, and sometimes even the only really obvious way to express a solution, is when a problem offers itself to a “divide and conquer” approach. That is, if we can do a similar computation on two halves (or anyway, several similarly sized chunks) of a larger collection. In that case, the recursion depth is only O(log N) of the size of the collection, which is unlikely to be 6 | (Avoiding) Flow Control

overly deep. For example, the quicksort algorithm is very elegantly expressed without any state variables or loops, but wholly through recursion: def quicksort(lst): "Quicksort over a list-like sequence" if len(lst) == 0: return lst pivot = lst[0] pivots = [x for x in lst if x == pivot] small = quicksort([x for x in lst if x < pivot]) large = quicksort([x for x in lst if x > pivot]) return small + pivots + large Some names are used in the function body to hold convenient val‐ ues, but they are never mutated. It would not be as readable, but the definition could be written as a single expression if we wanted to do so. In fact, it is somewhat difficult, and certainly less intuitive, to transform this into a stateful iterative version. As general advice, it is good practice to look for possibilities of recursive expression—and especially for versions that avoid the need for state variables or mutable data collections—whenever a problem looks partitionable into smaller problems. It is not a good idea in Python—most of the time—to use recursion merely for “iter‐ ation by other means.” Eliminating Loops Just for fun, let us take a quick look at how we could take out all loops from any Python program. Most of the time this is a bad idea, both for readability and performance, but it is worth looking at how simple it is to do in a systematic fashion as background to contem‐ plate those cases where it is actually a good idea. If we simply call a function inside a for loop, the built-in higher- order function map() comes to our aid: for e in it: # statement-based loop func(e) The following code is entirely equivalent to the functional version, except there is no repeated rebinding of the variable e involved, and hence no state: map(func, it) # map()-based "loop" Eliminating Loops | 7

A similar technique is available for a functional approach to sequen‐ tial program flow. Most imperative programming consists of state‐ ments that amount to “do this, then do that, then do the other thing.” If those individual actions are wrapped in functions, map() lets us do just this: # let f1, f2, f3 (etc) be functions that perform actions # an execution utility function do_it = lambda f, *args: f(*args) # map()-based action sequence map(do_it, [f1, f2, f3]) We can combine the sequencing of function calls with passing argu‐ ments from iterables: >>> hello = lambda first, last: print("Hello", first, last) >>> bye = lambda first, last: print("Bye", first, last) >>> _ = list(map(do_it, [hello, bye], >>> ['David','Jane'], ['Mertz','Doe'])) Hello David Mertz Bye Jane Doe Of course, looking at the example, one suspects the result one really wants is actually to pass all the arguments to each of the functions rather than one argument from each list to each function. Express‐ ing that is difficult without using a list comprehension, but easy enough using one: >>> do_all_funcs = lambda fns, *args: [ list(map(fn, *args)) for fn in fns] >>> _ = do_all_funcs([hello, bye], ['David','Jane'], ['Mertz','Doe']) Hello David Mertz Hello Jane Doe Bye David Mertz Bye Jane Doe In general, the whole of our main program could, in principle, be a map() expression with an iterable of functions to execute to com‐ plete the program. Translating while is slightly more complicated, but is possible to do directly using recursion: # statement-based while loop while <cond>: <pre-suite> if <break_condition>: break else: 8 | (Avoiding) Flow Control

<suite> # FP-style recursive while loop def while_block(): <pre-suite> if <break_condition>: return 1 else: <suite> return 0 while_FP = lambda: (<cond> and while_block()) or while_FP() while_FP() Our translation of while still requires a while_block() function that may itself contain statements rather than just expressions. We could go further in turning suites into function sequences, using map() as above. If we did this, we could, moreover, also return a sin‐ gle ternary expression. The details of this further purely functional refactoring is left to readers as an exercise (hint: it will be ugly; fun to play with, but not good production code). It is hard for <cond> to be useful with the usual tests, such as while myvar==7, since the loop body (by design) cannot change any vari‐ able values. One way to add a more useful condition is to let while_block() return a more interesting value, and compare that return value for a termination condition. Here is a concrete example of eliminating statements: # imperative version of "echo()" def echo_IMP(): while 1: x = input("IMP -- ") if x == 'quit': break else: print(x) echo_IMP() Now let’s remove the while loop for the functional version: # FP version of "echo()" def identity_print(x): # "identity with side-effect" print(x) return x echo_FP = lambda: identity_print(input("FP -- "))=='quit' or echo_FP() echo_FP() Eliminating Loops | 9

What we have accomplished is that we have managed to express a little program that involves I/O, looping, and conditional statements as a pure expression with recursion (in fact, as a function object that can be passed elsewhere if desired). We do still utilize the utility function identity_print(), but this function is completely general, and can be reused in every functional program expression we might create later (it’s a one-time cost). Notice that any expression contain‐ ing identity_print(x) evaluates to the same thing as if it had sim‐ ply contained x; it is only called for its I/O side effect. Eliminating Recursion As with the simple factorial example given above, sometimes we can perform “recursion without recursion” by using func tools.reduce() or other folding operations (other “folds” are not in the Python standard library, but can easily be constructed and/or occur in third-party libraries). A recursion is often simply a way of combining something simpler with an accumulated intermediate result, and that is exactly what reduce() does at heart. A slightly longer discussion of functools.reduce() occurs in the chapter on higher-order functions. 10 | (Avoiding) Flow Control