阿里天池-Python训练营task2

一、学习知识点概要
本次主要学习Python中的容器（序列）类型，包括：

列表（list）
元组（tuple）
字符串（str）
字典（dict）
集合（set）
二、学习内容
I.列表（list）
1.定义
列表(list)为有序集合，可以保存任意类型的对象，语法为[元素1,元素2,……,元素n]。列表的语法点在于用中括号“[]”将元素放在一起，用逗号“,”将元素隔开

2.创建列表
列表可以通过直接赋值创建，也可以用内置方法list(sub)把可迭代对象sub转化为列表，其中sub可以为range对象、字符串等。此外，在上次的学习中学习的列表推导式也可以用于创建列表,例如：

a=[1,2,'Python',True]   #直接赋值创建列表，元素为任意对象，列表中保存的是对象的引用
print(a,type(a))
   #运行结果：
   #[1,2,'Pthon',True] <class'list'>
 
b=list(range(1,11))    #通过list()方法将range对象转换为列表
print(b,type(b))
  #运行结果：
  #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] <class 'list'>
 
c=[i*2 for i in b]     #通过推导式创建列表
print(c,type(c))
  #运行结果：
  #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20] <class 'list'>
 
d=[]    #创建空列表，之后可以用list类的内置方法添加元素，详见下文
 
f=[[1,2,3]]*3          #列表的元素也可以是容器类型
print(f,type(f))       #*3的操作意为将创建了3份原列表的引用，看似是3个相同的列表拼在了一起
f[0][1]=5              #其实这3个相同列表的引用都是一样的，都指向原列表
print(f,type(f))       #只要一个列表产生变化，原列表就会变化，其他被拼接起来的列表也会变化
  #运行结果：
  #[[1, 2, 3], [1, 2, 3], [1, 2, 3]] <class 'list'>
  #[[1, 5, 3], [1, 5, 3], [1, 5, 3]] <class 'list'>
 3.列表的添加、删除操作
列表中有一些内置方法，可对列表进行添加或删除元素的操作。这些操作对列表的id不产生影响，这表明列表是可变的。字典和集合也是可变的，而数值、元组、字符串是不可变的。

判断一个数据可不可变可以用hash()方法判断，如果参数的数据类型是可变的，那么就会报错。

(1)添加元素

list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类。append()方法一次只添加一个元素，若参数obj为一个列表，那么这个列表会作为一个整体添加到 list 中；
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值，参数seq为列表，此方法用新列表seq拓展原列表list。相当于把seq接到list的末尾，是对list的操作，无返回值；
list.insert(index,obj)在编号index的位置插入元素obj。对参数obj的要求和append()一样，index表示第几个间隔，index从0数起。
例程：

x=list(range(1,6))
print(x)               #运行结果:[1,2,3,4,5]
 
x.append(6)            #在末尾添加元素6
print(x)               #运行结果:[1,2,3,4,5,6]
 
x.append([7,8])        #参数obj为列表，将列表整体当作一个元素添加到末尾
print(x)               #运行结果:[1,2,3,4,5,6,[7,8]]
 
x.extend([9,10])       #用列表[9,10]拓展x，即将[9,10]中的所有元素添加到x的末尾
print(x)               #运行结果:[1,2,3,4,5,6,[7,8],9,10]
 
x.insert(0,'Numbers')  #在第0个间隔之间(即最左端)插入字符串'Numbers'
print(x)               #运行结果:['Numbers',1,2,3,4,5,6,[7,8],9,10]
(2)删除元素

list.remove(obj)删除列表中第一个与obj相同的元素。remove()方法为对list的一项操作，无返回值；
list.pop([index=-1])返回并删除列表中index位置的元素。index为可选参数，表示列表的索引，索引相关详见下文。pop()方法默认取出列表中的最后一个元素；
del语句可以用于删除单个或多个列表对象。具体用法为 del list[var1]，或del list[start:end:step]。del 语句原本就可以用于删除变量，若del 后面写的是列表则删除整个列表，若写的是列表的切片则删除列表中相对应的元素。
例程：

x=['I','Love','Python',1,2,3]
print(x,type(x))                   #运行结果:['I','Love','Python',1,2,3] class<'list'>
 
x.remove('I')                      #删除x中的'I'
print(x)                           #运行结果:['Love', 'Python', 1, 2, 3]
 
