1. Introduction to Higher Order (Functional Programming) (Python) part 2
John R. Woodward

2. Higher Order Function A higher order function is a function which
- take another function as input Or
Returns a function as output.

3. What does the following print
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
print filter(lambda x: x % 3 == 0, foo)
print map(lambda x: x * , foo)
print reduce(lambda x, y: x + y, foo)

4. output
[18, 9, 24, 12, 27]
[14, 46, 28, 54, 44, 58, 26, 34, 64]
139

5. What does the following print
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
print type(filter(lambda x: x % 3 == 0, foo))
print type(map(lambda x: x * , foo))
print type(reduce(lambda x, y: x + y, foo))

6. output
<type 'list'>
<type 'int'>

7. Lambda – filter, map, reduce
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27] print filter(lambda x: x % 3 == 0, foo) #[18, 9, 24, 12, 27] print map(lambda x: x * , foo) #[14, 46, 28, 54, 44, 58, 26, 34, 64] print reduce(lambda x, y: x + y, foo) #139 #(more detail in a few slides)

8. Lists
Functional programming uses LISTs as its primary data structure. E.g. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
listNumbers = [1,2,3] #[1,2,3]
listNumbers.append(4)#[1, 2, 3, 4]
listNumbers.insert(2, 55)#[1, 2, 55, 3, 4]
listNumbers.remove(55)#[1, 2, 3, 4]
listNumbers.index(4)#3
listNumbers.count(2)#1

9. Map – (a transformation)
Map takes a function and a list and applies the function to each elements in the list
def cube(x): return x*x*x
print map(cube, range(1, 11))
print map(lambda x :x*x*x, range(1, 11))
print map(lambda x :x*x*x, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
#what is the type signature

10. filter
Filter takes a function (what type???) and a list, and returns items which pass the test
def f1(x): return x % 2 != 0
def f2(x): return x % 3 != 0
def f3(x): return x % 2 != 0 and x % 3 != 0
print filter(f1, range(2, 25))
print filter(f2, range(2, 25))
print filter(f3, range(2, 25))

11. filter 2 def f1(x): return x % 2 != 0 def f2(x): return x % 3 != 0
def f3(x): return x % 2 != 0 and x % 3 != 0
print filter(f1, range(2, 25))
# [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23]#odd
print filter(f2, range(2, 25))
# [2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23]
#not divisible by 3
print filter(f3, range(2, 25))
# [5, 7, 11, 13, 17, 19, 23]#not divisible by 2 or 3

12. A list can contain different datatypes
list1 = [0, 1, 0.0, 1.0, True, False, "True", "False", "", None, [True], [False]]
def isTrue(x):
return x
print filter(isTrue, list1)

13. output
list1 = [0, 1, 0.0, 1.0, True, False, "True", "False", "", None, [True], [False]]
#answer
[1, 1.0, True, 'True', 'False', [True], [False]]

14. Reduce – try this reduce( (lambda x, y: x + y), [1,2,3,4] )

15. answers reduce( (lambda x, y: x + y), [1, 2, 3, 4] )10 -8 24

16. The last one
print reduce( (lambda x, y: x / y), [1.0, 2.0, 3.0, 4.0] )
??? answer

17. The last one
print reduce( (lambda x, y: x / y), [1.0, 2.0, 3.0, 4.0] )
# what is the type signature?

18. Map, Reduce, Filter
Map, reduce and filter all take a function as an argument.
What type is the function in each case
Map,
Reduce,
Filter

19. Data Types of Function Taken.
Map: takes an argument of type T and returns a type S. It returns a list of S, denoted [S]
Reduce: takes two arguments of type T, and returns an argument of type T
Filter: take an argument of type T and returns a Boolean (True/False). It returns a list of T, denoted [T]

20. Partial Application Motivating example
Addition (+) takes two arguments
(arg1 + arg2)
What if we only supply one argument?
We cannot compute e.g. (1+)
But it is still a function of one argument
(1+ could be called what???)

21. Visualization ??? 3 ADD ADD 1 ??? 1 2 This is how we normally
think of the add function

22. Inc as partial add #add (2 args), inc(x)=add(1,x)
#inc is a special case of add
from functools import partial
def add(a,b):
return a+b
inc = partial(add, 1)
print inc(4)

23. Inc defined with add #add takes 2 arguments def add(x,y): return x+y
#we can define a new function by hardcoding one variable
def inc(x):
return add(1,x)
print inc(88)

24. double as partial mul #mul(2 args), double(x)=mul(2,x)
#double is a special case of mul
from functools import partial
def mul(a,b):
return a*b
double = partial(mul, 2)
print double(10)

25. Functions as special cases
#square and cube are special cases of the power function
def power(base, exponent):
return base ** exponent
def square(base):
return power(base, 2)
def cube(base):
return power(base, 3)

26. Equivalent Code from functools import partial
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

27. referential transparency
Haskell is a pure functional language referential transparency - the evaluation of an expression does not depend on context.
The value of an expression can be evaluated in any order (all sequences that terminate return the same value) (1+2)+(3+4) we could reduce this in any order.
In the 2nd world war, Richard Feynman was in charge of making calculation for the atomic bomb project.
These calculations were done by humans working in parallel. e.g. calculate exponential

28. Functional Programming
Programming paradigm? Object oriented, imperative
Immutable state (referential transparency)
Higher order functions, partial functions, anonymous functions (lambda)
Map, filter, reduce (fold)
List data structures and recursion feature heavily
Type inference (type signatures)
Lazy and eager evaluation, list comprehension

29. State & Referential Transparency
In maths, a function depends ONLY ON ITS INPUTS e.g. root(4) = +/-2
This is a “stateless function”
A stateful function (method, procedure) stores some data which changes i.e. mutable data
E.g. a “function” which returns the last argument it was given
F(4) = -1, F(55) = 4, F(3) = 55, F(65) = 55,
(side effects, e.g. accessing a file)
Harder to debug stateful function than stateless (why).

30. List Comprehensions
List comprehensions provide a concise way to create lists. 
To make new lists, where each element is the result of some operation applied to each member of another sequence.

31. List Comprehensions
The following are common ways to describe lists (or sets, or tuples, or vectors) in mathematics.
S = {x² : x in 0 ... 9} V = (1, 2, 4, 8, ..., 2¹²) M = {x | x in S and x even}

32. Create a list of squares
For example, assume we want to create a list of squares, like:
squares = []
for x in range(10):
squares.append(x**2)
print squares
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

33. As a list comprehension
We can obtain the same result with:
squares = [x**2 for x in range(10)]
This is also equivalent to 
squares = map(lambda x: x**2, range(10)),
However the list comprehension is more concise and readable.
(choose the way that works for you, but do try different techniques)

34. In Python S = [x**2 for x in range(10)] V = [2**i for i in range(13)]
M = [x for x in S if x % 2 == 0]
print S;
print V;
print M

35. In Python S = [x**2 for x in range(10)] V = [2**i for i in range(13)]
M = [x for x in S if x % 2 == 0]
print S;
print V;
print M
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
1024, 2048, 4096]
[0, 4, 16, 36, 64]

