小白学python系列————【Day24】三元表达式及匿名函数

皮糖小王子

已于 2022-07-07 21:14:34 修改

阅读量398

点赞数

文章标签： python 开发语言大数据

于 2022-07-07 20:40:53 首次发布

本文链接：https://blog.csdn.net/DiligentGG/article/details/125661065

版权

今日内容概要

三元表达式
各种生成式
匿名函数
匿名集合内置函数使用
重要内置函数

三元表达式

（1）三元表达式使用目的：
能够让代码更加精简！！！

（2）三元表达式使用场景：
仅限于二选一的情况并不建议嵌套使用

（3）三元表达式之语法结构：
值1 if 条件 else 值2
如果if后面的条件成立则使用if前面的值
如果if后面的条件不成立则使用else后面的值

（4）三元表达式举例：
栗子一之编写一个函数，比较两个数大小，返回较大的那个。
def max(a,b):
   return a if a > b else b
res = max(1,10)
print(res)
栗子二之用户登录
username = input('username>>>:').strip()
print('部门主管') if username == 'jason' else print('普通用户')

各种生成式

（1）列表生成式
列表生成式——列表名 = [ 元素 for循环 (if语句) ]
举个栗子：

name_list = ['jason', 'kevin', 'oscar', 'jerry']
# 先执行for循环 然后将一个个的数据值交给for循环前面处理
new_list = [name + '_NB' for name in name_list]
print(new_list)     # ['jason_NB', 'kevin_NB', 'oscar_NB', 'jerry_NB']
# 支持if判断   先执行for循环 然后将一个个的数据值交给if判断 结果为True则最后交给for循环前面处理
new_list = [name + '_NB' for name in name_list if name != 'jason']
print(new_list)     # ['kevin_NB', 'oscar_NB', 'jerry_NB']

注意：列表生成式中只能出现for和if，不能出现else 不然会产生歧义(for和if都能结合else)

（2）字典生成式
字典生成式——字典名 = [ k : v for循环 (if语句) ]
举个栗子：

new_dict = {i:'jason' for i in range(5)}
print(new_dict)    # {0: 'jason', 1: 'jason', 2: 'jason', 3: 'jason', 4: 'jason'}

new_dict = {i:'jason' for i in range(5) if i == 3}
print(new_dict)     # {3: 'jason'}

（3）集合生成式
集合生成式——集合名 = [ 元素 for循环 (if语句) ]
举个栗子：
new_set = {i for i in range(10)}
print(new_set)    # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
new_set = {i for i in range(10) if i == 6}
print(new_set)     # {6}

（4）针对元组没有所谓的生成式一说它是迭代器知识(生成器)

匿名函数

（1）什么是匿名函数
匿名函数就是没有函数名的函数

（2）匿名函数语法结构
lambda 匿名函数的形参: 匿名函数的返回值

（3）具体案例
直接调用

print((lambda x: x + 1)(123))     # 124

命名调用

res = lambda x: x + 1
print(res(123))      # 124

（4）应用场景·
匿名函数通常都需要配合其他函数一起使用

匿名集合内置函数使用

（1）代码展示

dic = {
   'jason': 100,
   'aj': 123,
   'Bason': 9999999,
   'zero': 888
}
res = max(dic, key=lambda k: dic.get(k))   # 使用匿名函数
print(res)  # Bason

（2）代码分析理解
max支持传函数名过来，max不加key时底层是for循环，这时候就是拿字典中K值去比较了。加了参数key以后，max把每次for循环的结果交给lambda这个匿名函数，此处K值就会当作参数传给匿名函数，k为形参，即K值jason为形参，冒号后面的为函数返回值，返回值dict.get(k)为k所对应的jason所对应的100，循环下来，就会用新的值进行比较。这时max比较大小的值就变为k匿名函数的返回值进行比较的依据。不过最终结果还是会以for循环对象k进行比较！！！

重要内置函数

（1）max() 求最大值

l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = max(l1)    # max()取出l1列表中最大值绑定变量名res
print(res)       # 打印出最大值    2123432

（2）min() 求最小值

l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = min(l1)    # max()取出l1列表中最大值绑定变量名res
print(res)       # 打印出最小值    3

（3）map() 映射关系
举个栗子：将列表中所有的数据值自增20
使用匿名函数：

l1 = [11, 22, 33, 44, 55, 66]
res = map(lambda x: x + 20, l1)   # 匿名函数使用map内置参数
print(res)             # <map object at 0x000001954B581100>
print(list(res))       # [31, 42, 53, 64, 75, 86]

未使用匿名函数时需要定义一个函数来使用：

l1 = [11, 22, 33, 44, 55, 66]
def index(a):
   return a + 20
res = map(index, l1)
print(list(res))      # [31, 42, 53, 64, 75, 86]

请添加图片描述

（4）filter() 对指定的序列执行过滤操作
举个栗子：移除数据值里面的jason
使用匿名函数：

l1 = ['jason', 'kevin', 'oscar', 'tony']
res = filter(lambda a: a != 'jason', l1)
print(res)  # <filter object at 0x00000195F21E6C70>
print(list(res))  # ['kevin', 'oscar', 'tony']