y=x.pop()                          #从x中取出最后一个元素赋给y
print('x=',x,'\ny=',y,sep="")      #运行结果:x=['Love', 'Python', 1, 2]
                                   #         y=3
 
del x[2],x[2]                      #删除x中的第3个元素，依次执行
print(x)                           #注意：del语句后的删除对象是依次执行的，先执行完一次
                                   #删除x[2]后x[3]就没有了，然后再执行一次删除x[2]
#运行结果：['Love', 'Python']
4.列表元素选取
(1)索引

可以通过list[index]的方式表示列表list中的元素，index为索引值，整数，从0开始。

若index为负数，则从右到左数起。例如list[-1]是列表list的最后一个元素，list[-2]是列表list的倒数第二个元素。

(2)切片

切片是一种一次性从列表里进行多个索引的方式，写法为list[start:end:step=1]，start为选取的第一个元素，end为选取的最后一个元素，step为步长，默认为1。切片有四种用法：

list[start:]  从start位置开始，选取后面的所有元素
list[:end]  从第一个元素开始，选取到end位置的前一个元素（含头不含尾）
list[start:end]  从start位置开始，选取到end位置的前一个元素
list[start:end:step]  从start位置开始，每隔step个间隔选取一个元素，直到end位置为止（不含end位置上的元素）
list[:]  选取所有元素，进行浅拷贝
例如：

x=list(range(1,11))
print(x)                     #[1,2,3,4,5,6,7,8,9,10]
print(x[5:])                 #[6,7,8,9,10]
print(x[:7])                 #[1,2,3,4,5,6,7]
print(x[2:7])                #[3,4,5,6,7]
print(x[0:8:2])              #[1,3,5,7]
 
y=x[:]                       #y为x的浅拷贝
z=x                          #z为x的深拷贝
x[0]=11
print(y)                     #[1,2,3,4,5,6,7,8,9,10]
print(z)                     #[11,2,3,4,5,6,7,8,9,10]
浅拷贝是将列表的各个元素的引用依次给新的列表，而深拷贝则是将列表的引用直接赋给新的列表，这就导致对原本的列表进行操作时，浅拷贝出来的列表不会受到影响，而深拷贝出来的列表会和原列表一致。

5.列表常用操作符
==  用于判断两个列表是否相等，只有当对应位置上的元素都相等才返回True
+    用于拼接两个列表
*     后面接整数n，用于把原列表重复n次形成新列表，若n小于或等于0则生成空列表
in   判断元素是否在列表内
not in  判断元素是否不在列表内
将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

6.列表的其他方法
list.count(obj)                                      统计obj元素在list列表中出现多少次
list.index(obj,[start[,end]])                 返回obj元素在list列表里[start:end]范围内第一次出现的索引值
list.reverse()                                        将列表list里的元素反方向排列，对list直接操作，无返回值
list.sort(key=None,reverse=False)    将列表进行排序。key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse排序规则，为True时降序，为False时升序（默认）。
例如：

x=[1,2,3]*4
print(x)                             #[1,2,3,1,2,3,1,2,3,1,2,3]
 
print(x.count(1))                    #计1出现的次数
                                     #4
 
print(x.index(2,2,6))                #在下表[2,6]的范围内检查2第一次出现的下标
                                     #4
 
x.reverse()                          #将x反向排序
print(x)                             #[3,2,1,3,2,1,3,2,1,3,2,1]
 
x.sort()                             #将x排序
print(x)                             #[1,1,1,1,2,2,2,2,3,3,3,3]
II.元组（tuple）
1.定义
与列表类似，不同点在于元组用小括号()将元素绑在一起，元组不可修改。与列表类似，元组也可以用整数进行索引和切片。

2.创建元组
元组可以直接赋值创建，赋值时若有多个元素，可以不加小括号；若只有一个元素，则需要在元素后面加上一个逗号，否则会被认为是其他数据类型
元组可以用内置方法tuple(sub)将可迭代对象对象sub转化为元组
可以用小括号创建空元组
可以用推导式创建可迭代对象，再转换成元组
例：

a=(4,5,6)                                 #直接赋值创建元组
print(a,type(a))                          #(4, 5, 6) <class 'tuple'>
 
b=(1,)                                    #单个元素创建元组需要在元素后面加上逗号
c=(1)
d=1,2,3                                   #多个元素时可以不加小括号
print(type(b),type(c),type(d),sep="\n")   #<class 'tuple'>
                                          #<class 'int'>
                                          #<class 'tuple'>
 
