学习内容概要

• 三元表达式

• 各种生成式

• 匿名函数

• 重要内置函数

• 常见内置函数

  内容详细

  三元表达式

  """减少代码量的便捷写入方式"""
  习题演练：
  1.获取用户输入的用户名 如果是make就打印很好 否则打印不好
  #之前的学习 写入方式为
  while 1:
      username = input('username>>>:').strip()
      if username =='make':
          print('很好')
      else:
          print('不好')
  """
  上述是在之前学习中 使用的方式 给人一种需求简单 但是代码却很多的感觉   接下来我们可以用三元表达式的方式 写入一下
  """
  username = input('username>>>:').strip()
  res = print('很好') if username =='make'else print ('不好')
  # 同样的需求 上面需要多行代码 下面则两行代码就可以实现功能
  
  2.编写一个函数 比较两个参数的大小 返回小的那个一个值
  def func(a,b):
      if a < b:
        return a
      else:
        return b
  res = func(1,2)
  print(res)  # 1
  # 用三元表达式也可以写成
  def func(a,b):
  	return a if a < b else b
  res = func(1,2)
  prinr(res)
  
  """在三元表达式中 只能判断 if ...else... 这一种情况  仅限于二选一的情况 并且不建议用于嵌套使用
  如果判断情况较多 也不建议使用三元表达式
  """
  
  """
  三元表达式语法结构
  	值1 if 条件 else 值2
  如果if后面的条件成立 则使用if前面的值
  如果if后面的条件不成立 则使用else后面的值
  """
  

  各种生成式

  """把可变类型 用简单便捷的方式 表现出我们想要达到的效果 """
  1.1.列表生成式
      name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
      # 给上述列表中所有的数据值加上 666 的后缀
  方式一：
  
  xin_list = []
  for name in name_list:
      xin_name = name +'666'
      xin_list.append(xin_name)
  print(new_list)  # ['jason666', 'kevin666', 'oscar666', 'jerry666', 'tony666']
  
  
  方式二：
  """  列表生成式  """
  
  xin_list = [name + '666' for name in name_list]
  print(xin_list)  # ['jason666', 'kevin666', 'oscar666', 'jerry666', 'tony666']
  
  
  #上述方法中用到 for 循环  运算顺序是  （先执行for循环体 在执行fro循环前面的条件代码）
  
  xin_list = [name + '666' for name in name_list if name != 'tony']
  print(xin_list
        
  # 同样上述生成式还支持使用 if 判断 一样的顺序 先执行for循环 然后把例表里的数据值 交给if判断 最后执行for循环前面的条件代码
  """
  以上述模板方式 推写出 字典 集合 生成式
  """
  2.字典生成式
  new_dict = {i: 'tony' for i in range(10) if i == 9}
  print(new_dict)  # {9: 'tony'}
        
  # 先循环 i 打印 0~10（顾头不顾尾） 然后 if 判断 i == 9 时 执行 for 循环前面的代码条件
  
  3.集合生成式
  new_set = {i for i in range(10) if i == 9}
  print(new_set)
   # 先循环 i 打印 0~10（顾头不顾尾） 然后 if 判断 i == 9 时 执行 for 循环前面的代码条件
  

  匿名函数

  匿名函数就是没有函数名的函数
  
  语法结构
  	lambda 形参: 返回值
  具体表现
  	(lambda x: x + 1)(123)  直接调用
      res = lambda x: x + 1  命名调用
  	 print(res(123))
  应用场景
  	匿名函数通常都需要配合其他函数一起使用 用于减少代码
  

  匿名集合内置函数使用

  1.max()  #求最大值
  # 计算列表里数据值相加之和
  l1 = [23,312,123,434,43,5546,74,5456,345,24,54,776,767,768,435,435,23412,334,5345,456,34,57,868,79,6969,679]
  res = max(l1)
  print(res)  # 23412
  """用法非常简单 便捷"""
  # 字典是否能使用 示例：
  #     'make': 1230,
  #     'tony': 4632,
  #     'jason': 8832,
  #     'lili': 2314
  # }
  # res = max(dict)
  # print(res)  # tony 打印出是tony  但是实际最大值是jason 因为解释器是按照此顺序大小 用首字母 来比对的
  A-Z   65-90
  a-z   97-122
  # 所以针对自字典 不能直接按照列表方式比对
  # def func(k):
  #     return dict.get(k)
  # res = max(dict, key=lambda k: dict.get(k))
  # print(res)  # jason
  #可以用定义一个函数 然后返回字典的k值 用res接收 max 相当于for循环一样 把字典里的k值一个一个调出来 用后面的lambda 去做v的比对 然后比对出最大的 
  
  # def func(k):
  #     return dict.get(k)
  # res = max(dict,key= func)
  # print(res)
  # 用函数直接比对也是可以的  
  

  重要内置函数

  min()  最小值
  # 具体表现
  l1 = [11, 22, 33, 44, 55, 66]
  res = min(l1)
  print(res)  # 11
  """
  顾名思义就是最小的数据值
  """
  
  
  map()  映射
  # l1 = [11, 22, 33, 44, 55, 66]
  # 需求:将列表中所有的数据值自增20
  
  
  # 方式1:for循环
  # new_list = []
  # for i in l1:
  #     a = i+20
  #     new_list.append(a)
  # print(new_list)  # [31, 42, 53, 64, 75, 86]
  
  # 方式2:列表生成式
  new_list =[a + 20 for a in l1]
  print(new_list)  # [31, 42, 53, 64, 75, 86]
  # 方式3:map函数
  #  lambda后面的x是形参 x+20 是返回值
  # res = map(lambda x: x + 20, l1)
  
  # print(res)  # <map object at 0x018DB2F8>
  # print(list(res))  # [31, 42, 53, 64, 75, 86]  用list做整型的转换
  
  
  filter()
  具体表现：
  l1 =  ['jason', 'kevin', 'oscar', 'tony']
  需求：移除数据值里面的tony
  # 方式1:for循环
  # print(l1)
  # for name in l1:
  #     if name == 'tony':
  #         l1.remove('tony')
  # print(l1)  # ['jason', 'kevin', 'oscar']
  
  # 方式2:列表生成式
  xin_l1 = [name for name in l1 if name !='tony']
  print(xin_l1)  # ['jason', 'kevin', 'oscar']
  # 方式3:filter()
  lambda后面的a是形参  a != 'tony'是返回值
  res = filter(lambda a: a != 'tony', l1)
  print(res)  # <filter object at 0x0166F520>
  print(list(res))  # ['jason', 'kevin', 'oscar']
  
  
  reduce()
  具体表现：
  # 方式1:for循环
  l2 = [5, 10, 15, 20]
  需求:求列表中所有数据值的和
  a= 0
  for i in l2:
      a += i
  print(a)  # 50
  
  # 方式2:sum()
  res = sum(l2)
  print(res)  # 50
  
  # 方式3:reduce()
  """比较特殊 在调用时 需要加下面这句话"""
  # from functools import reduce
  具体表现：
  res = reduce(lambda x, y: x + y, l2)  # 50
  print(res)
  """将多个单体 变成一个整体 化多为整"""
  # 还可以在后面继续添加数据值（整型）
  res = reduce(lambda x, y: x + y, l2,50)
  print(res)  # 100
  
  
  
  zip()
  具体表现：
  h1 = [1,2,3]
  h2 = ['make1','make2','make3']
  res = zip(h1,h2)
  print(res)
  print(list(res))  # [(1, 'make1'), (2, 'make2'), (3, 'make3')]
  """
  把两个列表里的数据值 整合到一个列表中 并且用元组的方式一一对应排序 
  """
  表现二：
  h1 = [1,2,3,4,5,6]
  h2 = ['make1','make2','make3']
  h3 = ['lala1','lala2','laal3','lala4','lala5']
  res = zip(h1,h2,h3)
  print(res)
  print(list(res))  # [(1, 'make1', 'lala1'), (2, 'make2', 'lala2'), (3, 'make3', 'laal3')]
  """
  多个列表同时整合时 列表里的数据值 参差不同时  按照最少列表里的数据值去比对
  """
  

  两种装饰器的执行流程

  1.多层装饰器
  def outter1(func1):# func1 = wrapper2函数名
      print('加载了outter1')  # 1.第三个打印
      def wrapper1(*args, **kwargs):
          print('执行了wrapper1') # 2.第四个打印
          res1 = func1(*args, **kwargs)
          return res1
      return wrapper1
  
  def outter2(func2): # func2 = wrapper3函数名
      print('加载了outter2') # 3.第二个打印
      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
  
  # index = weapper1 所以可以写成 index = outter1(wrapper2)
  @outter1# index = outter1(wrapper2)
  @outter2 #wrapper2= outter2(wrapper3)
  @outter3 # wrapper3 = outter3(index)
  def index():
      print('from index') # 第七个打印
  index()  # 加载了outter3
  加载了outter2
  加载了outter1
  执行了wrapper1
  执行了wrapper2
  执行了wrapper3
  from index 
  
  2.有参装饰器
  
  def outer(condition,type_user):  #这里可以添加需要添加的形参 本来也可以用*args **kwargs 但是下面局部名称空间中 已经有了这个名字 解释器接收不了  可以改用*h **k 代替使用
      def login_auth(func_name):  # 这里不能再填写其他形参，因为这里填写的是被装饰对象函数名
          def inner(*args, **kwargs):  # 这里应该填写被装饰对象需要传入的参数(其他的不能填写)
              username = input('username>>>:').strip()
              password = input('password>>>:').strip()
              
              if type_user =='make':print('高级用户')
              if condition == '列表':
                  print('使用列表作为数据来源 比对用户数据')
              elif condition == '字典':
                  print('使用字典作为数据来源 比对用户数据')
              elif condition == '文件':
                  print('使用文件作为数据来源 比对用户数据')
              else:
                  print('目前只有以上方式 其他不具备')
          return inner
      return login_auth
  @outer('文件','jason')  # 函数名加() 执行优先级最高 outer() 上来就先执行了 返回了login_auth这个函数名 然后@符号加上login_auth 就回到了 语法糖 index = login_auth(index)然后正常的走流程就可以调用了
  def index():
      print('from index')
  index()