生成器，三元表达式，匿名函数，内置函数

今日学习总结：

一、生成器：生成的工具，是一个自定义的迭代器。本质上是一个迭代器。

 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']
()