python内置函数和推导式

内置函数和推导式

1.匿名函数

传统的函数的定义包括了：函数名 + 函数体。

def send_email():
    pass

# 1. 执行
send_email()
# 2. 当做列表元素
data_list = [send_email, send_email, send_email ]
# 3. 当做参数传递
other_function(send_email)

匿名函数，则是基于lambda表达式实现定义一个可以没有名字的函数，例如：

data_list = [ lambda x:x+100,  lambda x:x+110, lambda x:x+120 ]

print( data_list[0] )

f1 = lambda x:x+100

res = f1(100)
print(res)

基于Lambda定义的函数格式为：`lambda 参数:函数体

• 参数，支持任意参数。

  lambda x: 函数体
  lambda x1,x2: 函数体
  lambda *args, **kwargs: 函数体
  

• 函数体，只能支持单行的代码。

  def xxx(x):
      return x + 100
      
  lambda x: x + 100
  

• 返回值，默认将函数体单行代码执行的结果返回给函数的执行这。

  func = lambda x: x + 100
  
  v1 = func(10)
  print(v1) # 110
  

  def func(a1,a2):
      return a1 + a2 + 100
  
  foo = lambda a1,a2: a1 + a2 + 100
  

  匿名函数适用于简单的业务处理，可以快速并简单的创建函数。

  在编写匿名函数时，由于受限 函数体只能写一行，所以匿名函数只能处理非常简单的功能。

  扩展：三元运算

  简单的函数，可以基于lambda表达式实现。

  简单的条件语句，可以基于三元运算实现，例如：

  num = input("请写入内容")
  
  if "达莱" in num:
      data = "很好"
  else:
      data = "正经人"
      
  print(data)
  

  num = input("请写入内容")
  data = "臭不要脸" if "苍老师" in num else "正经人"
  print(data)
  
  # 结果 =  条件成立时    if   条件   else   不成立
  

  lambda表达式和三元运算没有任何关系，属于两个独立的知识点。

• 掌握三元运算之后，以后再编写匿名函数时，就可以处理再稍微复杂点的情况了，例如：

  func = lambda x: "大了" if x > 66 else "小了"
  
  v1 = func(1)
  print(v1) # "小了"
  
  v2 = func(100)
  print(v2) # "大了"
  

2.生成器

生成器是由函数+yield关键字创造出来的写法，在特定情况下，用他可以帮助我们节省内存。

• 生成器函数，但函数中有yield存在时，这个函数就是生产生成器函数。

def func():
    print(111)
    yield 1

• 生成器对象，执行生成器函数时，会返回一个生成器对象。

  def func():
      print(111)
      yield 1
  
      print(222)
      yield 2
  
      print(333)
      yield 3
  
      print(444)
      
  data = func()
  
  # 执行生成器函数func，返回的生成器对象。
  # 注意：执行生成器函数时，函数内部代码不会执行。
  

  def func():
      print(111)
      yield 1
  
      print(222)
      yield 2
  
      print(333)
      yield 3
  
      print(444)
      
  data = func()
  
  v1 = next(data)
  print(v1)
  
  v2 = next(data)
  print(v2)
  
  v3 = next(data)
  print(v3)
  
  v4 = next(data)
  print(v4)  # 结束或中途遇到return，程序爆：StopIteration 错误
  

  data = func()
  
  for item in data:
      print(item)
  

  生成器的特点是，记录在函数中的执行位置，下次执行next时，会从上一次的位置基础上再继续向下执行。

应用场景

假设生成 300w个随机的4位数，并打印出来。

• 在内存中一次性创建300w个
• 动态创建，用一个创建一个。

import random


def gen_random_num(max_count):
    counter = 0
    while counter < max_count:
        yield random.randint(1000, 9999)
        counter += 1


data_list = gen_random_num(3000000)
# 再使用时，去 data_list 中获取即可。

扩展

• yield 接收值

  def func():
      print(111)
      v1 = yield 1
      print(v1)
  
      print(222)
      v2 = yield 2
      print(v2)
  
      print(333)
      v3 = yield 3
      print(v3)
  
      print(444)
  
  
  data = func()
  
  n1 = data.send(None)
  print(n1)
  
  n2 = data.send(666)
  print(n2)
  
  n3 = data.send(777)
  print(n3)
  
  n4 = data.send(888)
  print(n4)
  

3.内置函数

• 如下图

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yR6P0iBL-1627740560411)(assets/image-20210731210601593-16277367633432.png)]

Python内部为我们提供了很多方便的内置函数，在此整理出来36个

• 1组（5个）

  • ads，绝对值

    v = abs(-10)
    

  • pow，指数

    v1 = pow(2,5) # 2的5次方  2**5
    print(v1)
    

  • sum，求和

    v1 = sum([-11, 22, 33, 44, 55]) # 可以被迭代-for循环
    print(v1)
    

  • divmod，求商和余数

    v1, v2 = divmod(9, 2)
    print(v1, v2)
    

  • round，小数点后n位（四舍五入）

    v1 = round(4.11786, 2)
    print(v1) # 4.12
    

• 2组（4个）

  • min ，最小

    v1 = min(11, 2, 3, 4, 5, 56)
    print(v1) # 2
    

    v2 = min([11, 22, 33, 44, 55]) # 迭代的类型（for循环）
    print(v2)
    

    v3 = min([-11, 2, 33, 44, 55], key=lambda x: abs(x))
    print(v3) # 2
    

  • max，最大

    v1 = max(11, 2, 3, 4, 5, 56)
    print(v1)
    
    v2 = max([11, 22, 33, 44, 55])
    print(v2)
    

    v3 = max([-11, 22, 33, 44, 55], key=lambda x: x * 10)
    print(v3) # 55
    

  • all，是否为全部

    v1 = all(   [11,22,44,""]   ) # False
    

  • any，是否存在Ture

    v2 = any([11,22,44,""]) # True
    

• 3组 （3个）

  • bin，十进制转二进制
  • oct，十进制转八进制
  • hex，十进制转十六进制

• 4组 （2个）

  • ord，获取字符对应的unicode码点（十进制）

    v1 = ord("达")
    print(v1, hex(v1))  #36798  0x8fbe
    

  • chr，根据码点（十进制）获取对应字符

    v1 = chr(36798)
    print(v1)  #达
    

• 5组（9个）

  • int
  • foat
  • str，unicode编码
  • byte，utf-8，gbk编码

  v1 = "达莱"  # str类型
  
  v2 = v1.encode('utf-8')  # bytes类型
  
  v3 = bytes(v1, encoding="utf-8")  # bytes类型
  

  • bool
  • list
  • dict
  • tuple
  • set

• 6组（13个）

  • len

  • print

  • input

  • open

  • type ，获取数据类型

    v1 = "123"
    
    if type(v1) == str:
        pass
    else:
        pass
    

  • range

  • enumerate 多用于在for循环中得到计数

    v1 = ["达莱", "查苏娜", 'root']
    
    for num, value in enumerate(v1, 1):
        print(num, value)
    

  • id

  • hash

    v1 = hash("达莱")
    

  • help,帮助信息

    • pycharm，一般不用
    • 终端使用较多

  • zip

    v1 = [11, 22, 33, 44, 55, 66]
    v2 = [55, 66, 77, 88]
    v3 = [10, 20, 30, 40, 50]
    
    result = zip(v1, v2, v3)
    for item in result:
        print(item)
    

  • callable，是否可执行，后面是否可以加括号。

    v1 = "达莱"
    v2 = lambda x: x
    
    
    def v3():
        pass
    
    
    print(callable(v1))  # False
    print(callable(v2))
    print(callable(v3))
    

  • sorted ，排序

    v1 = sorted([11,88,33,44,55])
    print(v1)
    

    info = {
             
        "dalai": {
             
            'id': 10,
            'age': 119
        },
        "root": {
             
            'id': 20,
            'age': 29
        },
        "seven": {
             
            'id': 9,
            'age': 9
        },
        "admin": {
             
            'id': 11,
            'age': 139
        },
    }
    
    result = sorted(info.items(), key=lambda x: x[1]['id'])
    print(result)
    
    #[('seven', {'id': 9, 'age': 9}), ('dalai', {'id': 10, 'age': 119}), ('admin', {'id': 11, 'age': 139}), ('root', {'id': 20, 'age': 29})]
    

    data_list = [
        '1-5 编译器和解释器.mp4',
        '1-17 今日作业.mp4',
        '1-9 Python解释器种类.mp4',
        '1-16 今日总结.mp4',
        '1-2 课堂笔记的创建.mp4',
        '1-15 Pycharm使用和破解（win系统）.mp4',
        '1-12 python解释器的安装（mac系统）.mp4',
        '1-13 python解释器的安装（win系统）.mp4',
        '1-8 Python介绍.mp4', '1-7 编程语言的分类.mp4',
        '1-3 常见计算机基本概念.mp4',
        '1-14 Pycharm使用和破解（mac系统）.mp4',
        '1-10 CPython解释器版本.mp4',
        '1-1 今日概要.mp4',
        '1-6 学习编程本质上的三件事.mp4',
        '1-18 作业答案和讲解.mp4',
        '1-4 编程语言.mp4',
        '1-11 环境搭建说明.mp4'
    ]
    result = sorted(data_list, key=lambda x: int(x.split(' ')[0].split("-")[-1]))
    print(result)
    # 按照顺序排序
    

    4.推导式

    推导式是Python中提供了一个非常方便的功能，可以让我们通过一行代码实现创建list、dict、tuple、set 的同时初始化一些值。

    请创建一个列表，并在列表中初始化：0、1、2、3、4、5、6、7、8、9…299 整数元素。

    data = []
    for i in range(300):
        data.append(i)
    

  • 列表

    num_list = [ i for i in range(10)]
    
    num_list = [ [i,i] for i in range(10)]
    
    num_list = [ [i,i] for i in range(10) if i > 6 ]
    

  • 集合

    num_set = {
              i for i in range(10)}
    
    num_set = {
              (i,i,i) for i in range(10)}
    
    num_set = {
              (i,i,i) for i in range(10) if i>3}
    

  • 字典

    num_dict = {
              i:i for i in range(10)}
    
    num_dict = {
              i:(i,11) for i in range(10)}
    
    num_dict = {
              i:(i,11) for i in range(10) if i>7}
    

  • 元组，不同于其他类型

    # 不会立即执行内部循环去生成数据，而是得到一个生成器。
    data = (i for i in range(10))
    print(data)
    for item in data:
        print(item)
    

    高级推导式

    1.1 推导式支持嵌套

    data = [ i for i in range(10)]
    

    data = [ (i,j) for j in range(5) for i in range(10)]
    
    data = []
    for i in range(10):
        for j in range(5):
            data.append( (i,j) )
    
    data = [ [i, j] for j in range(5) for i in range(10)]
    

    # 一副扑克牌
    
    poker_list = [ (color,num) for num in range(1,14) for color in ["红桃", "黑桃", "方片", "梅花"]]
    
    poker_list = [ [color, num] for num in range(1, 14) for color in ["红桃", "黑桃", "方片", "梅花"]]
    
    print(poker_list)	
    

    • 复杂推导式

      def num():
          return [lambda x: i * x for i in range(4)]
      
      
      # 1. num()并获取返回值  [函数,函数,函数,函数] i=3
      # 2. for循环返回值
      # 3. 返回值的每个元素(2)
      result = [m(2) for m in num()]  # [6,6,6,6]
      print(result)
      
      

      def num():
          return (lambda x: i * x for i in range(4))
      
      
      # 1. num()并获取返回值  生成器对象
      # 2. for循环返回值
      # 3. 返回值的每个元素(2)
      result = [m(2) for m in num()]  # [0,2,4,6 ]
      print(result)