f=tuple(range(1,6))                       #用tuple()方法把range对象转换为元组
print(f,type(f))                          #(1, 2, 3, 4, 5) <class 'tuple'>
 
g=()                                      #创建空元组
print(g,type(g))                          #() <class 'tuple'>
 
h=tuple((i*3 for i in f))                 #推导式创建可迭代对象，再转换成元组
print(h,type(h))                          #(3, 6, 9, 12, 15) <class 'tuple'>
 3.元组的更新和删除
元组有不可更改的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改，那么我们可以直接更改其元素，注意这跟赋值其元素不同。（列表、字典、集合可以改变）

例：

a=(1,2,3,[4,5,6])
a[3][0]=8
print(a,type(a))            #(1, 2, 3, [8, 5, 6]) <class 'tuple'>
 
del a[3][0]
print(a,type(a))            #(1, 2, 3, [5, 6]) <class 'tuple'>
4. 元组常用操作符
元组的常用操作符有「==」，「+」，「*」，「in」，「not in」。用法与列表的操作符相同，此处不作赘述。

5.元组的内置方法
由于元组的不可改变性，元组的内置方法只有count()和index()。用法也与列表的count()和index()相同，此处不作赘述。

6.解压元组
通过(变量1 , 变量2 , …… , 变量n)=元组 的方式可以将元组中的元素依次付给等号左边的变量，等号左边的括号结构要与元组的结构相同（长度、维度）

如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。

例：

x=(1,2,'Python',[10.2,6])
(a,b,c,[d,f])=x
print(a,b,c,d,f)                 #1 2 Python 10.2 6
 
y=tuple(range(1,6))
q,w,*rest,r=y
print(q,w,r)                     #1 2 5
print(rest)                      #[3, 4]    rest为一个列表
 
t=1,2,3,4,5
a,b,*_=t
print(a,b)                       # 1 2
III.字符串（str）
1.定义
字符串为用引号之间的字符集合，可以用单引号也可以用双引号。例如 'Python' ，"S-PLUS"都是字符串。

2.字符串常用转义字符
由于反斜杠「\」、单引号「'」、双引号「"」在字符串中有特殊性，因此如果要在字符串中出现这三个符号，需要在前面再加上一个反斜杠。

\\     反斜杠
\'     单引号
\"    双引号
\n   换行符
\r    回车符
\t    横向制表符
若要表示原始字符串则只需在字符串之前加上小字母「r」即可。

三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

例：

print("I\nLove\nPython")
#I
#Love
#Python
 
print(r"I\nLove\nPython")
#I\nLove\nPython
 
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB (    )。
# 也可以使用换行符 [
#  ]。
3.字符串的索引和切片
字符串的索引和切片与列表和元组的类似，每一个字符都为字符串的元素，此处不作赘述。

4.字符串的操作符
字符串的操作符也为「==」，「+」，「*」，「in」，「not in」，用法与列表和元组相同。

5.字符串的内置方法
str.capitalize()                                                  返回一个新字符串，将字符串的第一个字符转换为大写，其他的转为小写
str.lower()                                                         返回一个新字符串，转换字符串中所有大写字符为小写
str.upper()                                                        返回一个新字符串，转换字符串中所有大写字符为大写
str.swapcase()                                                 返回一个新字符串，将字符串中大写转换为小写，小写转换为大写
str.count(str1,beg=0,end=len(str))                   统计字符串str1在str的指定范围(beg,end)出现的次数
str.endswith(suffix, beg=0, end=len(string))    检查指定范围内的字符串是否以suffix结束
str.startswith(substr, beg=0,end=len(string))   检查指定范围内的字符串是由以substr开始
str.find(str1, beg=0, end=len(string))               从左查找str1在指定范围字符串内的位置，返回索引值，若str1不在指定范围内则返回-1
str.rfind(str, beg=0,end=len(string))                 与find()类似，从右开始查找
str.isnumeric()                                                  如果字符串中只包含数字字符，则返回 True，否则返回 False
str.ljust(width[,fillchar=" "])                               返回一个新字符串，用fillchar扩充原字符串至长度width为止，原字符串向左对齐
str.rjust(width[,fillchar=" "])                              和ljust()类似，原字符串向右对齐
str.lstrip([chars])                                              删除字符串左边的空格或指定字符
str.rstrip([chars])                                              删除字符串右边的空格或指定字符
str.strip([chats])                                               执行lstrip()和rstrip()
str.partition(sub)                                              找到子字符串sub，把字符串分为一个元组('左边的字符串','sub','右边的字符串')，如果字符串中不包含sub则返回('原字符串','','')
str.rpartition(sub)                                             与partition()类似，从右边开始查找
str.replace(old,new[,max])                               把将字符串中的old替换成new，如果max指定，则替换不超过max次
str.split(str=" ",num)                                         不带参数默认是以空格为分隔符分开字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表
str.splitlines([keepends])                                 如果字符串按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符
str.maketrans(intab,outtab)                            创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
str.translate(table,deletechars="")                  根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。
6.字符串格式化
可以用str.format()格式化方法进行格式化，例如：

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup
 
