1.abs
参数：x 数字表达式
描述：求参数的绝对值
例子：

    print(abs(-1))               # 1
    print(abs(-9999.99))         # 9999.99
    print(abs(True-False))       # 1
    print(abs(3.0+4.0j))         # 5.0

对虚数求绝对值相当于是求虚数的模，虚数没有绝对值的概念
bool类型True代表1，False代表0

2.all
参数：iterable 可迭代对象
描述：判断可迭代对象中的元素调用bool()函数后的值是否都为True，如果包含False则返回False，否则返回True
例子：

    print(all([1,2,4,6,8,0]))  # False
    print(all(''))  # True
    print(all([]))  # True
    print(all(()))  # True
    print(all({}))  # True
    print(bool(''))  # False
    print(bool([]))  # False
    print(bool())  # False
    print(bool({}))  # False
    print(bool(0))  # False
    print(bool(False))  # False
    print(bool(None))  # False

bool()函数将int、float、str、list、tuple、dict等转为bool类型，如果待转换元素为0、空、None、False则转换为False否则转换为True

3.any
参数：iterable 可迭代对象
描述：判断可迭代对象中的元素调用bool()函数后的值是否含有True，如果含有True则返回True，否则返回False
例子：

    print(any([0,0]))  # False
    print(any([0,1]))  # True

4.ascii
参数：obj
描述：返回对象的ascii表示，程序执行的过程中会调用repr函数获取该对象的字符串表示，并将该字符串中不是ascii字符转换为使用\x、\u或\U编码的字符
例子：

    print(ascii('x'))
    jelly = Dog('果冻','7个月了','白色',10)
    print(repr(jelly))  # 我是比熊aaa 我非常happy
    print(ascii(jelly))  # \u6211\u662f\u6bd4\u718aaaa \u6211\u975e\u5e38happy
    print(ascii('我是比熊aaa 我非常happy'))  # '\u6211\u662f\u6bd4\u718aaaa \u6211\u975e\u5e38happy'

5.bin
参数：number整数
描述：将十进制的整数转为二进制表示
例子：

    print(bin(27))  # 0b11011
    print(bin(-11))  # 0b11011

6.callable
参数：obj 对象
描述：判断对象是否能像函数一样调用，如果对象实现了call魔法方法，则是可以被调用的，否则返回False
例子：

# 类定义部分：
class Dog():
    # 对应callable内置函数
    def __call__(self, *args, **kwargs):
        return args
# 调用部分：
'''
在指定__call__之前
print(callable(jelly))  # False
'''
    print(callable(jelly))  # True
    print(jelly(1,2))  # (1, 2)

7.chr
参数：i 整型
描述：根据unicode字符列表通过十进制整数查找Unicode字符
例子：

print(chr(101))  # e

8.compile
参数：

• source: 源代码可以表示一个Python模块、语句或表达式。只能为str或bytes或AST对象【Abstract Syntax Trees的首字母缩写，是源码到字节码的一种中间产物为抽象语法树，可以直接通过ast的方法去编译可执行代码】
• filename: 该参数的作用只是在执行代码报错或是打印返回值时提供该参数对应的信息。一般按照约定来说，如果source是从文件中读取的字符串则filename存文件名；如果source为python语句，则存可以标识代码的字符串，如果source是ast对象，可以存标识该对象的字符串
• mode: 指定编译代码的种类，可以指定为:
  1. exec:如果是一整个模块或者多行python语句，需要指定为exec
  2. eval:如果是单行表达式可以指定为eval
  3. single:如果是单行交互式语句例如input需要指定为single
• flags: 参数，可以是任何映射对象
  dont_inherit参数如果为真，则停止编译继承 在代码调用中生效的任何future语句的效果 编译;如果这些语句不存在或不正确，则会影响编译， 除了明确指定的任何特性之外。

flags和dont_inherit还不是很明白是做什么的，先放着，搞懂了再补上

描述：将源代码编译为可由exec()或eval()执行的代码对象。
返回值类型为CodeType

