functional programming in Python, part 2

Transcription

1 Programming Languages Week 2 functional programming in Python, part 2 College of Information Science and Engineering Ritsumeikan University

2 review of part 1 eliminating assignment makes programs easier to write and understand easier to prove correct more modular, with easily reusable modules have strictly local effects easier to debug 2

3 mathematical pure functions no side effects, idempotent review: recursive functions compute the answer from current problem and a simpler, related subproblem def factorial(n): return 1 factorial(0) #=> 1 correct for n = 0 factorial(1) #=> 1 correct for n = 1 factorial(2) #=> 1 wrong (for any n >= 2) def factorial(n): return 1 if n < 2 \ else n * factorial(n - 1) factorial(0) #=> 1 correct for n = 0 factorial(1) #=> 1 correct for n = 1 factorial(2) #=> 2 correct for n = 2 factorial(3) #=> 6 correct for n = 3 factorial(4) #=> 24 correct for all n... 3

4 review: lists sequences of values stored in lists iteration variables (list indexes, etc.) successive values of a variable (instead of assignment) series of related values (samples, primes, etc.) range(10, 20) #=> [10, 11, 12,..., 18, 19] range( 10) #=> [0, 1, 2,..., 8, 9] 4

5 map, reduce and filter map: transforming a list of values into another list of values def double(x): return x * 2 range(10) #=> [0, 1, 2, 3,..., 8, 9] map(double, range(10)) #=> [0, 2, 4, 6,..., 16, 18] reduce: collapsing a list of values into a single value def f(x, y): return x + y reduce(f, range(10)) #=> 45 (the sum ) filter: collect elements of a list based on a predicate def f(x): return x % 2 == 0 # returns true iff x is even range(5) #=> [0, 1, 2, 3, 4 ] map(f, range(5)) #=> [True, False, True, False, True] filter(f, range(10)) #=> [0, 2, 4 ] 5

6 functional programming, part 2 higher-order functions treating functions as data closures functions remember the environment in which they were defined currying creating functions that provide one or more arguments for another function composition of functions creating new functions by combining old functions pipelining creating a production line of functions 6

7 higher-order functions a higher-order function is one that accepts one or more functions as arguments, and/or returns a function as its result we have already seen some higher-order functions: map, reduce and filter all take a function as their first argument and how to create a literal function: lambda parameters : expression which can be returned as the result of a function before exploring function results, we have to understand... 7

8 closures consider an anonymous function that returns the sum of its two parameters f = lambda x, y: x + y print f(3, 4) #=> 7 in the body of the function, x and y are local variables they are bound to the arguments supplied when the function is called they exist only during the lifetime of the function call their meanings within a call to f are provided by that call assuming the above definition of f, g = lambda: f print g()(5, 6) #=> 11 g is a global variable bound to a higher-order anonymous function that returns f within the body of g, f is also global variable the meaning of f within the body of g is independent of calls to g to find the meaning of f during a call to g, we have to look outside the call g f is a free variable within the body of g 8

9 closures functions can be nested parameters of an outer function can be free within an inner function def add(x, y): return x + y def makeadder(a): return lambda b: add(a, b) adder = makeadder(100) print map(adder, range(5)) #=> [100, 101, 102, 103, 104] in this example, a is a non-local free variable in the result of makeadder non-local variables are neither local nor global they are inherited variables that are local in some enclosing function 9

10 closures def makeadder(a): return lambda b: add(a, b) print map(makeadder(10), range(5)) #=> [10, 11, 12, 13, 14] each time makeadder is called a new adder function value is created the adder function value remembers the value of a it closes over the current values of any variables that are free within its body these function-like values are called closures they are first-class, and can be applied to arguments just like functions closure = function body + values of closed-over free variables in the above example, we can call makeadder as many times as we like a new adder closure will be returned every time each of them defined in the context of a different call to makeadder and hence, a different version of a each closure therefore closes over a different copy of a, independent of all others 10

