01-recode

1.函数声明

def 函数名（参数列表）：
    函数体

匿名函数
lambda 参数列表：返回值

2.函数调用

函数名（）   <--->   变量（） - 要求变量中存储的地址对应的值是function
注意：函数声明的时候函数体不会执行（重点）

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

3.函数的参数

位置参数和关键字参数
参数默认值
参数类型说明（两种1.直接等于一个默认值，2.冒号：类型名）
不定长参数

4.返回值

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

5.全局变量 和 局部变量

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

---

---

---

02-recursionFuntion

（了解）
实际开发的时候，能不用递归就不用
1.什么是递归函数
函数中调用函数本身的函数就递归函数

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

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

---

# 1+2+3+...+n
# for 循环
# n = 100
# sum1 = 0
# for x in range(n + 1):
#     sum1 += x
# print(sum1)


# 递归
def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1
    #     2.找关系
    return yt_sum(n - 1) + n


"""
找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
"""

print(yt_sum(100))

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

# 1,1,2,3,5,8,13....
def sequence(n):
    # 1.找临界值2
    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))
"""
4.循环能做的事情不能使用递归做！
"""

---

---

---

03-model

1.什么是模块
在python中一个py文件就是一个py模块
a.系统模块（标准库） - python系统提供的模块（安装解释器的时候已经导入
到解释器中了，使用的时候在代码中直接导入）

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

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

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

2.怎么使用模块
import 模块名 - 在程序中直接导入指定的模块，导入后可以使用模块中所有的全局变量
（包含了变量、函数和类）
                导入后通过"模块名.变量"来使用

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

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

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

4.怎么阻止模块中的内容被其他模块执行
将不希望被其他模块执行的代码放在if语句中（if __name__ == '__main__':）
如果希望被其他模块使用的代码放在if语句的外面

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

---

# 1.系统模块
# import time
# print(time.localtime())  提供本地时间

import model

print(model.a)
print(model.func1())

# from model2 import aa,x
#
# print(aa)
# print(x)
# print(model2.func2())  不能使用model2中除了aa 和x的内容

# 导入model2，并且可以直接使用里面所有的全局变量
from model2 import *  # * 表示通配符

print(aa)
print(x)
func2()

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

name = '和'
print(newmode.age)

from model4 import name as yt_name, age as  yt_age

print(yt_name, yt_age)

---

---

---

04-iterator

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

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

---

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

# 将列表转换成迭代器，迭代器中的元素就是列表中每个元素
list1 = [112, 23, 45, 68]
iter1 = iter(list1)
print(iter1, type(iter1))

3.获取元素
迭代器中的元素只支持查，不支持增删改
迭代器只能通过next函数获取单个元素，for - in遍历一个一个获取每一个元素。
不管怎么获取，已经获取过的元素，在迭代器中就不存在
"""
iter3 = iter('hello')
# 1.next
"""
next(迭代器) -> 获取迭代器中最新的数据（最顶层）
"""
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
# print(next(iter3))   报'StopIteration'异常，因为在这迭代器中的数据已经取完了

iter3 = iter('123456')

# 通过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


item = next(iter4)
print(item)
print(next(iter4))

---

---

---

05-generator

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

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

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

---

def func1():
    yield 1


print(func1())  # <generator object func1 at 0x0000023FA50FA830>

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

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

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


def func3():
    print('~~~~~~~~~~~~~')
    yield 100


gen1 = func3()  # gen1就是一个生成器（生成器就是迭代器）
print(gen1)
print('打印：', next(gen1))


# 产生学号python1809001
def creat_num():
    num = 1
    while True:
        yield 'python1809%d' % num
        num += 1


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

print('上了两天课')
students.append(next(num_gen))
# print(next(num_gen))
students.pop(9)
print(students)
students.append(next(num_gen))
print(students)
print('=====================================================')


def yt_iter(seq):
    def func1():
        for x in seq:
            yield x

    return func1()


iter1 = yt_iter('abc')