Programming Languages

Transcription

1 Programming Languages Week 2 Exercises 0. a) Open an interactive Python 2 session (either in a terminal window, or in an IDE that allows small sections of code to be executed). To open a terminal window on Mac, use the Finder to look in Applications and then Utilities for Terminal.app. Run it. In the terminal window, type python2.7 to start Python. Enter the following expressions and observe the results. If any result does not make sense, ask for an explanation. b) Executing a lambda creates an anonymous function (a closure, to be precise). lambda: 13 (lambda: 13)() lambda x: x+x ( lambda x: x+x)(9) lambda x, y: x-y ( lambda x, y: x-y)(3, 4) def f(): return lambda x, y: x-y f() f()(15, 10) c) Moving one of the arguments from the lambda to an enclosing function will forever fix that argument to the value it had when the lambda is executed to create the closure. def f(x): return lambda y: x-y f(16) f(16)(9) g = f(13) g(7) g(8) g(9) h = f(17) h(7) h(8) h(9) map(h, range (17)) If closures still do not make sense to you, please ask for help now. Otherwise, please attempt the following exercises.

2 1. Create a function makeadder() that returns a closure which applies its arguments to add, a binary function that adds its arguments. def makeadder(): return lambda a, b: add(a, b) makeadder()(3, 4) Move the first argument of the lambda to the enclosing function, so that it will be fixed. Use the resulting makeadder(a) function to create three unary adder functions. Demonstrate that the amounts they add are independent of each other. def makeadder... # fill in the blank a, b, c = makeadder (100), makeadder (200), makeadder (300) print map(a, range(5)), map(b, range(5)), map(c, range(5)) 2. Use the function curry(f, x) to achieve the same result. from operator import add def curry(f, x): return lambda y: f(x, y) a, b, c = curry (...),... # fill in the blanks print map(a, range(5)), map(b, range(5)), map(c, range(5)) 3. Use curry to create a reciprocal function that returns 1/x. from operator import div print map(curry(...,...), range(1, 6)) # fill in the blanks #=> [1.0, 0.5, , 0.25, 0.2] 4. Write the function rcurry that curries the second operand of a function. (rcurry will be almost the same as curry. See the lecture slides for a hint about its definition, if it is not obvious.) Use rcurry to divide a list of numbers by 2. from operator import div print map( rcurry(div, 2), range (10)) #=> [0, 0, 1, 1,..., 4, 4] 5. Use compose() to create a Farenheit to Celsius converter: subtract 32, multiply by 5, then divide by 9. (You will have to use compose twice, to combine three curried functions.) from operator import sub, mul, div def compose(f, g): return lambda x: f(g(x)) f2c = compose (... compose (...)...) # fill in the blanks print map(f2c, [0, 50, 100]) #=> [-18, 10, 37] 6. Prove that function composition is associative. The easiest way to do this is to use compose in a different order when defining f2c. Note that the three curried functions will still appear in the same order, but will be grouped differently by compose.) 7. Define f2c as a pipeline, using composen(). def composen( functions): return functions [0] if len( functions) < 2 \ else compose( functions[0], composen( functions [1:])) 2

3 Programming Languages Week 2 Additional Challenges 8. Define composen() using reduce instead of recursion. Demonstrate that it still works by defining f2c using your new definition and then running it on the same list of inputs. 9. Define your own mymap(), myreduce() and myfilter(), as recursive functions. def mymap(function, values):... def myreduce( function, values):... def myfilter( function, values):... from operator import add def iseven(x): return x % 2 == 0 print mymap(iseven, range(5)) #=> [True, False, True, False, True] print myreduce(add, range(5)) #=> 10 print myfilter(iseven, range(5)) #=> [0, 2, 4] 10. The behaviour of composen() is not very intuitive: it applies the given functions from right to left. Define another function pipeline() that works like composen() except that it applies the functions from left to right. def pipeline(functions):... c2f = pipeline([ curry(mul, 9), rcurry(div, 5), curry(add, 32)]) print map(c2f, [0, 50, 100]) 11. Define makecounter(n) that creates a counter closure that returns an integer each time it is called, starting at n and increasing by 1 each time. Because assignment is a statement in Python, and only a single expression can form the body of a lambda, you will have to def a named function inside makecounter and return your inner function as the result of makecounter. Note that named functions cannot contain non-local variables in Python 2, so you will have to use Python 3 for this problem and obtain access to non-local variables using the nonlocal keyword (which behaves like the global keyword). a, b, c = makecounter (0), makecounter (10), makecounter (20) print(a()) #=> 1 print(b()) #=> 11 print(c()) #=> 21 print(a()) #=> 2 print(b()) #=> 12 print(c()) #=> 22 print(a()) #=> 3 print(b()) #=> 13 print(c()) #=> 23 3