未使用匿名函数时需要定义一个函数来使用：

l1 = ['jason', 'kevin', 'oscar', 'tony']
def index(a):
   return a != 'jason'
res = filter(index, l1)
print(list(res))      # ['kevin', 'oscar', 'tony']

（5）reduce() 函数会对参数序列中的元素进行累计
举个栗子：求列表中所有数据值的和
使用匿名函数其次需要引入模块：
l2 = [1, 2, 3]
from functools import reduce
# 将很多整体变成一个整体
res = reduce(lambda x, y: x + y, l2, 100)
print(res)

（6）zip() 将参数序列分组合并。
举个栗子：拼接数据值
数据值相同情况下依次拼接：

n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res))    # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 'c'), (4, 8, 'k')]

数据值不相同情况下有多少拼接多少：

n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res))     # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 's'), (4, 8, 'o')]

（7）其他内置函数补充（了解）

名称作用
abs() 求取绝对值
bin() oct() hex() 产生对应的进制数
bytes() 类型转换，可用于编码使用
callable() 判断当前对象是否可以加括号调用
chr()、ord() 字符与数字的对应转换
dir() 返回数据类型可以调用的内置方法(查看对象内部可调用的属性)
其他内置方法了解可移步python内置函数

名称	作用
abs()	求取绝对值
bin() oct() hex()	产生对应的进制数
bytes()	类型转换，可用于编码使用
callable()	判断当前对象是否可以加括号调用
chr()、ord()	字符与数字的对应转换
dir()	返回数据类型可以调用的内置方法(查看对象内部可调用的属性)
其他内置方法了解可移步python内置函数

作业一：多层装饰器执行流程

多层装饰器举例：
def outter1(func1):      # func1 = wrapper2函数名
  print('加载了outter1')
  def wrapper1(*args, **kwargs):
      print('执行了wrapper1')
      res1 = func1(*args, **kwargs)
      return res1
  return wrapper1

def outter2(func2):      # func2 = wrapper3函数名
  print('加载了outter2')
  def wrapper2(*args, **kwargs):
      print('执行了wrapper2')
      res2 = func2(*args, **kwargs)
      return res2
  return wrapper2

def outter3(func3):      # func3 = 真正的index函数
  print('加载了outter3')
  def wrapper3(*args, **kwargs):
      print('执行了wrapper3')
      res3 = func3(*args, **kwargs)
     return res3
  return wrapper3


@outter1     # index = outter1(wrapper2)
@outter2    # wrapper2 = outter2(wrapper3)
@outter3   # wrapper3 = outter3(真正的index函数名)
def index():
  print('from index')
index()
执行流程表述：
调用index函数名先看离它最近的语法糖@outter3，index函数名以实参的形式传给outter3的形参func3，然后执行‘加载了outter3’，然后看与它同级的返回值wrapper3。这时候不执行wrapper3而是直接进行下一块语法糖@outter2执行，wrapper3以实参的形式传给outter2的形参func2，然后执行‘加载了outter2’，然后看与它同级的返回值wrapper2。这时候不执行wrapper2而是直接进行下一块语法糖@outter1执行，wrapper2 以实参的形式传给outter1的形参func1，然后执行‘加载了outter1’，然后看与它同级的wrapper1。下一步调用index()接收wrapper1，这时候就开始调用wrapper1这个函数，然后执行‘执行了wrapper1’，然后func1=res=wrapper2，即继续调用wrapper2函数。然后执行‘执行了wrapper2’，然后func2=res=wrapper3，即继续调用wrapper3函数。func3本质上为index函数，所以调用index函数最后执行‘from index’，然后结束程序~~

作业二：参数函数执行流程

参数函数举例：
def outer(condition,type_user):
  def login_auth(func_name):  # 这里不能再填写其他形参
      def inner(*args, **kwargs):  # 这里不能再填写非被装饰对象所需的参数
          username = input('username>>>:').strip()
          password = input('password>>>:').strip()
          # 应该根据用户的需求执行不同的代码
          if type_user =='jason':print('VIP')
          if condition == '列表':
              print('使用列表作为数据来源 比对用户数据')
          elif condition == '字典':
              print('使用字典作为数据来源 比对用户数据')
          elif condition == '文件':
              print('使用文件作为数据来源 比对用户数据')
          else:
              print('去你妹的 我目前只有上面几种方式')
      return inner
  return login_auth
@outer('文件','jason')
def index():
  print('from index')
index()
执行流程表述：
先outer但不会直接调用，只是在全局空间产生了一个名称空间，然后outer加括号执行优先级最高，把outer括号内实参传给iouter形参。后面继续login_auth也不会直接调用而是在outer名称空间里产生了一个名字，然后同级返回login_auth，然后和@构成语法糖。然后接受真正的index函数传给func_name，然后调用函数login_auth()；继续往下走inner不执行，又在login_auth局部名称空间中产生一个名字，然后继续同级返回inner。然后index()接受并调用函数inner，真正的index传给了login_auth的形参func_name。