例子：

    with open('运算符.py') as f:
        # source_bytes = bytes(f.read().encode())  # bytes类型，这里也可以直接f.read()将获取到的字符串传入
        file = compile(source_bytes,'运算符.py','exec')
        exec(file)
    code = compile('x+y','str','eval')
    print(eval(code,{'x':1},{'y':2}))  # 3

9.delattr
参数：
object: 注意如果要删除对象属性，这里填实例对象名。如果要删除类属性，这里填类名
name: 对象或类中的某个属性
描述：从给定对象中删除指定属性 相当于del object.name
⚠️几种情况：
类代码：

class Dog():
    length = 50
    # 胖了多少斤
    set_height = -1
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
# 实例化对象部分：
    jelly = Dog('果冻', '7个月了', '白色', 70)

1. 类中定义了属性，对象初始化时没有同名属性被赋值
   例子：

'''
1. 删除类属性，删除后无论是实例名调用属性还是类名调用属性都报错
'''
    print(jelly.set_height)  # -1
    delattr(Dog,'set_height')
    print(jelly.set_height)   # AttributeError: 'Dog' object has no attribute 'set_height'
    print(Dog.set_height)  # AttributeError: type object 'Dog' has no attribute 'set_height'
'''
2. 删除实例属性，删除时报错
'''
    print(jelly.set_height)  # -1
    delattr(jelly, 'set_height')  # AttributeError: set_height

2. 类中定义了属性，对象初始化时也被赋值新的值
   例子：

'''1. 删除类属性，类名调用属性报错，对象调用属性输出为对象初始化时赋的值'''
    print(jelly.length)  # 70
    delattr(Dog,'length')
    print(jelly.length)  # 70
    print(Dog.length)  # AttributeError: type object 'Dog' has no attribute 'length'
'''2. 删除实例属性，都不报错，删除后输出的都是类定义时的默认属性'''
    print(jelly.length)  # 70
    delattr(jelly,'length')
    print(Dog.length)  # 50
    print(jelly.length)  # 50

3. 对象初始化时赋值了一个对象属性,类中没有定义的属性不能使用类名去调用。所以这种情况只能用对象名去删除，删除后再调用会报错
   例子：

    print(jelly.name)  # 果冻
    delattr(jelly,'name')
    print(jelly.name)  # AttributeError: 'Dog' object has no attribute 'name'

