深入解析python返回函数和匿名函数

1、定义一个求和的函数，可以这样写
# -*- coding: utf-8 -*-
def test_1(*args):
    i = 0
    for n in args:
        i = i + n
    return i

print(test_1(10,20,30))

#输出
60

但是如果不需要立即求和，而是需要在后面的代码中再进行计算改怎么办，当出现这种情况时，就可以不返回求和的结果，而是返回求和的参数，修改后可以这样写：
# -*- coding: utf-8 -*-
def test_1(*args):
    def test_sum():
        i = 0
        for n in args:
            i = i + n
        return i
    return test_sum

f = test_1(10,20,30)
print(f)
print(f())

#输出
<function test_1.<locals>.test_sum at 0x0000020483CAE7A0>
60

可以看出，当把函数的结果赋值给f时，直接输出f，返回的是函数，只有在调用 f( ) 时，才会返回结果

# -*- coding: utf-8 -*-
def test_1(*args):
    def test_sum():
        i = 0
        for n in args:
            i = i + n
        return i
    return test_sum

f1 = test_1(10,20,30)
f2 = test_1(10,20,30)
print(f1)
print(f1())
print(f2)
print(f2())
if f1 == f2 :
    print("yes")
else:
    print("error")

#输出
<function test_1.<locals>.test_sum at 0x000001F27E2AE7A0>
60
<function test_1.<locals>.test_sum at 0x000001F27E2AE8C0>
60
error

可以看到，就算参数相同、返回的值相同，但是每次调用函数返回的函数是不一样的

# -*- coding: utf-8 -*-
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())

#输出：
9
9
9

可以发现，连续把count函数赋值了三次变量后，引用变量时，返回的值全部都是9，这是因为返回函数 f( ) 中调用了局部变量i，而i是for循环引用的函数，在赋值 count( ) 函数到变量时，因为并没有直接调用函数，所以内部函数 f( ) 其实是没有执行的，只是进行了循环，而赋值三次后，变量i已经循环到了3，这时候调用了函数，内部函数 f( ) 在这个时候执行了，所以三次的结果都是9

# -*- coding: utf-8 -*-
def count():
    def f(j):
        def g():
            return j * j
        return g
    fs = []
    for i in range(1,4):
        fs.append(f(i))
    return fs

f1,f2,f3 = count()
print(f1())
print(f2())
print(f3())

#输出：
1
4
9

这样写，在函数中就调用了函数

# -*- coding: utf-8 -*-
def inc():
    x = 0
    def fn():
        # 可以看到这里只是读取了x的值:
        return x + 1
    return fn

f = inc()
print(f()) 
print(f()) 

#输出
1
1

# -*- coding: utf-8 -*-
def inc():
    x = 0
    def fn():
        # 这里在内部函数修改了外部函数变量的值
        return x = x + 1
    return fn

f = inc()
print(f()) 
print(f()) 

#输出，这里直接就报错了
  File "c:\Users\RZY\Desktop\work\py\test.py", line 5
    return x = x + 1
             ^
SyntaxError: invalid syntax

# -*- coding: utf-8 -*-
def inc():
    x = 0
    def fn():
        # 先声明x变量不是fn函数的局部变量
        nonlocal x
        x = x + 1
        return x
    return fn

f = inc()
print(f()) 
print(f()) 

#输出
1
2

- 利用闭包返回一个计数器函数，每次调用它返回递增整数
# -*- coding: utf-8 -*-
def createCounter():
    x = 0 
    def counter():
        nonlocal x 
        x = x + 1
        return x 
    return counter

# 测试:
counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5
counterB = createCounter()
if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]:
    print('测试通过!')
else:
    print('测试失败!')
    
#输出
1 2 3 4 5
测试通过!

#解析
其实和上面类似，利用nonlocal声明之后可以使内部函数修改外部函数的变量，然后返回一个函数，从而实现每次调用递增

#使用匿名函数：
>>> list(map(lambda x:x * x,[1,2,3,4,5,6]))  
[1, 4, 9, 16, 25, 36]

#定义函数：
>>> def f(x):
...     return x * x
... 
>>> list(map(f,[1,2,3,4,5,6]))   
[1, 4, 9, 16, 25, 36]

#虽然两种方法都可以达到效果，但是可以看出匿名函数比较简洁

>>> f = lambda  x : x*x
>>> f
<function <lambda> at 0x0000020CE841E7A0>
>>> f(22) 
484

#匿名函数也可以作为函数的返回值
>>> def f(x,y):
...     return lambda: x * y    
... 
>>> a = f(5,6) 
>>> a()
30

- 利用匿名函数改造下面代码，使之更为简洁
# -*- coding: utf-8 -*-
def is_odd(n):
    return n % 2 == 1

L = list(filter(is_odd, range(1, 20)))

print(L)
#输出：
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

- 改造成匿名函数后：
# -*- coding: utf-8 -*-
L = list(filter(lambda x:x % 2 ==1, range(1, 20)))

print(L)
#输出：
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]