一、函数基础

1. 匿名函数

匿名函数就是没有函数名的函数

匿名函数可以看作类型为function的值，与10，'abc'等作用等价

注意：匿名函数本质还是函数，函数中除了声明语法以外其他的都使用匿名函数

1）语法

lambda 参数列表: 返回值

2）说明

lambda：关键字
参数列表：参数名1, 参数名2,...
:：固定写法（不需要换行和缩进）
返回值：任何有结果的表达式;它是匿名函数的函数体,相当于普通函数中的return语句

3）参数

普通函数中除了用‘参数名: 类型’的形式来指定参数类型以外，其它的语法匿名函数都支持

fn1 = lambda x, y: x + y

fn2 = lambda x: print(x)

print(fn1(10, 20), fn2(10))

sum1 = lambda x, y, z: x + y + z
print(sum1(1, 2, 3))  # 6

sum1 = lambda x, y, z=30: x + y + z
print(sum1(10, 30))  # 70

sum1 = lambda *num: sum(num)
print(sum1(10, 30))  # 40

2. 变量的作用域

变量在程序中能够使用的范围就是变量的作用域

1）全局变量：没有声明在函数或者类里面的变量就是全局变量

作用域是从声明开始到文件结束的任何位置

a = 10  # 全局变量

# x是全局变量
for x in range(5):
    b = 10
    print('循环里面', a)
    print('循环里面', x)

print('外面', b)


def func1():
    print('函数里面', a)
    print('函数里面', x)


func1()

2）局部变量：声明在函数中的变量就是局部变量

函数的参数相当于声明在函数中的局部变量

作用域是从声明开始到函数结束的任何位置

def func2(x1=10, y1=20):
    z1 = 100
    print('函数内部：x1:{}, y1:{}, z1:{}'.format(x1, y1, z1))


func2()

print('函数外：', x1)  # NameError: name 'x1' is not defined
print('函数外：', z1)  # NameError: name 'z1' is not defined

3）函数调用过程（内存）：压栈

当调用函数的时候，系统会自动在内存的栈区间为这个函数开辟一个独立的内存区域

用来保存在函数中声明的变量，当函数调用结束内存区域会自动释放

3. global和nonlocal

global和nonlocal都是在函数中的关键字，和return相同只能在函数体中使用

1）global：在函数中声明一个全局变量

global 变量
变量 = 值

a = 111  # 全局变量a


def func3():
    a = 222  # 局部变量a
    print('in:', a)

    global b  # 全局变量b
    b = 333
    print('in:', b)


func3()

# in: 222
# in: 333
# out 111
# out 333
print('out', a)
print('out', b)

2）nonlocal：在局部的局部中去修改局部变量的值

nonlocal 变量
变量 = 值

def func4():
    a2 = 100

    def func5():
        nonlocal a2
        a2 = 500
        print('in function5:a2', a2)

    func5()
    print('in function4:a2', a2)


# in function5:a2 500
# in function4:a2 500
func4()

二、函数递归

1. 什么是递归函数

自己调自己的函数（函数体中调用当前函数）

循环能做的事情，递归都可以做

注意：能用循环解决的问题就不要用递归

2. 怎么写递归函数

第一步：找临界值（循环结束的条件） - 在这里需要结束函数

第二步：找关系 - 找f(n)和f(n - 1)的关系（找档次循环和上次循环的关系）

第三步：假设函数的功能已经实现，根据关系用f(n - 1)去实现f(n)的功能

# 递归函数1 + 2 + 3 + ... + n

def sum1(n):
    if n == 1:
        return 1
    return n + sum1(n - 1)


print(sum1(100))  # 5050

# 递归函数实现：1,1,2,3,5,8,13,21,34....

def sequence(n):
    if n == 1 or n == 2:
        return 1
    return sequence(n - 2) + sequence(n - 1)


print(sequence(10))  # 55

# 练习：用递归实现以下功能
"""
n = 5
*****
****
***
**
*
"""
def print_star(n: int):
    if n == 1:
        print('*')
        return
    print('*' * n)
    print_star(n - 1)

三、迭代器和生成器

1. 迭代器

迭代器作为容器可以保存多个数据

数据的来源：将其他序列转换成迭代器；生成器

1）将其他序列转换成迭代器

iter1 = iter('abc')
# <str_iterator object at 0x10e328438> <class 'str_iterator'>
print(iter1, type(iter1))

iter2 = iter([12, 30, 90])
# <list_iterator object at 0x10e328550> <class 'list_iterator'>
print(iter2, type(iter2))

2. 获取元素

不管用哪种方式去获取了元素的值，这个元素在迭代器中就不再存在了

1）获取单个元素：

next(迭代器)、迭代器.next() ---> 获取迭代器中的第一个元素

iter3 = iter('hello')
print(next(iter3))  # h
print(next(iter3))  # e
print(next(iter3))  # l
print(iter3.__next__())  # l
print(iter3.__next__())  # 0
# 如果迭代器为空，再次获取元素时会报错
# print(iter3.__next__())  # StopIteration

2）遍历

for 变量 in 迭代器:
    pass

iter4 = iter('world')
for item in iter4:
    print(item)
# w
# o
# r
# l
# d
# print(next(iter4))  # StopIteration


iter4 = iter('world')
print(next(iter4))
for item in iter4:
    print('循环：', item)
# w
# 循环： o
# 循环： r
# 循环： l
# 循环： d

2. 生成器

1）什么是生成器

生成器就是迭代器中的一种

调用一个带有yield关键字的函数就可以得到一个生成器

如果一个函数中有yield关键字：

a. 调用函数不会执行函数体

b. 函数调用表达式的值不是函数的返回值，而是一个生成器对象

2）生成器产生数据的原理

a. 一个生成器能够产生多少数据

是由执行完生成器对应的函数函数体遇到yield的次数决定的

yield后面的值就是生成器能够产生的数据

b. 每次获取生成器元素时

都是先去执行函数体直到遇到yield，并且将yield后面的值作为获取元素的结果；

并且保留结束的位置，下次获取值时，会从上超车结束的位置继续执行函数体，直到遇到yield...

如果从开始执行到函数结束都没有遇到yield，就会报StopIteration错误

def func4():
    for x in range(0, 100, 3):
        yield x


gen4 = func4()
print(next(gen4))  # 0
print(next(gen4))  # 3
print(next(gen4))  # 6