今日学习总结：
一、生成器：生成的工具，是一个自定义的迭代器。本质上是一个迭代器。
1.自定义生成器
01.但凡在函数内部定义了的yeild
02.调用函数时，函数体代码不会执行
03.会返回一个结果，该结果就是一个生成器对象
2. yield
00.可以返回多次的值
01.只能在函数内部定义
02.可以保存函数的暂停状态
03.每一次yield都会往生成器对象中添加一个值
3.创建一个生成器对象有两种方式
01.一种是调用带yield关键字的函数
02.另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()
def func(): print('form word') yield 'tank' res=func() #此时res是迭代器对象 print(res._next_()) 其实，res._next_() 与 next(res) 相等 def func(): print('form word') yield 'tank' res=func() #此时res是迭代器对象 print(next(res))
3. return
01. return只能返回一次的值
02. return可以返回任意类型的值
4. range
自定义range功能，创建一个自定义的生成器 def my_range(start,end,move=1): while start<end: yield start start+=move g_range=my_range(1,5) print(g_range)
二、面向过程编程：是一门编程思想，核心是‘过程’二字。过程是指一种解决问题的步骤，既是先干什么再干什么。基于该编程思想写程序，就像设计一条流水线，一种机械式的思维。
优点：将复杂的问题流程化，进而简单化
缺点：可扩展性差，既是若改变当前程序的某一部分,则需要改动其他程序。（牵一发而动全身）
例子：登录认证，保存在一个文件
def get_user_pwd(): # 1.先让用户输入用户名和密码，校验合法性 while True: username = input('请输入用户名:').strip() if username.isalpha(): # 校验用户名是否为 英文字母 str.isalpha 校验英文字母、中文 break else: print('用户名不合法') while True: password = input('请输入密码:').strip() re_password = input('请确认密码:').strip() if password == re_password: # 校验两次密码是否一致 break else: print('两次密码不一致。') return username, password def cut_user_pwd(user, pwd): # 2.拼接用户字符串 user_pwd_str = f'{user}:{pwd} ' return user_pwd_str def save_data(user_pwd_str) # 3.保存用户数据，写入文件中 with open('user.txt', 'a', encoding='utf-8') as f: f.write(user_pwd_str) # 注册功能Demo def register(): user, pwd = get_user_pwd() # 1.设计先让用户输入用户名和密码，校验合法性，得到合法的用户名与密码 user_pwd_str = cut_user_pwd(user, pwd) # 2.设计字符串的拼接, 得到拼接好的字符串 save_data(user_pwd_str) # 3.开始写入文件 register()
例子：登录认证，以不用的用户名保存文件
def gut_user_pwd(): while True: username=input('请输入你要注册的用户名：').strip() if username.isalpha(): break else: print('输入的用户名不合法') while True: password=input('请您输入注册的密码：').strip() re_password=input('请您再次输入注册的密码：').strip() if password==re_password: break else: print('您输入的密码不一致') while True: user_role=input('请输入您的角色').strip() list=['普通用户','超级用户','管理员用户'] if user_role in list: print('恭喜您注册成功') break else: print('您输入的角色不正确') return username,password,user_role def cut_user_pwd(user,pwd,role): user_pwd_str=f'{user}:{pwd}:{role} ' return user_pwd_str,user # 在这里把 user 用户名返回了 def save_data(user_pwd_str,name): with open(f'{name}.txt','w', encoding='utf-8') as f: f.write(user_pwd_str) def register(): user,pwd,role=gut_user_pwd() #在这里把gut_user_pwd()里得到的返回值解压赋值了 user_pwd_str,name=cut_user_pwd(user,pwd,role) ##在这里把cut_user_pwd(user,pwd,role)里得到的返回值解压赋值了 save_data(user_pwd_str,name) register()
三、三元表达式
可以将if...else... 分支，变成一行。
语法结构：
表达式1 if 条件语句 else 表达式2 # 如条件成立执行 条件语句的左边的表达式
案例1：需求: 让用户输入用户名，输入的用户如果不是tank，为其后缀添加_DBD
username = input('请输入用户名:').strip() new_username = username if username == 'tank' else username + '_DBD' print(new_username)
四、列表生成式
01.生成列表的方法：
方法一：
new_list=[]
for i in range(1,101)
new_list.append(i)
print(new_list)
方法二：列表生成式: [line for line in 可迭代对象]
list=[i for i in range(1,101)]
ps: list=[f'1{i}' for i in range(1,101)]
ps:list=[1 for i in range(1,101)]
ps:list=['1' for i in range(1,101)]
ps:list=[i+'-dsb' for i in range(1,101)]
ps:list=[i+'-dsb' for i in range(1,101) if i!=4] 要看
五、生成器表达式（生成器生成式）：(line for line in 可迭代对象)
g=(line for line in range(1,101))
print(g)
结果： 表示是生成器对象
<generator object <genexpr> at 0x0000000009E4A9E8>
优点：节省内存（一次只产生一个值在内存中）
区别：
列表生成式：用在数据量少时。可以依赖于索引取值，取值方便。在数据量过大时浪费资
生成器生成式：用在数据量大时。不依赖于索引取值，取值麻烦。 在数据量过大时节省资源
六、匿名函数：无名字的函数。匿名函数是临时的，一次性的。匿名函数主要是和其他函数或内置函数搭配使用。单独使用时需要把匿名函数赋值个变量，就变成有名字了，没有什么意义了。不要单独用。
定义：
lambda 形参变量 ：函数体
七、内置函数：python
01.求最大值的函数： max（）
list =[1,2,3,4]
print(max(list))
结果：4
02. 求最小值的函数： min( )
03. 求排序的函数sorted( )
04.求映射的函数map（）
05.reduce()
06.filter
例子：请使用两种方式获取user_dic字典中薪资最高的员工。
user_dic = {'张全蛋': 20000,'赵铁柱': 3000,'李小花': 8000,'伍六七': 1500}
方法一： l1 =max(user_dic,key=lambda x:user_dic[x]) print(l1) 方法二： l2 = sorted(user_dic, key=lambda x:user_dic[x]) #升序 #x 指的是 字典里的 key print(l2[-1])
方法三：
l3=sorted(user_dic.items(), key = lambda x: x[1]) #user_dic.items() 表示元组形式的键值对
print(l3)
#按降序排
l3 = sorted(user_dic, key=lambda x:user_dic[x]，], reverse=True) #降序
print(l3)
考试面试题
1.请按alist中元素的age由大到小排序
alist = [{'name': 'a', 'age': 20}, {'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}]
l1=sorted(alist, key=lambda x: x['age'], reverse=True) # x 是指列表里的 每个元素{'name': 'a', 'age': 20}
print(l1)
2.现有字典 d={‘a’:24，’g’:52，’l’:12，’k’:33}请使用函数的内置方法按字典中的 value 值进行排序？
例子:map: 映射.（得到的是一个map对象）
格式：map(函数地址, 可迭代对象) ---> map对象
作用：map会将可迭代对象中的每一个值进行修改，然后映射一个map对象中，
可以再将map对象转换成列表/元组。
注意: 只能转一次。
name_list = ['egon', 'jason', 'sean', '大饼', 'tank'] map_obj = map(lambda name: name + '喜欢吃生蚝' if name == 'tank' else name + 'DJB', name_list) print(map_obj) # map_obj ---> list/tuple print(list(map_obj)) # map_obj ---> 生成器(迭代器) ---> 用完后，不能再取了 print(tuple(map_obj))
结果：
<map object at 0x0000000009E97588>
['egonDJB', 'jasonDJB', 'seanDJB', '大饼DJB', 'tank喜欢吃生蚝']
()
例子：reduce: 合并 .使用时需要导入functools模块，返回的是一个值
格式：reduce(函数地址, 可迭代对象, 默认为0)
格式：reduce(函数地址, 可迭代对象, 初始值)
作用：每次从可迭代对象中获取两个值进行合并。初始值: 执行reduce函数时，都是从初始值开始合并
eg:求1到100的和
#方法一： sum=0 for i in range(1,101): sum+=i print(sum) #方法二： from functools import reduce #从functools中导入 reduce res =reduce(lambda x,y:x+y, range(1,101),0) #x ，y 是变量。每次x+y的值都会再次赋值给x , 在从range中取出新的值再次赋值给y
rint(res)
例子：filter: 过滤 （得到的结果是filter对象）
格式：filter(函数地址, 可迭代对象) --> filter 对象
作用：将可迭代对象遍历，然后通过判断，再将filter对象转换成列表/元组。
注意: 只能转一次。
name_list = ['egon_dsb', 'jason_dsb','sean_dsb', '大饼_dsb', 'tank'] filter_obj = filter(lambda name: name.endswith('_dsb'), name_list) print(filter_obj) print(list(filter_obj)) print(tuple(filter_obj))
结果：
<filter object at 0x0000000002876A20>
['egon_dsb', 'jason_dsb', 'sean_dsb', '大饼_dsb']
()