函数的进阶2

本节内容：

1.函数的嵌套回顾及延伸

2.闭包

3.迭代器

4.递归

我们说了，函数的嵌套有两种，其中一种就是：函数里面还有函数：

def 函数1:
    def 函数2:
下面的这种也叫作函数的嵌套，虽然没有调用。

def func():
    func1()

①函数的嵌套：

1 def func1():
2     print(2)
3     func2()
4 def func2():
5     print(1)
6 func1()

解构：

1 *c,a,b,d,e = [1,2,3,4]
2 print(c)

结果：

[]

函数名的使用：

首先我们来看看：

1 def func():
2     pass
3 print(func)  # 得到了函数的内存地址

结果：

<function func at 0x0000000001CFC1E0>

说明，打印函数会得到一个函数的内存地址。

那么我们可以利用函数的值（地址）来命名变量。

1 def func():
2     print(1)
3 a = func
4 
5 a()
6 func()  # 函数名可以当做值赋值给变量

函数名可以被当做元素放在容器里。

1 def func():
2     print(1)
3 #
4 def func2():
5     print(2)
6 #
7 li = [func,func2]
8 print(li)  # 函数名可以当做元素放到容器里

1 def func():
2     def aa():
3         print(2)
4         return None
5     return aa()  # return None
6 func() # func() == None

 1 def f():
 2     def a():
 3         def b():
 4             def c():
 5                 return '哈撒给!'
 6             return c()
 7         return b()
 8     return a()
 9 print(f())
10 
11 结果：哈撒给!

下面有一道经典的例题:

1 for i in range(3):
2     def func(x):
3         print(x*i)
4     func(2)  
5 
6 结果：0 2 4

加深难度：

1 li = [] # [func,func,func]
2 for i in range(3):
3     def func(x):
4         print(x*i)
5     li.append(func)
6 
7 for func in li: # [func,func,func]
8     func(2)

1 li = []
2 for i in range(3):
3     def func(x,y=i):
4         print(x*y)
5     li.append(func)
6 
7 for func in li:
8     func(2)

1 def s():
2     print(1)
3 
4 def func(s11):
5     s11()
6 
7 func(s)

2.闭包

1.一个嵌套函数
2.在嵌套函数的内部函数使用外部(非全局的变量)的引用
满足以上两条就是闭包

1 def wrapper():
2     a = 10
3     def inner():
4        print(a)
5     return inner
6 inner = wrapper()
7 inner()

1 def func1():
2     name = "alex"
3     def func2():
4         print(name)
5         # 闭包
6     func2()
7 func1()
8 # 结果: alex

我们可以使用__closure__来检测函数是否是闭包. 使用函数名.__closure__返回cell就是
闭包. 返回None就不是闭包

3.迭代器

 首先我们说说，可迭代对象：

可以被for的就是可迭代对象

具有.__iter__方法的就是可迭代对象
a = 对象.__iter__      就是 创建一个迭代器
具有__iter__和__next__ 就是一个迭代器

1 li = [1,2,3]
2 a = li.__iter__()
3 print(a.__next__())
4 print(a.__next__())  #一个一个取
5 print(a.__next__())

迭代器特性:
    1.惰性机制，一次输出一个值
    2.不能从下向上走
    3.一次性的,用完就没了

 4.递归