11 currying a closed-over parameter can be used to fix one operand of a function def add(x, y): return x + y def makeadder(a): return lambda b: add(a, b) adder = makeadder(100) print map(adder, range(5)) #=> [100, 101, 102, 103, 104] makeadder creates an anonymous unary function from the binary function add the anonymous function fixes one argument of add the other is supplied when the anonymous function is called this process of partial application of a function is called currying after the logician Haskell Curry the function is usually supplied as an argument: curry(f, x) = λy.(f(x, y)) def curry(f, x): return lambda y: f(x, y) print map(curry(add, 10), range(5)) #=> [10, 11, 12, 13, 14] 11

12 function composition in mathematics, functions are composed to create a new function (f g)(x) = f(g(x)) in Python, the corresponding higher-order function: def double(n): return n+n def square(n): return n*n print map(double, range(5)) #=> [0, 2, 4, 6, 8] print map(square, range(5)) #=> [0, 1, 4, 9, 16] def compose(f, g): return lambda x: f(g(x)) #=> f g print map(double, map(square, range(5))) #=> [0, 2, 8, 18, 32] print map(compose(double, square), range(5)) #=> [0, 2, 8, 18, 32] 12

13 pipelining function composition can be generalised to pipelining any number of functions are composed into a single function def composen(functions): return functions[0] if len(functions) < 2 \ else compose(functions[0], composen(functions[1:])) example: to convert a temperature t from Celsius to Farenheit degrees t F = t C from operator import add, sub, mul, div c2f = composen([ curry(add, 32), rcurry(div, 5), curry(mul, 9) ]) print map(c2f, [0, 50, 100]) #=> [32, 122, 212] where the function rcurry(f, y) curries the second argument of f curry(f, x) = λy.(f(x, y)) rcurry(f, y) = λx.(f(x, y)) 13

14 pipelining one advantage of composition and pipelining: avoiding intermediate lists this version of Celsius-to-Farenheit creates three new lists, one for every map print map(curry(add, 32), map(rcurry(div, 5), map(curry(mul, 9), [0, 50, 100]))) #=> [32, 122, 212] this version creates one new list (containing the final results) c2f = composen([ curry(add, 32), rcurry(div, 5), curry(mul, 9) ]) print map(c2f, [0, 50, 100]) #=> [32, 122, 212] 14

15 summary higher-order functions manipulate functions like data e.g., producing new functions based on old new behaviour can be built up incrementally based on many small functions the final complex behaviour can be represented as a single function free variables are those inherited within a function body from outside usually from the local variables of an enclosing function closures are anonymous functions that remember the values of their free variables each time the lambda is executed, the values of free variables are captured in the newly-created closure closures with free variables can be used to fix some of the operands of a function this is called currying functions can be composed easily to create pipelines of useful behaviour represented as a single function, that can be further manipulated and combined 15

16 glossary application the process of calling a function or closure: when a function is called, it is applied to its arguments. bound variable a variable whose value is provided by a parameter or local variable during the execution of a function. close over the process of capturing the values of any free variables occuring in the body of a closure s function at the moment the closure is created (e.g., when control passes the associated lambda expression). The captured values provide bindings for the free variables whenever the closure is applied as a function. closure a combination of function and any saved bindings required to provide values for free variables in the body of the function. compose the process of combining two functions into a single function that applies the two original functions one after the other. currying the process of fixing one of the n operands of a function, producing a new function that takes n 1 operands. free variable a variable that appears in the body of a function but which has no local definition as a variable or function parameter. global a variable that is visible everywhere in a program. higher-order function a function that accepts a function as an argument and/or returns a function as its result. inner function a function that is defined inside another function. local a variable that is created when a function is called, or during the execution of the function s body, and whose lifetime ends when the function returns. 16

17 non-local a variable that is defined by an outer function. If such a variable appears free in a closure that outlives the outer function s execution, its value must be preserved in the closure for use in subsequent applications. outer function a function that defines inner functions or closures. partial application applying a function to some of its arguments, produce a new function that accepts the missing arguments. When all arguments are finally provided, the original function can be applied to them. pipelining composing many functions together to create a useful process. For example, pipelining mul, div and add with curried operands 9, 5 and 32, respectively, will create a Celsius to Farenheit converter. 17