str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup
 
str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup
 
str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB
格式化符号：

符 号    描述
%c    格式化字符及其ASCII码
%s    格式化字符串，用str()方法处理对象
%r    格式化字符串，用rper()方法处理对象
%d    格式化整数
%o    格式化无符号八进制数
%x    格式化无符号十六进制数
%X    格式化无符号十六进制数（大写）
%f    格式化浮点数字，可指定小数点后的精度
%e    用科学计数法格式化浮点数
%E    作用同%e，用科学计数法格式化浮点数
%g    根据值的大小决定使用%f或%e
%G    作用同%g，根据值的大小决定使用%f或%E
例：

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'
格式化操作符辅助命令：

符号    功能
m.n    m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
-    用作左对齐
+    在正数前面显示加号( + )
#    在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0    显示的数字前面填充'0'而不是默认的空格
例：

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005
IV.字典（dict）
1.定义
字典是无序的，由大括号绑起来的(key:value)键值对集合，语法结构为{key1:value1,key2:value2, …… ,key n:value n}
同一字典内的键(key)是不重复的
字典用不可变数据作为键，而值没有这个要求
字典内的排放顺序与键的放入顺序无关
字典的每一个元素为(key:value)键值对
冒号用于分开键和值
2.创建和索引
字典可以通过直接赋值创建，也可以用推导式创建，还可以用dict()创建一个字典。

dict()内的参数可以是n×2维的列表，列表内的元素为二维的元组，这样会将元组的两个元素分别作为键值对创建字典

也可以直接用dict(key1=value1,key2=value2, ……)的方式创建字典，但是这样的字典的键只能是字符串

例：

dic={'李宁':'一切皆有可能','耐克':' Just do it','阿迪达斯':'Impossible is nothing'}
print('耐克的口号是:',dic['耐克'])
   # 耐克的口号是: Just do it
 
b={i:i%2==0 for i in range(10) if i % 3 == 0}    #推导式创建
print(b)
# {0: True, 3: False, 6: True, 9: False}
 
c=dict()                                      #创建空字典
c['a']=1
c['b']=2
print(c)
#  {'a':1 ,'b':2}
 
dic2=dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2)               # {'peach': 4127, 'cherry': 4098, 'apple': 4139}
 
dic = dict(name='Tom', age=10)
print(dic,type(dic))              # {'name': 'Tom', 'age': 10} <class 'dict'>
字典的索引只能通过键来索引，语法结构为dict[key]，返回的是对应键的值value，如果索引的键不存在，则会报错。

3.字典的内置方法
dict.fromkeys(seq[,value])                  用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
dict.keys()                                           返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
dict.values()                                        与keys()类似，不过返回的内容是所有的值
dict.items()                                          以n×2列表的形式返回可遍历的 (键, 值) 元组数组，列表元素为元组
dict.get(key,default=None)                 与dict[key]类似，返回指定键的值，但如果值不在字典中则返回默认值default
dict.setdefault(key,default=None)      与get()类似，类似，如果键不存在于字典中，将会添加键并将值设为默认值
in 和 not in 操作符                              字典也可以使用in和not in 操作符，不过只能检查键key是否在字典中
dict.pop(key[,default])                        抛出给定键key对应的值，若key不存在，则必须设置默认值default并会返回默认值
del dict[key]                                        删除字典中给定的键所在的元素
dict.popitem()                                     随机抛出字典中的一个值，若字典为空，则会报错
dict.clear()                                          删除字典中的所有元素
dict.copy()                                          返回字典的一个浅拷贝
dict.update(dict2)                               键字典型参数dict2中的元素更新到dict中
V.集合（set）
1.定义
集合与字典相似，由大括号将元素绑在一起，但是集合只保存键(key)
由于字典中key不可重复，所以集合中也没有重复的元素
集合中的元素（即key）为不可变型数据
2.创建
集合可以通过直接赋值创建，也可以用推导式创建，还可以用set(value)函数将可迭代对象转换成集合，重复元素会被自动过滤。

