一、复习

1.函数的声明

def 函数名(参数列表):
函数体

lambda 参数列表: 返回值

(重点)函数声明的时候函数体不会执行！

2.函数调用

函数名() <---> 变量() - 要求变量中存储的地址对应的值是function

调用过程:
回到函数声明的位置
传参 - 保证每个参数都有值
执行函数体
确定返回值
回到函数调用的位置

3.函数的参数

位置参数和关键参数
参数默认值
参数类型说明
不定长参数

4.返回值

怎么确定函数的返回值
怎么获取函数的返回值 - 函数调用表达式

5.全局变量和局部变量

6.函数作为量: 声明函数就是声明一个类型是function的变量，函数名就是变量名

例如：

def func1():
    return 10


a = 10
# func1和a是一样的，都是变量

print(a - 1)
print(func1())

a = [1, 2]
print(a[0])

func1 = 'abc'
print(func1[0])

# lambda x: x 和  10是一样的，都是值
num = 10
list1 = [10]

func2 = lambda x: x
list2 = [lambda x: x]

func2(10)
list2[0]('abc')


def yt_sums(*num):
    """求多个数的和"""
    # num = (1, 2, 3, 4)
    sum1 = 0
    for x in num:
        sum1 += x
    return sum1


def yt_product(*num):
    sum1 = 1
    for x in num:
        sum1 *= x
    return sum1


# print(yt_sums(1, 2, 3))
# print(yt_product(2, 4, 6))


def opration(char: str, *nums):
    # char = '+', nums = (1, 2, 3, 4)  *nums 相当于 1, 2, 3, 4
    if char == '+':
        return yt_sums(*nums)  # yt_sums(1,2,3,4)
    else:
        return yt_product(*nums)


print(opration('+', 1, 2, 3, 4))
print(opration('*', 1, 2, 3, 4))

运行结果：

9
10
1
a
10
24

二、递归函数

实际开发的时候，能不用递归就不用

1.什么是递归函数

函数中调用函数本身的函数就是递归函数

2.递归的作用：循环能做的事情递归函数都能做

例如：

def func1():
    print('====')
    func1()


a = 0

def func2():
    global a
    if a < 5:
        print('~~~~~')
        a += 1
        func2()

func2()

运行结果：

~~~~~
~~~~~
~~~~~
~~~~~
~~~~~

3.怎么写递归函数：f(n)

第一步：确定临界值 - 循环结束的条件,在临界值的地方要让函数结束！
第二步：找关系 - 找当次循环和上次循环的关系;
找f(n)和f(n-1)的关系
第三步: 假设函数f的功能已经实现，通过f(n-1)来实现f(n)的功能

例如：

# 实现：1+2+3+...+n
# a.for循环
# n = 20
# # sum1 = 0
# # for x in range(n+1):
# #     sum1 += x
# # print(sum1)


# b.递归
def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2. 找关系
    """
    找yt_sum(n)和yt_sum(n-1)的关系
    yt_sum(n): 1+2+3+...+n-1+n
    yt_sum(n-1): 1+2+3+...n-1
    yt_sum(n) = yt_sum(n-1)+n
    """
    return yt_sum(n-1)+n

print(yt_sum(4))
print(yt_sum(100))

运行结果：

10
5050

练习: 求斐波那契数列第n个数

ef sequence(n):
    # 1.找临界值
    if n == 1 or n == 2:
        return 1
    # 2. f(n)和f(n-1)
    """
    f(n) = f(n-1)+f(n-2)
    """
    return sequence(n-1)+sequence(n-2)


print(sequence(5))

运行结果

5

4.循环能做的事情不能使用递归做！

例如：

sum1 = 0
for x in range(10001):
    sum1 += x
print(sum1)


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


print(yt_sum(100))

运行结果：

50005000
5050

三、模块

1.什么是模块

在python中一个py文件就是一个模块

a.系统模块(标准库) - python系统提供的模块（安装解释器的时候已经导入到解释器中了,使用的时候在代码中直接导入）

random模块 - 提供随机数
math模块 - 提供数学运算
json库 - 提供json数据相关操作
re模块 - 提供正则表达式相关操作
socket模块 - 提供python套接字编程
time模块 - 提供和时间相关的操作
threading模块 - 提供和线程相关的操作
...

b.自定义模块 - 程序员自己创建的py文件