36. Calculating Primes We can calculate the primes by
first build a list of non-prime numbers,
then use another list comprehension to get the "inverse" of the list,

37. Calculating Primes
noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)] print noprimes primes = [x for x in range(2, 50) if x not in noprimes] print primes

38. output noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
print noprimes
#[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 10, 15, 20, 25, 30, 35, 40, 45, 12, 18, 24, 30, 36, 42, 48, 14, 21, 28, 35, 42, 49]
primes = [x for x in range(2, 50) if x not in noprimes]
print primes
#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

39. Nested List Comprehensions
You can nest list comprehensions (just like you can do with other python commands).
In this case just substitute the “noprimes” variable with the python code.
I would not recommend this, as it is harder to read
It is also harder to debug (where would you insert a print statement)

40. Nested List Comprehensions
primes = [x for x in range(2, 50) if x not in [j for i in range(2, 8) for j in range(i*2, 50, i)]]
print primes
#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

41. List Comprehension with Strings
words = 'The quick brown fox jumps over the lazy dog'.split() print words stuff = [[w.upper(), w.lower(), len(w)] for w in words] for i in stuff: print i

42. List Comprehension with Strings
words = 'The quick brown fox jumps over the lazy dog'.split() print words stuff = [[w.upper(), w.lower(), len(w)] for w in words] for i in stuff: print i
['THE', 'the', 3]
['QUICK', 'quick', 5]
['BROWN', 'brown', 5]
['FOX', 'fox', 3]
['JUMPS', 'jumps', 5]
['OVER', 'over', 4]
['LAZY', 'lazy', 4]
['DOG', 'dog', 3]

43. Output 2 <type 'list'>
words = 'The quick brown fox jumps over the lazy dog'.split()
stuff = [[w.upper(), w.lower(), len(w)] for w in words]
for i in stuff:
print i
print type(words)
print type(stuff)
<type 'list'>

44. 3 EXAMPLES print [y for y in [3,1,4]]
print [(x, y) for x in [1,2,3] for y in [3,1,4]]
print [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
OUTPUT
[3, 1, 4]
[(1, 3), (1, 1), (1, 4), (2, 3), (2, 1), (2, 4), (3, 3), (3, 1), (3, 4)]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

45. Written as nested for loops
[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
Is equivalent to
combs = []
for x in [1,2,3]:
for y in [3,1,4]:
if x != y:
combs.append((x, y))
the order of the for and if statements is the same in both
(choose the way that works for you, but do try different techniques)

46. More examples vec = [-4, -2, 0, 2, 4] print [x*2 for x in vec]
print [x for x in vec if x >= 0]
print [abs(x) for x in vec]
fruits = [' banana', ' loganberry ', 'passion fruit ']
4. print [fruit.strip() for fruit in fruits]
5. print [(x, x**2) for x in range(6)]

47. More examples vec = [-4, -2, 0, 2, 4] print [x*2 for x in vec]
print [x for x in vec if x >= 0]
print [abs(x) for x in vec]

48. More examples vec = [-4, -2, 0, 2, 4] print [x*2 for x in vec]
print [x for x in vec if x >= 0]
print [abs(x) for x in vec]
[-8, -4, 0, 4, 8]
[0, 2, 4]
[4, 2, 0, 2, 4]

49. More examples fruits = [' banana', ' loganberry ', 'passion fruit ']
4. print [fruit.strip() for fruit in fruits]
5. print [(x, x**2) for x in range(6)]

50. More examples fruits = [' banana', ' loganberry ', 'passion fruit ']
4. print [fruit.strip() for fruit in fruits]
5. print [(x, x**2) for x in range(6)]
['banana', 'loganberry', 'passion fruit']
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

51. examples
matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],] print [row[i] for row in matrix for i in range(4)] print [[row[i]] for row in matrix for i in range(4)] print [[row[i] for row in matrix] for i in range(4)]

52. output
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12]]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

53. Equivalent to … transposed = [] for i in range(4):
# the following 3 lines implement the nested listcomp
transposed_row = []
for row in matrix:
transposed_row.append(row[i])
transposed.append(transposed_row)