1. recode
1. 匿名函数
格式：
lambda 参数列表: 返回值 常用情况：函数名 = lambda 参数列表: 返回值
匿名函数也是函数
2. 变量的作用域
全局变量：没有声明在函数或者类中的变量都是全局变量
作用域从声明开始到py文件结束
局部变量：声明在函数和类中的变量
作用域从声明开始到函数或类结束
关键字:
global: 在函数中声明一个全局变量/或者想要在函数中修改全局变量的值
nonlocal: 想要在局部的局部去修改一个局部变量的值，我们就使用nonlacal
3. 函数作为变量
声明函数就是在声明一个类型是function的变量。普通变量能做的事情，函数都能做
函数名 ---> 一个函数
函数名() ---> 调用函数，拿到的是函数的返回值
函数作为参数 ---> 闭包的概念(以后会讲)
函数作为返回值 ---> 装饰器(以后会讲)
4. 函数的调用过程
函数的调用过程是一个压栈的过程(适用于所有语言)
调用函数时，系统会自动在栈区间开辟空间存储数据(函数的参数，函数中声明的变量)， 调用结束后内存和数据会自动销毁
a = 10
b = 20
def func_a (a, b):
a, b = b, a
print(a, b)
func_a(a, b)
print(a, b)
5. 递归函数 ---> 自己调用自己
循环能做的递归都能做，但是能用循环的就不要用递归(短时间内会进行内存的大量开辟和释放， 会消耗cpu)
步骤：
第一: 找临界值(找出循环结束的条件，这儿要让函数结束)
第二: 找当次循环( f(n) )和上次循环( f(n-1) )的关系
第三: 用f(n-1)去实现f(n)的功能
2. 模块的使用
1. 什么是模块
python中一个py文件就是一个模块,可以通过import 模块或者from-import在一个模块中去使用另一个模块
2. 导入模块
import 模块名 ---> 导入模块中所有内容,并且在当前模块中通过"模块名."的方式去使用模块中的所有全局变量
from 模块名 import 变量1, 变量2…… ---> 将模块中的所有内容都导入，但是只能使用import后导入的变量
from 模块名 import* ---> 将模块中所有内容导入，可以直接使用模块中的全局变量
代码执行到import的时候，会讲import模块中的代码内容执行一遍
# import ey_module
#
# # 使用test1 中的整型变量
# print(ey_module.ey_test + 100)
# # 使用eryang_module中的函数eryang_func
# ey_module.ey_func()
# print("当前模块", ey_test)
# print(ey_func())
# # 使用*
# from ey_module import *
# print("当前模块", ey_test)
# print(ey_func())
3. 重命名
import 模块 as 模块新的名字
from 模块 import 变量名1 as 新的名字, 变量名2 as 新的名字 ……
"""
er_tese = "name"
# import ey_module as aa
# print(aa.ey_test)
# from ey_module import ey_test as a
# print(er_tese) # 使用当前模块的 ey_test
# print(a) # 使用ey_module中的 ey_test
import: 可以检查被导入的内容之前是否已经导入过，如果导入过，不会再重复导入
导入多次，但是只执行一次。多种导入只执行一次
3. 选择性导入
1. 阻止导入的方法
if __name__ == "__main__":
代码块
说明：
if name =="main": ---> 固定写法
代码块 ---> 在当前模块直接执行，代码块会被执行，如果被别的模块导入，这个代码块不会执行
2. 每一个模块都有一个name属性，这个属性的默认值是当前模块对应的py文件的文件名
当当前模块正在被直接执行的时候，系统会自动将模块的name属性变成main
3. 什么时候使用模块
将具有相似或相同的功能的函数和数据封装到一起
函数时将多个代码块封装
模块是将多个函数数据封装到一起
4. 迭代器
1. 什么是迭代器(iter)
迭代器是python中的一种容器类的数据类型，属于序列，没有具体的字面量,可以将其他的序列转换为迭代器
iter(序列)
2. 迭代器的特点
只能通过next()或者 迭代器.next() 方法去一个一个按顺序的获取迭代器中的元素，而且一旦元素被取出,迭代器中就不存在这个元素
iter1 = iter("abcd")
print(iter1)
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1)) 报错：StopIteration
3. 遍历迭代器：
iter2 = iter("abcde")
print("=====")
for x in iter2:
print(x)
print("+++++")
# print(next(iter2)) # 取不到元素 因为上面已经取完
iter3 = iter("abcd")
print(iter3.__next__())
print(next(iter3))
生成器和生成式
1. 什么是生成器
生成器就是迭代器，但是迭代器不一定是生成器
生成式就是生成器的一种特俗形式: (变量 for 变量 in 序列)
特点：
需要数据的时候根据算法去一次生成一个数据
# 产生一个生成器，生成器中可以生成的数据是数字0~4 (每个元素是数字)
generator1 = (x for x in range(5))
print(generator1)
print(next(generator1))
print(next(generator1))
print("===========")
for item in generator1:
print(item)
print("++++++++++++")
generator2 = (x*2 for x in range(5))
for item2 in generator2:
print(item2)
generator3 = ([y, y*2] for y in "abc")
print(next(generator3))
print("========")
generator4 = (x for x in range(5) if x%2)
for item4 in generator4:
print(item4)
2. 生成器就是函数体中有yield关键字的函数 ---> 函数中只要有yield,那么调用函数不再是执行函数体
获取返回值，而是产生一个生成器
通过next获取生成器的元素的时候，会去执行生成器对应的函数的函数体，执行到yield位置，并且将yield
后面的值产生(生成)，然后保存当前结束的位置。下一次获取生成器元素的时候会接着上次结束的位置往后执行
生成器可以当做序列来使用
print("**********************")
def function1(n):
print("你好生成器")
for x in range(n+1):
print(x)
yield x # 生成x的值，调用next函数的时候取出来
g4 = function1(10)
print(g4)
print("=:", next(g4)) # 你好生成器 0 =: 0
print("=:", next(g4), type(g4)) # 1 =: 1
文件的读和写
文件用来干嘛？
使用本地文件可以做数据的持久化(本地化) ---> 常用二进制文件 数据库文件 txt文件 json文件 plist文件
1. 文件操作 --> 读写操作(二进制不能设置编码方式，编码方式是对应文本来讲的)
读 ---> 取出文件中的数据
写 ---> 将数据写到文件中
所有文件操作基本过程: 先要打开文件 --> 操作文件 --> 关闭文件
2. 打开文件和关闭文件
- 打开文件: open(file, mode="r", encoding=None)
a. file: 文件路径(必须传参),决定需要打开的是哪个文件
绝对路径(不推荐): 完整文件路径
相对路径:
./相对路径 (相对路径是相对当前py文件对应的文件夹)
../ ---> 当前文件夹上层文件夹
.../ ---> 当前文件夹上层文件夹的上层文件夹
b. mode: 决定文件打开方式(决定打开文件后是读还是写还是改……,不同操作对应不同打开方式)
"r" --> read 以只读的形式打开，读文本文件
"rb" / "br" --> 读操作，读出来的数据是二进制形式的数据
"w" --> write 以写的方式打开文件
"wb" / "bw" --> 写操作，将二进制数据写入文件
"a" --> 写操作，追加
c. encoding: 文本文件的编码方式
utf-8: 几乎支持所有的语言文字
gbk: 只支持英文
d. open()函数的返回值，就是被打开的文件对象
- 关闭文件: 文件对象.close()
# # 在此文件绝对路径打开test.txt文件
# a = open(r"D:\Study\phase 1\Day11_文件操作\test.txt")
# # 在此文件相对路径打开test.txt, 文件操作.txt, 文件操作2.py文件
# b = open("./test.txt")
# c = open("./files/文件操作.txt")
# d = open("./files/files2/文件操作2.py")
#
# # 在文件操作2中，相对路径打开test.txt, 文件操作.txt
# e = open("../文件操作.txt")
# f = open(".../test.txt")
读文件
# 1. 打开文件
f1 = open("./test.txt", mode="r", encoding="utf-8")
# 2. 读文件中的内容(每次读是按照上次读到的位置往下面读)
"""
文件对象.read() ---> 从文件开始读到文件结束，返回读到的结果
文件对象.readline() ---> 读一行
文件对象.readlines() ---> 一行一行读完，每一行作为列表元素，返回列表
"""
content2 = f1.read()
print("=: ", content2)
# content = f1.readline()
# print(type(content), content, sep="\n")
# 关闭文件
f1.close()
写文件一般先把原来的内容读出来，然后再写文件的时候用原来的内容加上添加的内容
一般不用"a"去写文件，因为一般开发文件为json文件，使用"a"可能会导致文件被破坏
"w" ---> 将字符串写入文件中，完全覆盖文件原来的内容
"wb" / "bw" ---> 将二进制写入文件中，完全覆盖文件原来的内容
"a" ---> 在文件的最后面去写内容
# 1. 打开文件
f2 = open("./test.txt", mode="w", encoding="utf-8")
# 2. 写入文件
f2.write(content2 + "我是被写入的hello python\n")
# f2.writelines(["hahah, ", "我也被写进来了\n"])
# 3. 关闭文件
f2.close()