自己写的模块
别人写的模块 - 第三方库 (需要先下载到解释器中，然后才能再代码中导入)

标准库和第三库一般是通过模块提供变量、函数、类

2.怎么使用模块

import 模块名 - 在程序中直接导入指定的模块, 导入后可以使用模块中所有的全局变量(包含了变量、函数和类)
导入后通过"模块名.变量"来使用模块中的内容

from 模块名 import 变量1, 变量2 - 在程序中导入指定的模块，导入后只能使用import后面的变量
导入后直接使用变量,不用在前面加'模块名.'

from 模块名 import * - 在程序中直接导入指定的模块, 导入后可以使用模块中所有的全局变量(包含了变量、函数和类)
导入后直接使用变量,不用在前面加'模块名.'

3.导入模块的实质

a.不管是使用 import 还是 from-import ，导入模块的时候都会执行模块中的所有代码

b.python中，一个模块不会重复导入多次。因为导入的时候系统会自动检查之前有没有导入这个模块

4.怎么阻止模块中的内容被其它模块执行

将不希望被其它模块执行的代码放在 if 语句中，如果希望被其它模块使用的代码就放在 if 语句代码外
写在这个 if 语句中的代码不会被别的模块执行：

if __name__ == '__main__':
    main()

原理：每个模块都有一个 name 属性，代表模块名。默认情况下它的值是 py 文件的文件名。
当前模块正在被执行（）的时候，

5.重命名

导入模块的时候，可以对模块或者模块中的内容重新命名。
import 模块名 as 新模块名
from 模块名 import 变量名1 as 新变量名2, 变量名2 as 新变量名2

四、迭代器

1.什么是迭代器（iter）

是python提供的容器型数据类型
获取迭代器中的元素的时候，只能从前往后一个一个的取，而且取了之后这个元素在迭代器中就不存在了。

2.迭代器的字面量

迭代器没有指定格式的字面量，迭代器作为容器，里面的元素只能通过其他序列转换而成，或者通过生成器生成。
迭代器里面的数据可以是任何数据类型。

iter1 = iter('halo') -----将字符串转换成迭代器，迭代器中的元素就是字符串中的每个元素
iter2 = iter([123, 'adc'], (10, 20), [30, 40]) -----将列表转换成迭代器，迭代器里面的元素就是列表里面的所有元素。

3.获取元素

迭代器里面的元素只支持查，不支持增删改。
迭代器只能通过 next 函数获取单个元素，或者通过 for-in 遍历，一个一个获取每一个元素。
已经获取过的元素，在迭代器里面就不存在了。

a.

next(迭代器) -----获取迭代器里最新（顶层）的数据
如果取完了迭代器里面的数据后还取，会报错。

b.

for i in 迭代器:
print(i)
效果和 next 效果一样，元素还会从迭代器中取出。

五、生成器

1.什么是生成器

生成器就是迭代器，迭代器不一定是生成器。

2.生成器怎么产生元素

调用一个带有 yield 关键字的函数，就能得到一个生成器。
例如：

# 不带 yield 的函数，调用的时候，会执行函数体，并且获取返回值。
def func1():
    print('===')
    return 100


print(func1)


# 带 yield 的函数，调用的时候，不会执行函数体，也不会获取返回值，而是生成一个生成器（函数调用表达式就是一个生成器）。
# 这个生成器中的元素就是 yield 关键字后面的值（元素）
def func2():
    print('===')
    return 100
    yield


print(func2)

运行结果：

===
100
<generator object func2 at 0x000001350B0A5938>

3.生成器的元素

生成器中的元素也是通过 next 或者 for-in
生成器获取元素的时候，实质就是去执行生成器对应的函数，每次执行到 yield 语句为止，
并且会将 yield 后面的值作为当次获取到的元素， 保留当次执行到 yield 的位置。
下次获取元素的时候，会接着上层结束的位置，往后执行，直到遇到下个 yield 为止。以此类推，直到函数结束。
如果执行到函数结束都没有遇到 yield 那么就会报‘stopiterator’错误。
例如：

def func3():
    print('…………')
    yield 1000
    print('!!!!!!')
    yield 100


gen1 = func3()              # gen1 就是一个生成器
print(gen1)
print('打印', next(gen1))
print('打印', next(gen1))

运行结果：

<generator object func3 at 0x000001350B0A5938>
…………
打印 1000
!!!!!!
打印 100

例如：

运行结果：