CS61A_lab02

def cycle(f1, f2, f3):
    """Returns a function that is itself a higher-order function.

    >>> def add1(x):
    ...     return x + 1
    >>> def times2(x):
    ...     return x * 2
    >>> def add3(x):
    ...     return x + 3
    >>> my_cycle = cycle(add1, times2, add3)
    >>> identity = my_cycle(0)
    >>> identity(5)
    5
    >>> add_one_then_double = my_cycle(2)
    >>> add_one_then_double(1)
    4
    >>> do_all_functions = my_cycle(3)
    >>> do_all_functions(2)
    9
    >>> do_more_than_a_cycle = my_cycle(4)
    >>> do_more_than_a_cycle(2)
    10
    >>> do_two_cycles = my_cycle(6)
    >>> do_two_cycles(1)
    19
    """
    "*** YOUR CODE HERE ***"
    def combine(n):
        def F(x):
            p=n//3
            q=n%3
            for i in range(p):
                x=f3(f2(f1(x)))
            if q==0:
                return x
            elif q==1:
                return f1(x)
            else:
                return f2(f1(x))
        return F
    return combine     

评点：

最精妙的地方就在于for循环赋值x【 x=f3(f2(f1(x))) 】，直接将所有大于3的情况都变为3以内的情况，然后再来列举考虑。

 

def lambda_curry2(func):
    """
    Returns a Curried version of a two-argument function FUNC.
    >>> from operator import add, mul, mod
    >>> curried_add = lambda_curry2(add)
    >>> add_three = curried_add(3)
    >>> add_three(5)
    8
    >>> curried_mul = lambda_curry2(mul)
    >>> mul_5 = curried_mul(5)
    >>> mul_5(42)
    210
    >>> lambda_curry2(mod)(123)(10)
    3
    """
    "*** YOUR CODE HERE ***"
    return lambda x :lambda y: func(x,y)

 

题目描述：

Let a path be some sequence of directions, starting with S for start, and followed by a sequence of U and Ds representing up and down directions along the path. For example, the path SUDDDUUU represents the path up, down, down, down, up, up, up.

Your task is to implement the function both_paths, which prints out the path so far (at first just S), and then returns two functions, each of which keeps track of a branch down or up. This is probably easiest to understand with an example, which can be found in the doctest of both_paths as seen below.

代码：

def both_paths(sofar="S"):
    """
    >>> up, down = both_paths()
    S
    >>> upup, updown = up()
    SU
    >>> downup, downdown = down()
    SD
    >>> _ = upup()
    SUU
    """
    "*** YOUR CODE HERE ***"
    print(sofar)
    def up():
        return both_paths(sofar+'U')
    def down():
        return both_paths(sofar+'D')
    return up, down

 

 

 

lambda函数与currying小结

一、例子

1.

>>> def compose1(f, g):
        return lambda x: f(g(x))

等同于

def compose1(f,g):
    def F(x):
        return f(g(x))
    return F

不同于

def compose1(f):
    def F(g):
        return f(g)
    return F

第三段代码等同于

def compose1(f):
    return lambda g: f(g)

2.

>>> def curried_pow(x):
        def h(y):
            return pow(x, y)
        return h

等同于

def curried_pow(x):
    return lambda y: pow(x,y)

3.

def curry2(f):
    def g(x):
        def h(y):
            return f(x,y)
        return h
    return g

等同于

def curry2(f):
    return lambda x: lambda y: f(x,y)

二、总结

lambda表达式其实就是def的省略版本，所以lambda表达式也就是一个函数。不同在于，def能够自己定义函数的名称，而lambda表达式不可以定义名称

冒号之前的变量就是def方式的变量，而冒号后面的操作就是def定义的函数中的操作。

看多个嵌套函数的时候，不应该首先看多个嵌套函数的具体定义，而是应该像编译器一样，先看函数的返回值。由返回值来引导自己看函数的步骤。