例：

a={1,2,3,4,4}               #直接赋值创建集合，重复元素自动过滤
print(a,type(a))            #{1, 2, 3, 4} <class 'set'>
 
b={i*2 for i in range(1,11) if i%3==0}     #推导式创建集合
print(b,type(b))                           #{18, 12, 6} <class 'set'>
 
c=set(list(range(5,12)))                   #set()将列表转化为集合
print(c,type(c))                           #{5, 6, 7, 8, 9, 10, 11} <class 'set'>
 
d=set()                                    #创建空集合只能用set()创建
print(d,type(d))                           #{} <class 'set'>
2.访问集合中的值
由于集合的无序性，我们不能用索引取得集合中的值，但我们仍然可以用一些方法得到一些值

用针对序列的方法len(set)可以返回集合set的大小，即元素的个数
集合作为可迭代对象也可以用for循环一个个读取出来
例：

b={i*2 for i in range(1,11) if i%3==0}
print(b)                                   #{18, 12, 6}
 
for j in b:
    print(j)                               #18
                                           #12
                                           #6
可以用 in 和 not in 操作符判断一个元素是否在集合里
3.集合的内置方法
set.add(elmnt)                              用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作
set.update(set2)                           与字典的update()方法类似，将集合set2中的元素更新到集合set里
set.remove(item)                          用于移除集合中的指定元素。如果元素不存在，则会发生错误
set.discard(item)                          与remove()类似，但不会报错
set.pop()                                      随机抛出一个元素
set.intersection(set2)                   返回set与set2的交集，操作与set & set2 相同
set.intersection_update(set2)      将set更新为原set和set2的交集
set.union(set2)                             返回set与set2的并集，操作与set | set2 相同
set.difference(set2)                      返回set与set2的差集，操作与set - set2 相同
set.difference_update(set2)         将set更新为原set和set2的差集
set.symmetric_difference(set2)    返回set与set2的异或，操作与set ^ set2 相同，也与(set | set2) - (set & set2)相同
set.symmetric_difference_update(set2)  将set与set2的异或更新到set中
set.issubset(set2)                         判断set是否被set2包围，操作与set <= set2 相同
set.issuperset(set2)                      判断set是否包围set2，操作与set >= set2相同
set.isdisjoint(set2)                         判断set与set2是否不相交，不相交则返回True
4.不可变集合（frozenset）
普通的集合是可变的，但是Python提供了实现不可变集合的方法，不可变集合与集合不属于同一类，不可变集合属于<frozenset>

不可变集合与普通集合类似，但是不能添加或删除元素，因此不能用代有update的方法

frozenset([iterable])可以将可迭代对象iterable转换为不可变集合，如果没有参数则生成不可变的空集

VI.序列
序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

一般的有转换类型的方法如：list()、tuple()和str()等，此外还有一些通用的方法：

len(s)                                                                  返回序列类型s的元素个数（长度）
max(sub)                                                            返回序列或者参数集合中的最大值，若sub为字符串，则比较ASCII码值
min(sub)                                                             返回序列或者参数集合中的最小值
sum(iterable[,start=0])                                        返回序列（可迭代对象）iterable与可选参数start的总和
sorted(iterable,key=None,reverse=Flase)          对所有可迭代对象iterable进行排序操作，key和reverse参数和前文提到的sort()方法相同
reversed(seq)                                                     返回一个反转的可迭代对象
enumerate(sequence[,start=0])                          将可枚举的对象（序列）组合为一个索引序列，常用在for循环中
zip(iter1 [,iter2 [...]])                                             将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。若不同对象的长度不同，则返回的列表长度与最短的对象相同，用*zip()可以将zip对象解压
————————————————
版权声明：本文为CSDN博主「突发恶疾的Kaz哥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/LuKenkazia/article/details/116148235