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

1.什么是递归函数

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

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

a = 0


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


func2()

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

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

实现：1+2+3+...+n

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

递归实现

def gyh_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

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


print(gyh_sum(100))

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

# 1, 1, 2, 3, 5, 8, 13....
def sequence(n):
    # 找临界值
    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(20))

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

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


# def gyh_sum(n):
#     if n == 1:
#         return 1
#     return gyh_sum(n - 1) + n
#
#
# print(gyh_sum(100))

---

1.什么是模块

在python中一个py文件就是一个模块
a.系统模块(标准库) - python系统提供的模块(安装解释器的时候已经导入到解释器中了，使用的时候在代码中直接导入)
random模块 - 提供随机数
math模块 - 提供数学运算
json库 - 提供json数据相关的操作
re模块 - 提供正则表达式相关操作
socket模块 - 提供python套接字编程
time模块 - 提供和时间相关的操作
threading模块 - 提供和线程相关的操作
...

b.自定义模块 - 程序员自己创建的py文件
自己写的模块
别人写的模块 - 第三方库(需要先下载到解释器中，然后才能在代码中导入)

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

import random
print(random.randint(10, 100))

2.怎么使用模块

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

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

from 模块名 import * - 在程序中导入指定模块，并且可以直接使用里面所有的全局变量( * 为通配符)
导入后直接使用变量，不用再前面加 模块名.

3.导入模块的实质：

a.不管是使用import还是from - import,导入模块的时候都会执行模块中所有的代码
b.python中一个模块不会重复导入多次。因为导入的时候系统会自动检查当前模块是否已经导入

print('=======import model1之前=======')
import module1
import module1
print('=======import model1之后=======')
module1.a = 1000
print(module1.a)
print(module1.fun1())

# print('=========from model2 import之前=========')
# from model2 import aa, x
# print('=========from model2 import之后=========')
# print('aa:', aa)
# print(x)
# # print(model2.func2())   # 不能是用model2中除了aa和x的内容

aa = 'hello'
from module2 import *
# 导入model2，并且可以直接使用里面所有的全局变量
print('aa:', aa)
print(x)
func2()

print('==============import model3================')
import module3

# print(model3.a)
# print(model3.b)

模块1：

print('model1开始')
a = 100
print('model1:', a)


def fun1():
    b = 200
    print('test1中的func1被调用', b)

fun1()

print('model1结束')

模块2：

print('model2开始')
aa = 'abc'

for x in range(1000):
    print(x)


def func2():
    print('model2中的func2被调用')


func2()


print('model2结束')

模块3：

# 其他函数的声明
print('if外面的语句')


# 这儿就是程序的入口
def main():
    print('这儿的代码不会被导入')


print('model3:', __name__)

# 写在这个if语句中的代码不会被别的模块执行。
if __name__ == '__main__':
    print('if里面的语句')
    main()

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

将不希望被其他模块执行的代码放在if语句中
如果希望被其他模块使用的代码就放在if语句的外面

(这儿的if语句指的是：if name == 'main')

原理：
每个模块都有一个name属性代表模块名，默认情况下它的值是py文件的文件名。
当当前模块正在被执行(直接执行)的时候，模块属性name的值就会变成main

写在这个if语句中的代码不会被别的模块执行。

# 其他函数的声明

# 这儿就是程序的入口
# def main():
#     print('这儿的代码不会被导入')
#
#
# if __name__ == '__main__':
#     main()

5.重命名 - 导入模块的时候可以对模块或者模块中的内容重新命名

import 模块名 as 新模块名
from 模块名 import 变量名1 as 新变量名1, 变量名2, 变量名3 as 新变量名3

# import module4 as newMode
# print(newMode.age)

name = 100

from module4 import name as gyh_name, age as gyh_age

print(name)
print(gyh_name)
print(gyh_age)

模块4：

name = '小明'
age = 18


def show_info():
    print(name, age)


if __name__ == '__main__':
    pass

---

1.什么是迭代器(iter)

是python提供的容器型数据类型

获取迭代器中的元素的时候只能从前往后一个一个的取，而且取了之后这个元素在迭代器中就不存在了

list1 = [1, 2, 3, 4]
print(list1[0])
print(list1[1])
print(list1[0])

2.迭代器的字面量

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

# 将字符串转换成迭代器，迭代器中的元素就是字符串中的每个字符
iter1 = iter('hello')
print(iter1)

# 将列表转换成迭代器，迭代器中的元素就是列表中的每个元素
iter2 = iter([100, 'shi', (10, 20), [1, 2], True, {'name': '小花'}, lambda x: x])
print(iter2)

3.获取元素

(迭代器中的元素只支持查，不支持增删改)
迭代器是通过next函数获取单个元素，for - in 遍历一个一个获取每一个元素。
不管哪种方式获取，已经获取过的元素，在迭代器中就不存在

iter3 = iter('hello')

# 1.next
"""
next(迭代器)  ->  获取迭代器中最新的数据(最顶层)
"""
print(iter3)
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
# print(next(iter3))    # 报  StopIteration  异常，因为在这儿迭代器中的数据已经取完了
print(iter3)

iter3 = iter('123456')
print(next(iter3))

# 通过for - in取迭代器中的元素和next效果一样，元素还是会从迭代器中取出
for x in iter3:
    print('x:', x)

# print(next(iter3))

练习：看打印结果

iter4 = iter([10, True, 'abc', (1, 2)])

index = 0
for x in iter4:
    index += 1
    if index == 2:
        break

print(next(iter4))
print(next(iter4))

---

1.什么是生成器

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

2.生成器怎么产生元素

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

不带yield的函数：调用的时候会执行函数体，并且获取返回值
带yield的函数：调用的时候不会执行函数体，也不会获取返回值，而是产生一个生成器(函数调用表达式就是一个生成器)
这个生成器中的元素就是yield关键字后面的值

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


print(func1())   # 100

print('=====================')


def func2():
    yield
    print('====')
    return 100


print(func2())    # <generator object func2 at 0x00CBAB70>

3.生成器的元素

生成器中的元素也是通过next或者for - in

生成器获取元素，实质就是去执行生成器对应的函数,每次执行到yield语句为止，并且会将yield后面的值作为当次获取到的元素
下次获取元素的时候会接着上次结束的位置完后执行，直到下一个yield为止...
以此类推，直到函数结束。如果执行到函数结束没有遇到yield那么就会报 StopIteration 异常

def func3():
    print('----')
    yield 100
    print('!!!!!!!!!!')
    yield 'abc'


gen1 = func3()   # gen1就是一个生成器(生成器就是迭代器)
print(gen1)
print(next(gen1))
print('第一次结束')
print(next(gen1))


# py1809001  py1809002  py1809003
def create_num():
    num = 1
    while True:
        yield 'py1809%d' % num
        num += 1


num_gen = create_num()

students = []
for _ in range(10):
    students.append(next(num_gen))

print(students)


def gyh_iter(seq):
    for x in seq:
        yield x


iter1 = gyh_iter('1235')
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))