10.divmod
参数：x、y
描述：函数返回的结果为(x//y,x%y)的元组
例子：

    print(divmod(4.1,0.5))  # (8.0, 0.09999999999999964)
    print(4.1 // 0.5)  # 8.0
    print(4.1 % 0.5)  # 0.09999999999999964

11.eval
参数：
__source:表示一个python表达式的字符串或compile函数返回的代码对象
__globals:全局变量，若指定则必须是字典
__locals:局部变量，可以是任何映射， locals默认为globals的值。
如果既指定了globals又指定了locals，则以局部变量为主，如果局部变量不存在则向上着了全局变量。如果表达式为print语句则是没有返回值的
描述：
例子：

    eval('print(x) if x>5 else print(y)',{'x':10,'y':20},{'x':15,'y':20})  # 15
    print(eval('print(x) if x>5 else print(y)',{'x':10,'y':20},{'x':15,'y':20}))  # None
    print(eval('input("请输入一个整数")'))  # 2

12.exec
参数：
__source:表示一个或多个python语句的字符串或compile函数返回的代码对象
__globals:全局变量，若指定则必须是字典
__locals:局部变量，可以是任何映射， locals默认为globals的值。
如果既指定了globals又指定了locals，则以局部变量为主，如果局部变量不存在则向上着了全局变量
描述：
例子：

exec('print(x) if x>5 else print(y)',{'x':10,'y':20},{'x':15,'y':20})  # 15
    game = '''
print('我是一段复杂的代码哦～')
age = int(input('欢迎来到网吧，请出示您的身份证'))
if age >= 18:
    print('您的年龄是%d岁，按规定您可以进入，欢迎光临'%age)
else:
    print('抱歉，您的年龄是%d，不满十八岁不能入内'%age)  
    '''
    exec(game)
    '''
    控制台输出结果为：
    我是一段复杂的代码哦～
    欢迎来到网吧，请出示您的身份证12
    抱歉，您的年龄是12，不满十八岁不能入内
    '''

注意：这两个都支持控制台交互的python语句，比如input

eval和exec的区别：
1. eval的source只能是一个python表达式，而exec支持一个或多个python代码块
2. eval有返回值，返回值为表达式的结果。exec没有返回值

python中的映射类型除了字典还有其他的吗？如果没有，为什么局部变量不直接指定必须是字典类型，而是任何映射类型都可以呢？

13.getattr
参数：
o:对象名
name:属性名或类名
default:默认值
描述：获取对象或类的属性，当指定默认值时，若属性不存在则返回默认值，如果不指定默认值则报错
例子：

    print(getattr(jelly, 'halo', 'xixi'))  # xixi
    print(getattr(jelly,'length','xixi'))  # 70
    print(getattr(jelly,'love'))  # AttributeError: 'Dog' object has no attribute 'love'
    print(getattr(Dog, 'halo', 'xixi'))  # xixi
    print(getattr(Dog,'length','xixi'))  # 50
    print(getattr(Dog,'halo'))  # AttributeError: type object 'Dog' has no attribute 'halo'

setattr
参数：
obj:对象名
name:属性名或类名
value:值
描述：给对象或类设置属性值。若属性存在则覆盖，属性不存在则新建
例子：

    setattr(Dog,'length',23)  # 已存在的属性，定义类时定义的该属性的值为50
    print(getattr(Dog,'length'))  # 23
    setattr(Dog, 'type', '比熊')
    print(getattr(Dog, 'type'))  # 比熊
    setattr(jelly, 'length', 37)  # 已存在的属性，定义类时定义的该属性的值为50
    print(getattr(jelly, 'length'))  # 37
    setattr(jelly, 'haha', 'lala')
    print(getattr(jelly, 'haha'))  # lala

14.globals
参数：无
描述：以字典的形式返回当前位置的全部全局变量
例子：

print(globals())
    '''
    {
    '__name__': '__main__', 
    '__doc__': None, 
    '__package__': None,
    '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f9af80c7f10>,
    '__spec__': None, 
    '__annotations__': {},
    '__builtins__': <module 'builtins' (built-in)>,
    '__file__': '/Users/shilingli/workspace/PycharmProjects/pythonProject/common/博客练习/常用函数合集练习.py', 
    '__cached__': None, 
    'ast': <module 'ast' from '/Users/shilingli/software/anaconda/anaconda3/python.app/Contents/lib/python3.8/ast.py'>, 
    '运算符': <module '博客练习.运算符' from '/Users/shilingli/workspace/PycharmProjects/pythonProject/common/博客练习/运算符.py'>, 
    'Dog': <class '博客练习.tmp.Dog'>, 
    'jelly': <博客练习.tmp.Dog object at 0x7f9af81a5310>
    }
    '''

返回值里的特殊全局变量将会在写完这几篇博客后搞明白另起一篇博客写

15.hasattr
参数：
obj: 对象名或类名
name: 属性名
描述：返回对象或者类是否含有指定属性
例子：

    print(hasattr(jelly,'hala'))  # False
    print(hasattr(jelly, 'length'))  # True
    print(hasattr(jelly,'set_height'))  # True
    print(hasattr(Dog, 'hala'))  # False
    print(hasattr(Dog, 'length'))  # True

16.hash
参数：obj:对象
描述：返回对象的hash值，可以通过对象所在类的_hash_函数更改
例子：

类代码：
class Dog():
    length = 50
    # 胖了多少斤
    set_height = -1
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
    def __del__(self):
        # print('拜拜啦，我要去睡觉觉了')
        pass
    def __hash__(self):
        return 88
调用代码：
# 这是指定hash魔法函数之前的输出
    print(hash(jelly))  # 8788014796081
    print(hash(jelly))  # 88

17.help
参数：obj对象
描述：帮助命令，用于查看函数或者模块用途的详细说明，如果直接print(help())会跳转到命令行界面，直接输入要查询的函数名返回函数源码处的注释
例子：

print(help())
'''
控制台输出：
help> format
Help on built-in function format in module builtins:

format(value, format_spec='', /)
    Return value.__format__(format_spec)
    
    format_spec defaults to the empty string.
    See the Format Specification Mini-Language section of help('FORMATTING') for
    details.
和print(help('format'))打印出来的内容是一样的
'''

18.hex
参数：number整数
描述：将一个整数转换为十六进制，十六进制的数为字符串形式，以ox开头
十六进制以0～9和A_F(af)表示，A_F(af)代表10～15

十进制转十六进制的公式：
将十进制数除以16得到商和余数，再将商不断除以16，记录每次的余数，直到商为0，将记录的余数从小到大排列就是十六进制的数了

例子：

print(hex(19))  # 0x13
    '''
    1 19除以16 商为1余数为3
    2 1除以16  商为0余数为1
    到第二步商为0，不再循环除以16，将余数从小到大排列为13，加上十六进制的标志字符串0x则返回值为0x13
    '''

19.id
参数：obj:对象
描述：返回对象的内存地址，可以保证同时执行的对象是唯一的
例子：

    a = [1, 2, 3, 4]
    b = [1, 2, 3, 4]
    print(id(a))  # 140233367750784
    print(id(b))  # 140233367750528
    print(id(jelly))  # 140233099039504
    print(id([1, 2, 3, 4]))  # 140233367744448
    print(id([1, 2, 3, 4])) # 140233367744448
    print(id(Dog))  # 140233287151536
    print(id(Dog))  # 140233287151536

之前在调试代码时，曾打印过两次没有给变量赋值的列表，当时很诧异为什么打印出来的内存地址是一样的，一度怀疑我是用错了函数，或者是我哪写的不对。今天恍然大悟！原来我打印的是类，直接打印没有赋值的列表相当于打印的是类而不是对象。而id函数存在的意义是保证执行的对象是唯一的，而对象是类的实例化对象，同一个类初始化出来的对象的内存地址肯定是要唯一的，但类的内存地址却是相同的。给列表赋值给ab变量，则ab才是对象，内存地址才会不同

20.input
参数：obj:需要打印到控制台的输入提示信息
描述：返回字符串，接收用户输入的任何信息，但最后的换行只是结束本次输入并不会被要返回的字符串接收
例子：

    name = input('你叫什么？')
    print(type(name))
    print(name)
    '''
    控制台的输出结果：
    你叫什么？jelly
    <class 'str'>
    jelly
    '''

21.isinstance
参数：
obj:要判断的对象
class or tuple:类或者含有类型的元组，若命中元组中的任意一个都返回True
描述：判断一个对象是否为指定类型
例子：

类定义部分代码：
class Cat(Dog):
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
    def __str__(self):
        return self.name
调用部分代码：
    jeck = Cat('杰瑞','3个月了','橘色',20)
    print(isinstance(jeck,Dog))  # True
    print(isinstance(jeck,(Dog,int)))  # True
    print(type(jeck))  # <class '博客练习.tmp.Cat'>
    '''
    type函数只能返回该对象所在类是哪个，并没有继承的层级关系
    '''

22.issubclass
参数：
cls:类
class or tuple:类名或包含类的元祖
描述：判断参数类是否为指定类的子类，若元组中包含该类的子类则返回True
例子：

    print(issubclass(Cat,(Dog,int)))  # True

23.len
参数：obj对象
描述：返回对象的长度,可以通过对象的_len_魔法方法定义返回的长度值，若对象没有该魔法方法则抛异常
例子：

# 类定义部分：
class Dog():
    length = 50
    # 胖了多少斤
    set_height = -1
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
    def __del__(self):
        # print('拜拜啦，我要去睡觉觉了')
        pass
    def __hash__(self):
        return 88
    def __len__(self):
        return self.length
# 调用部分：
 print(len(jelly))  # 70

24.locals
参数：无
描述：以字典的形式返回当前位置的全部局部变量。

25.max
参数：
*args:待比较对象
key: key,指定比对函数
描述：计算并返回待比较对象中的最大值
例子：

  print(max([1,2,5,9,10],[2,6,4,9,12]))  # [2, 6, 4, 9, 12]默认比较第一位，若一样则顺延往后比较
  print(max([1,2,5,9,10],[2,6,4,9,12],key=lambda x:x[2]))  # [1, 2, 5, 9, 10]

26.min
参数：
*args:待比较对象
key: key,指定比对函数
描述：计算并返回待比较对象中的最小值
例子：

  print(min([1,2,5,9,10],[2,6,4,9,12]))  # [1, 2, 5, 9, 10]
  print(min([1,2,5,9,10],[2,6,4,9,12],key=lambda x:x[2]))  # [2, 6, 4, 9, 12]

27.next
参数：iter：迭代器
描述：返回可迭代器的下一个对象
例子：

    itera = iter([1,2,5,8,0,10])
    print(next(itera))  # 1
    print(next(itera))  # 2
    print(next(itera))  # 5
    print(next(itera))  # 8
    print(next(itera))  # 0
    print(next(itera))  # 10
    print(next(itera))  # 当没有下一个元素时报错：StopIteration

未生成迭代器的可迭代对象例如list是不可以作为参数使用的。这里必须是迭代器，或者使用yeild关键字的自定义函数也可以作为参数使用

28.iter
参数：iterable:可迭代对象
描述：将可迭代对象利用该函数生成迭代器
例子：

    print(iter('hello'))  # <str_iterator object at 0x7f8de8245310>
    print(iter([1,2,5,8,0,10]))  # <list_iterator object at 0x7f8de8245970>
    print(iter((1,2,5,8,0,10)))  # <tuple_iterator object at 0x7f8de8245970>
    print(iter({1,2,5,8,0,10}))  # <set_iterator object at 0x7f8de83cf880>

29.oct
参数：number:整数
描述：将指定整数转换为八进制的字符串形式，0o【零欧】为python中对八进制字符串的前缀
例子：

print(oct(181))  # 0o265

30.open
涉及内容较多，之前专门写过一篇讲解open函数的博客，地址：
https://blog.csdn.net/qq_43201025/article/details/119357482?spm=1001.2014.3001.5501

31.ord
参数：c:字符
描述：返回字符对应的ascii或unicode数值
例子：

print(ord('a'))  # 97

ord和chr：
ord是输入字符返回对应的ascii值，值为整数
chr是输入ascii值正数，返回ascii字符
结合使用返回本身print(ord(chr(97))) # 97

32.pow
参数：base**exp%mod
base:x
exp:y
mod:z
描述：如果两个参数为返回x的y次方的计算结果，如果三个参数，则返回x的y次方计算完后再对z取余
例子：

    print(pow(2,3))  # 8
    print(pow(2,3,5))  # 3

33.print
参数：
*args 为要打印的值，为不定长参数，参数之间以逗号分隔，打印后的值之间以空格隔开
sep 当输入多个打印的值时，通过该参数改变输出的各个值之间分割方式， 默认是空格，改变该值即可自定义
end 结束标识符,这里的\n为转义字符，代表换行，后面会介绍都有哪些转义字符
file 设置输出设备，即将结果打印到什么地方，默认只在控制台输出，也可以设置file= 文件后就会把内容存到指定文件中
描述：打印输出
例子：

    print('hello world')  # hello world

34.repr
参数：obj 对象
描述：返回对象的规范字符串表示形式，该字符串为对象的魔法方法_repr_中的返回值
例子：

类定义部分：
class Dog():
    def __repr__(self):
        return '我是比熊aaa 我非常happy'
# 调用部分
    jelly = Dog('果冻','7个月了','白色',10)
    print(repr(jelly))  # 我是比熊aaa 我非常happy

35.round
参数：number:浮点数
描述：对输入的浮点数采用四舍六入五成双

所谓四舍六入五成双分为：

1. 如果浮点数的小数第一位小于等于4则直接舍弃
2. 如果浮点数的小数第一位大于等于6直接进一
3. 如果浮点数的小数第一位等于5:
   1. 小数5后面还有其他值，则进一
   2. 小数5的后面没有其他值【奇进偶不进原则】
   1. 小数5前面的数为奇数，进一
   2. 小数5前面的数为偶数，舍弃
   例子：

    print(round(4.4))  # 4
    print(round(4.6))  # 5
    print(round(4.51))  # 5
    print(round(4.5))  # 4
    print(round(3.5))  # 4

36.sorted
参数：
iterable:可迭代对象
key:排序函数
reverse:是否降序排序,默认为False，也就是默认升序排序
描述：
例子：

    '''
    [1,7,17,9,11,19]
    x%7后的序列为：[1,0,3,2,4,5]
    所以结果为：[7,1,9,17,11,19]
    '''
    print(sorted([1,7,17,9,11,19],key=lambda x:x%7,reverse=False))  # [7, 1, 9, 17, 11, 19]

37.sum
参数：
iterable:可迭代对象
i：指定相加的值，需要和前面可迭代对象中的元素的值的类型保持一致。int和folat都算number类型
描述：
例子：

print(sum([1,2,5,8,10]))  # 26
print(sum([1,2,5,8,10],10))  # 36
print(sum([[1, 2],[5, 8]],[3,4]))  # [3, 4, 1, 2, 5, 8]

38.vars
参数：obj 对象或类名
描述：返回对象或类的属性字典对象{属性名1:属性值1,属性名2:属性值2……}
例子：

    print(vars(jelly))  # {'name': '果冻', 'age': '7个月了', 'color': '白色', 'length': 70}

注意：如果传入的参数是对象名的话，返回的对象的属性只有被初始化过的，不论是init函数中初始化赋值或者是在调用处进行赋值过的属性都可以被打印出来，但是没有被对象初始化过的类属性是不会被打印的

39.format
参数：
value:对象
format_sepc:待格式化的字符串
描述：返回对象的_format_方法的返回值
例子：

类定义部分代码：
class Dog():
    length = 50
    # 胖了多少斤
    set_height = -1
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
    def __del__(self):
        # print('拜拜啦，我要去睡觉觉了')
        pass
    def __hash__(self):
        return 88
    def __len__(self):
        return self.length

    def __format__(self, format_spec):
        return format_spec.replace('{}',self.name)
调用部分代码：
jelly = Dog('果冻', '7个月了', '白色', 70)
print(format(jelly,'我叫{}，我喜欢你'))  # 我叫果冻，我喜欢你

40.dir
参数：o 对象【可选】
描述：返回字符串列表。返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数中的包含方法_dir_()，该方法将被调用。如果参数不包含_dir_()，该方法将最大限度地收集参数信息。
例子：

类定义部分代码：
from typing import Iterable
class Dog():
    length = 50
    # 胖了多少斤
    set_height = -1
    def __init__(self,name,age,color,length):
        self.name = name
        self.age = age
        self.color = color
        self.length = length
    def __del__(self):
        # print('拜拜啦，我要去睡觉觉了')
        pass
    def __hash__(self):
        return 88
    def __len__(self):
        return self.length
    def __dir__(self) -> Iterable[str]:
        return iter(['果冻','jelly'])
调用部分代码：
    print(dir(jelly))  # ['jelly', '果冻']

41. zip
    参数:
    iterable: 一个或多个可迭代对象
    描述: 将多个可迭代对象的相同位置的元素打包成一个元组，如果各迭代对象的元素个数不一致，取长度最短，利用 * 号操作符，可以将元组解压为列表。
    例子:

'''zip拉链操作'''
    x = [1,2,3,4,5,6,7]
    y = ['a','b','c','d','e','f']
    z = zip(x,y)   # [(1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e') (6, 'f')]
    # print(*z)  # 直接打印*z 相当于是遍历的过程 结果为:(1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e') (6, 'f')
    zz = zip(*z)  # 将*z 传参相当于是遍历了 z 的每一个元素当做一个参数
    print([i for i in zz])
    for i in zip(x,y):
        print(i)
    for i,j in zip(x,y):
        print('{%s}---->{%s}'%(i,j))
    '''
    控制台输出:
    [(1, 2, 3, 4, 5, 6), ('a', 'b', 'c', 'd', 'e', 'f')]
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')
(6, 'f')
{1}---->{a}
{2}---->{b}
{3}---->{c}
{4}---->{d}
{5}---->{e}
{6}---->{f}
    '''

zip 是取长度最短,如果要取长度最长使用 zip_longest 函数,长度不足的列表补 None