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.内部修改这个变量在外部有这个变量的第一层函数中生效（即最近以外层作用域）

nonlocal

闭包

关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响。

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()函数：