4 12. The creator of Python once tried to remove lambda, map, filter and reduce from the language [1]. The Python community refused to let him do it and eventually he gave up, writing: After so many attempts to come up with an alternative for lambda, perhaps we should admit defeat. I ve not had the time to follow the most recent rounds, but I propose that we keep lambda, so as to stop wasting everybody s talent and time on an impossible quest. [2] He still removed reduce from the language, however, and made it a library function instead (in Python 3). Of the three list-manipulating functions, reduce is precisely the one that should not be removed; it is the more fundamental operation of the three. In other words, map and filter can very easily be written in terms of reduce, whereas reduce cannot be written in terms of map and/or filter. Write two functions mymap and myfilter using only conditional expressions, reduce, list addition (concatenation), and the list-contructing expression [value] ; i.e: x if y else z reduce(fn, r, l) [1] + [2] [value ] #=> x or z, depending on y #=> fn(fn(fn(l, r[0]), r[1])..., r[-1]) #=> [1 2] ( list concatenation) #=> [ value] (list construction) (Note that the third argument to reduce provides the initial first operand to the reducing function, and also the value to be used as the default result in case the list of items to reduce is empty. Note also that reduce works on any data type, not just numbers.) Test your functions as follows: print mymap( lambda x: x*x, range(5)) #=> [0, 1, 4, 9, 16] print mymap(lambda x: x*x, []) #=> [] print myfilter( lambda x: x%2, range (10)) #=> [1, 3, 5, 7, 9] print myfilter(lambda x: x%2, []) #=> [] 13. Use map and filter to write a function indices(predicate, alist) that returns a list of the indices of all the items in alist for which predicate(item) returns True. Test your function on the following example: indices( lambda x: x%2 == 1, range(10, 20)) #=> [1, 3, 5, 7, 9] (You might find the function enumerate(collection) useful for this. When the collection is a list, enumerate generates a list of ordered pairs containing the indices and corresponding elements in the collection. For example: list(enumerate([ a, b, c ])) #=> [(0, a ), (1, b ), (2, c )] An ordered pair (1, 2) is just like a list [1, 2] except that it is immutable. Ordered pairs are tuples that contain two elements. Tuples and lists are very similar, and indexing works exactly the same on both of them. Unlike lists, tuples are immutable once created, they cannot be modified. Tuples probably were once more efficient than lists, but now lists are faster in most cases.) [1] [2] 4

5 14. [Difficult] The terminal window s cursor can be moved by printing special sequences of non-printing characters [3]. We can use this to create animations. The following program simulates a race between three snails, using the terminal s cursor movement commands to animate the race as it unfolds: from random import random from time import sleep CursorUp = \033[ A # escape sequence to move cursor up one line NewLine = \n Space = Snail Trail = _ distance = 50 snails = [0, 0, 0] winners = [] print NewLine * 4 while not winners: print CursorUp * 4 for snail in range(3): if random() > 0.5: snails[ snail] += 1 if snails[ snail] == distance: winners. append( snail + 1) print Trail * snails[ snail] + Snail sleep (0.05) print "winner(s):", for i in winners: print i, print Rewrite the simulation in functional style, without using assignments =, +=, or similar. (You might want to reduce the sleep time to while working on this. Watching slow snails race each other can rapidly become unexciting.) Your solution will probably use all three of map, filter and reduce (including the optional third argument to reduce which provides a default value for an empty list of operands). 15. [Easy] Modify your solution to the previous question so that it simulates a race between three cows. ( ) (oo) / \/ / * ---- ^^ ^^ 16. [Easy] Use the information in reference [3] to turn your cows green. ( ) (oo) / \/ / * ---- ^^ ^^ [3] 5