函数的复习
"""
1.函数的声明
def 函数名(参数列表):
函数体
函数名就是变量名。 上面整个是声明一个变量

lambda 参数列表: 返回值
就相当于一个值

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

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

函数调用过程:
回到函数声明的位置
传参 - 保证每个参数都有值
执行函数体
确定返回值(看有没有return,没有就是None，有就是return后面的值)
回到函数调用的位置

3.函数的参数
位置参数和关键字参数
参数默认值
设置参数类型说明
不定长参数 *把形参变成元祖， **把形参变成字典

4.返回值
怎么确定函数的返回值 - 看有没有return
怎么获取函数的返回值 - 函数调用表达式的值

5.全局变量和局部变量
6.函数作为量:声明函数就是声明一个类型是function的变量，函数名就是变量名
"""

def func1():
    return 10

a = 10
# func1和a是一样的，都是变量
print(a-1)
print(func1())

a = [1, 2]
print(a[0])  # 此时A作为列表

def th_sums(*num):
    """求多个数的和"""
    sum1 = 0
    for x in num:
        sum1 += x
    return sum1

def th_product(*num):
    """求多个数的乘"""
    sum1 = 1
    for x in num:
        sum1 *= x
    return sum1

# 写一个函数，可以对多个数据进行操作
def opration(char: str, *nums):
    # char = '+', nums = (1, 2, 3, 4)
    if char == '+':
        return th_sums(*nums)  # th_sums(1, 2, 3, 4)将元祖拎的数拎出来
    else:
        return th_product(*nums)


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

二 recursionFunction(递归函数)

了解！！！
"""
实际开发的时候，能不用递归就不用(因为递归函数会占内存，而且会损耗cpu)
1.什么是递归函数(应付面试!!!)
在函数中调用函数本身的函数就是递归函数

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

# def func1():
#    print('=====')
#    func1()
# func1()  # 这就是递归函数，但是别执行，会一直打印=====，死循环

a = 0

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

func2()  # 有6个~~~~~ 因为还没到if里面判断的时候就已经执行了一次

"""
3.怎么写递归函数: f(n) f是随便取的变量名
第一步:确定临界值 - 循环结束的条件，在临界值（就是函数执行完）的位置要让递归函数结束!
第二步:找关系 - 找当次循环和上次循环的关系
- 找f(n)和f(n-1)的关系
第三步:假设函数的功能已经实现，通过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 th_sum(n):  # 上面的f就相当于这个th_sum，只是变量名
    # 1.找临界值
    if n == 1:
        return 1

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


"""
th_sum(4):
n=4 4==1 return th_sum(3)+4 ---> return 1+2+3+4
th_sum(3)
n=3 3==1 return th_sum(2)+3  ---> return 1+2+3
th_sum(2):
n=2 2==1 return th_sum(1)+2  ---> return 1+2
th_sum1(1):
n=1 1==1 return 1
"""
print(th_sum(4))  # 上面诠释
print(th_sum(100))

练习:求斐波那契数列第n个数
1, 1, 2, 3, 5, 8, 13....

def sequance(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 sequance(n-1)+sequance(n-2)


print(sequance(5))  # 第5个数5，下面诠释
"""
sequance(5)
n =5 return sequance(5-1)+sequance(5-2) | 1+1+1(是sequance(4)的值)+1+1(是sequance(3)的值)
sequance(4)
n =4 return sequance(4-1)+sequance(4-2) | 1+1+1
sequance(3)
n =3 return sequance(3-1)+sequance(3-2) | 1+1
sequance(2)
n=2 return 1+0 |1
sequance(1)
n=1 return 1 | 1 前两个数都为1
"""

三 module(模块)

"""
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 name=='main':)
原理:
每个模块都有一个name属性，代表模块名。默认情况下它的值是py文件的文件名
当前模块正在被执行(直接执行)的时候，模块属性name的值就会变成'main'
"""

# 1. 系统模块
import random
print(random.randint(10, 100))

print('=======import model1之前=======')
import model1
import model1
print('=======import model1之后=======')
model1.a = 1000
print(model1.a)
print(model1.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 model2 import *
# 导入model2，并且可以直接使用里面所有的全局变量
print('aa:', aa)
print(x)
func2()

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

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

#另一个模块model3
# 其他函数的声明
print('if外面的语句')

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

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

"""
5.重命名 - 导入模块的时候可以对模块或者模块中的内容重新命名
import 模块名 as 新模块名
from 模块名 import 变量名1 as 新变量名1, 变量名2, 变量名3 as 新变量名3
"""

#另一个模块
name = '小敏'
age = 18

def show_info():
    print(name, age)
# import model4 as newMode
# print(newMode.age)

import threading as TD
name = 100

from model4 import name as yt_name, age as yt_age

print(name)
print(yt_name)
print(yt_age)

三 iterator(迭代器)（重点）

"""
1.什么是迭代器(iter)
是python提供的容器型数据类型 (列表那些也是容器)
获取迭代器中的元素的时候只能从前往后一个一个的取，而且取了之后这个元素在迭代器中就不存在了。

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

list1 = [1, 2, 3, 4]
print(list1[0])
print(list1[1])
print(list1[0])  # 元素还在
# 将字符串转换成迭代器，迭代器中的元素就是字符串中的每个字符
iter1 = iter('hello')
print(iter1)  # <str_iterator object at 0x006430B0> 字符串迭代器

# 将列表转换成迭代器，迭代器中的元素就是列表中的每个字符
iter2 = iter([100, 'shj', (10, 20), [1, 2], True, {'name': '小花'}, lambda x: x])
print(iter2)  # <list_iterator object at 0x007E35B0>

"""
3.获取元素
(迭代器中的元素只支持查，不支持增删改)
迭代器只能通过next函数获取单个元素, 通过for in变量一个一个获取每一个元素。
不管是哪种方式获取，已经获取过得元素，在迭代器中就不存在
"""

iter3 = iter('hello')

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

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

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

# 练习:看打印结果
iter4 = iter([10, True, 'abc', (1, 2)])
index = 0
for x in iter4:
    index += 1
    if index == 2:
        break

"""
index = 0
x = 10 iter = True,'abc',(1,2) index= 1 if 1==2不成立
x = True iter = 'abc',(1,2) index= 2 if 2==2 成立 结束
"""
print(next(iter4))  # abc

五generator(生成器)

"""
1.什么是生成器
生成器就是迭代器,迭代器不一定是生成器。

2.生成器怎么产生元素
一调用一个带有yield关键字的函数就能得到一个生成器

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

# 普通函数
def func1():
    print('====')
    return 100


print(func1())  # ==== 100


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


print(func2())  # <generator object func2 at 0x00737ED0> 因为有yield,就产生一个生成器,就看有没有，不管他执不执行

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

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

print('===================')
def func3():
    print('~~~~~')
    yield 100
    print('!!!!!!!!!!!')
    yield 'abc'

gen1 = func3()  # gen1就是一个生成器(生成器就是迭代器)
print(gen1)
# next
print('打印:', next(gen1))  # 打印: 100
print('第一次结束')
print('打印', next(gen1))  # 打印 abc

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


new_gen = creat_num()
for _ in range(10):
    print(next(new_gen))

print('上了两天的课')
print(next(new_gen))  # py180911

# iter1 = iter('1234') 它的内部
def yt_iter(seq):
    def func():
        for x in seq:
            yield x
    return func()

iter1 = yt_iter('abc')
print(next(iter1))  # a
print(next(iter1))  # b