python函数式编程之返回函数

Veröffentlicht am

函数作为返回值

1.返回函数

返回函数时相关参数和变量保存在返回函数中

1
2
3
4
5
6
7
8
9
10
11
def lazy_sum(*args):
    def sum():
        ans = 0
        for i in args:
            ans = ans+i
        return ans
    return sum
a = lazy_sum(1,2,3,4,5)
print(a)#返回函数
b = a()
print(b)#返回结果

1
2
<function lazy_sum.<locals>.sum at 0x7f47807908c8>
15

每次调用lazy_sum时，都会返回一个新的函数，即使传入相同的参数

1
2
3
f1 = lazy_sum()
f2 = lazy_sum()
print(f1 == f2)

1
False

2.闭包

闭包：
1.内部函数可以引用外部函数的参数或变量（不一定就是上一层函数中的参数和变量）
2.外部函数把内部函数作为返回值，相关参数和变量都保存在内部函数中

1
2
3
4
5
6
7
8
9
10
11
def count():
    fn = []
    for i in range(1, 4):
        def get():
            def f():
                return i * i
            return f
        fn.append(get())
    return fn
f1,f2,f3 = count()
print(f1(),f2(),f3())

1
9 9 9

直到调用f()才执行函数，此时i已经变成３,所以最终结果是9 9 9，而不是1,4,9
所以函数最好不要引用循环变量，以及后续会发生变化的量
如果一定要引用循环变量，再创建一个函数，用函数绑定当前循环变量的值

1
2
3
4
5
6
7
8
9
10
11
def count():
    def f(j):
        def g():
            return j*j
        return g
    fn = []
    for i in range(1,4):
        fn.append(f(i))
    return fn
f1,f2,f3 = count()
print(f1(),f2(),f3())

1
1 4 9

3.练习

闭包返回计数器函数，每次返回递增整数

1
2
3
4
5
6
7
8
9
def createCounter():
    i = 0
    def counter():
        nonlocal i#闭包对闭包函数外，函数内的变量进行引用
        i = i+1
        return i
    return counter
countA = createCounter()
print(countA(),countA(),countA())

1
1 2 3

4.三种不同写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#----------------------------------------------------
def count():
fn = []
def get():
    def f():
        return 3*3
    return f#######返回f函数
fn.append(get())###返回结果
return fn
#----------------------------------------------------
def count():
fn = []
def get():
    def f():
        return 3*3
    return f()######返回结果
fn.append(get)#####返回函数
return fn
#----------------------------------------------------
def count():
fn = []
def f():
    return 3*3
fn.append(f)#####返回函数
return fn

最终结果都是一样的哈哈，现在的程序员，真的是……没毛病！！！