Higher-Order Functions Announcements

Prime Factorization

Each positive integer n has a set of prime factors: primes whose product is n

...
8 = 2 * 2 * 2
9 = 3 * 3
10 = 2 * 5
11 = 11
Example: Prime Factorization 12 =
...
2 * 2 * 3

One approach: Find the smallest prime factor of n, then divide by it

858 = 2 * 429 = 2 * 3 * 143 = 2 * 3 * 11 * 13

(Demo)

4
 The Fibonacci Sequence

0,
1,
1,
2,
3,
fib pred 5,
8,
curr 13
,
n 5 21
,
34
5
4
3
2
1 ,
k 55
Example: Iteration ,
89
,
14
4,
23
3,
def fib(n): 37
7,
"""Compute the nth Fibonacci number, for N >= 1.""" 61
0,
pred, curr = 0, 1 # 0th and 1st Fibonacci numbers 98
7
k = 1 # curr is the kth Fibonacci number
while k < n:
pred, curr = curr, pred + curr
k = k + 1
return curr The next Fibonacci number is the sum of
the current one and its predecessor

Go Bears!
 Boolean Contexts

def absolute_value(x):
"""Return the absolute value of x."""
if x < 0:
return -x
elif x == 0:
return 0
Control else:
return x

George Boole

10

Boolean Contexts If Statements and Call Expressions

def if_(c, t, f):
Let's try to write a function that does the same thing as an if statement. if c:
def absolute_value(x): return t
"""Return the absolute value of x.""" "if" header This function else:
if x < 0: if __________: expression doesn't exist return f
return -x "if"
elif x == 0: clause _________
Two boolean contexts "if" suite if_(________, ________, ________)
return 0
else: else:
return x "else" "if" header "if" "else"
clause "else" suite expression suite suite
_________
George Boole
Execution Rule for Conditional Statements: Evaluation Rule for Call Expressions:
False values in Python: False, 0, '', None (more to come) Each clause is considered in order. 1. Evaluate the operator and then the
operand subexpressions
True values in Python: Anything else (True) 1. Evaluate the header's expression (if present).
2. Apply the function that is the
2. If it is a true value (or an else header), value of the operator
(Demo)
execute the suite & skip the remaining clauses. to the arguments that are the
values of the operands
(Demo)
11 12
 Logical Operators

To evaluate the expression <left> and <right>:

1. Evaluate the subexpression <left>.

2. If the result is a false value v, then the expression evaluates to v.

3. Otherwise, the expression evaluates to the value of the subexpression <right>.

Short-Circuiting Expressions
To evaluate the expression <left> or <right>:

1. Evaluate the subexpression <left>.

2. If the result is a true value v, then the expression evaluates to v.

3. Otherwise, the expression evaluates to the value of the subexpression <right>.

(Demo)
14

Generalizing Over Computational Processes

The common structure among functions may be a computational process, rather than a number.

5
X
k =1+2+3+4+5 = 15
k=1

Higher-Order Functions
5
X
k 3 = 13 + 23 + 33 + 43 + 53 = 225
k=1

5
X 8 8 8 8 8 8
= + + + + = 3.04
(4k 3) · (4k 1) 3 35 99 195 323
k=1

(Demo)
16
 hof.py Page 2

return total
Summation Example
def identity(k):
return k
Function of a single argument
def cube(k): (not called "term")
return pow(k, 3)
A formal parameter that will
def summation(n, term): be bound to a function
"""Sum the first n terms of a sequence.

>>> summation(5, cube)

225
The cube function is passed
""" as an argument value
total, k = 0, 1
while k <= n:
total, k = total + term(k), k + 1
return total
The function bound to term
0 + 1 + 8 + 27 + 64 + 125
def pi_term(k): gets called here
return 8 / (k * 4 3) / (k * 4 1)
17

# Local function definitions; returning functions

def make_adder(n):
"""Return a function that takes one argument k and returns k + n.
>>> add_three = make_adder(3)
>>> add_three(4)
7
"""
def adder(k):
return k + n
return adder

def compose1(f, g):

"""Return a function that composes f and g.

f, g functions of a single argument

"""
def h(x):
return f(g(x))
return h

@main
def run():
interact()