Python之函数——进阶篇
嵌套函数
---函数内部可以再次定义函数
---函数若想执行，必须被调用
注意，下例中，执行结果为什么？
age = 19 def func1(): print(age) def func2(): print(age) func2() age = 73 func1()
如下：
执行fun2()时，age按从内而外规则寻找，但age = 73还未执行。但又被检测到赋值语句，因此程序不知道应该从哪里寻找，故报错。
*global、nonlocal关键字：
global：声明变量在全局作用域内使用
nonlocal：声明变量在最近一外层函数作用域内使用
def f1(): a = 1 def f2(): nonlocal a a = 2 f2() print('a in f1 : ',a) f1() #nonlocal关键字: # 1.外部必须有这个变量，此处外部不包括全局作用域 # 2.在内部函数声明nonlocal变量之前内部不能再出现同名变量 # 3.内部修改这个变量在外部有这个变量的第一层函数中生效（即最近以外层作用域）
闭包
关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响。
age = 19 def func1(): age = 73 def func2(): print(age) return func2 val = func1() print(val)
结果如下：
是func2的内存地址！
age = 19 def func1(): age = 73 def func2(): print(age) return func2 val = func1() val()
结果如下：
验证:代码定义完成后，作用域已经生成，无论何时调用该函数，参数值都回回到定义该函数时的作用域内寻找。
闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。
匿名函数
lambda x,y:x*y # 声明一个匿名函数
如何调用匿名函数呢？
func = lambda x,y:x*y print(func(3,8))
把多行代码简写成一行，匿名函数不能支持复杂的代码（如循环），最多跟三元运算符，lambda一般会跟其他方法配合使用。
现在想将一个列表中所有元素自乘，代码如下：
data = list(range(10)) list1 = list(map(lambda x: x*x, data)) print(list1)
结果如下：
函数名的本质和高阶函数
函数名本质上就是函数的内存地址
1.可以被引用
def func(): print('in func') f = func print(f)
2.可以被当作容器类型的元素
def f1(): print('f1') def f2(): print('f2') def f3(): print('f3') l = [f1,f2,f3] d = {'f1':f1,'f2':f2,'f3':f3} #调用 l[0]() d['f2']()
3.可以当作函数的参数和返回值
高阶函数：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
不明白？那就记住一句话，就当普通变量用
第一类对象（first-class object）指 1.可在运行期创建 2.可用作函数参数或返回值 3.可存入变量的实体。
递归
def calc(n,count): print(n, count) if count > 0: return calc(n/2, count-1) else: return n res = calc(188,5) print('res', res)
特性：
--必须有一个明确的结束条件
--每进入更深一层次时，问题规模相比上次递归都应有所减少
--递归的效率不高，递归层次过多会导致栈溢出
列表生成式
有个需求，列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],要求把列表里的每个值加1，你怎么实现？
可以如下实现：
a = map(lambda x:x+1,a)
其实还有一种写法：
b = [i+1 for i in range(10)]
这种写法就叫做列表生成式
又如：
a = [1,2,3,4,5,6,7] a = [i if i<5 else i*i for i in a]
生成器
生成器的创建方式：
1. 类似列表生成式的方式
a = （i+1 for i in range(10)）
next(a)
next(a)
结果如下：
2. 函数
def range_new(n): count = 0 while count < n: yield count count += 1 xrange = range_new(10) print(next(xrange)) # 也可以写成 xrange.__next__ print(next(xrange)) print(next(xrange))
结果如下：
yield vs return
return：返回数据并终止function
yield：返回数据并冻结当前的执行过程
next：唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield
函数有了yield后...
1.函数名加（）就成了一个生成器
2.return在生成器里，代表生成器的终止，会报错（StopIteration：A,A为return的值）
next vs send
next：唤醒冻结的函数执行过程继续执行，直到遇到下一个yield
send：唤醒冻结的函数执行过程继续执行，并且发送一个信息到生成器内部
def range_new(n): count = 0 while count < n: sign = yield count count += 1 if sign == 'Stop': break xrange = range_new(10) print(next(xrange)) xrange.send('Stop')
迭代器
迭代，即是循环。我们已知的可以直接作用域for循环的数据类型有以下几种：
一是集合数据类型，如list、tuple、dict等；
二是generator，包括生成器和带yield的函数。
可迭代对象：这些可以直接作用域for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance（）判断一个对象是否是Iterable对象：
迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
