天池Python训练营笔记—Python基础：数据结构大汇总

概述列表简单数据类型：整型，浮点型和布尔型。容器数据类型：列表，元组，字典，集合和字符串。1.列表的定义列表是有序集合，无固定大小，能够保存任意数量任意类型的Python对象。语法的关键点是中括号[]和逗号,中括号：把所有元素绑在一起。逗号：把每个元素一一分开。2.列表的创建创建一 列表

简单数据类型：整型，浮点型和布尔型。

容器数据类型：列表，元组，字典，集合和字符串。

1. 列表的定义

列表是有序集合，无固定大小，能够保存任意数量任意类型的Python对象。

语法的关键点是中括号[]和逗号,中括号：把所有元素绑在一起。逗号：把每个元素一一分开。2. 列表的创建创建一个普通列表

x = ['Monday','Tuesday','Wednesday','Thursday','FrIDay']print(x,type(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'FrIDay'] <class 'List'>

利用range()创建列表

x = List(range(10))print(x,type(x))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'List'>

利用推导式创建列表

x = [0]*5print(x,type(x))

[0, 0, 0, 0, 0] <class 'List'>

x = [0 for i in range(5)]print(x,type(x))

[0, 0, 0, 0, 0] <class 'List'>

x = [i for i in range(1,10,2)]print(x,type(x))

[1, 3, 5, 7, 9] <class 'List'>

x = [i for i in range(100) if (i%2)!=0 and (i%3)==0]print(x,type(x))

[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'List'>

注：

由于List的元素是任意对象，因此列表中所保存的是对象的指针，即使最简单的[1,2,3]，也有三个整数对象。x = [a] * 4中，如果a发生了改变，x中4个a也会随之改变。

举例：

x = [[0]*3]*4print(x,type(x))

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'List'>

x[0][0] = 1print(x,type(x))

[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'List'>

a = [0] * 3x = [a] * 4print(x,type(x))

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'List'>

x[0][0] = 1print(x,type(x))

[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'List'>

创建混合列表`

mix = [1,'lsgo',3.14,[1,2,3]]print(mix,type(mix))

[1, 'lsgo', 3.14, [1, 2, 3]] <class 'List'>

创建一个空列表

empty = []print(empty,type(empty))

[] <class 'List'>

由于列表的元素可以随意更改，所以附加(append,extend)、插入(insert)、删除(remove,pop)这些 *** 作列表都可以使用

3.添加元素List.append(obj) 在列表末尾添加新对象，参数可以是任意数据类型

x = ['Monday','Tuesday','Webnesday','Thursday','FrIDay']x.append('Thursday')print(x)

['Monday', 'Tuesday', 'Webnesday', 'Thursday', 'FrIDay', 'Thursday']

添加List时将List作为整体追加，注意append()和extend()的区别

x = ['Monday','Tuesday','Webnesday']x.append(['Thursday','Sunday'])print(x)

['Monday', 'Tuesday', 'Webnesday', ['Thursday', 'Sunday']]

List.extend(seq)在列表末尾一次性追加另一个序列（可迭代）中的多个值

x = ['Monday','Tuesday','Webnesday']x.extend(['Thursday','Sunday'])print(x)

['Monday', 'Tuesday', 'Webnesday', 'Thursday', 'Sunday']

List.insert(index,obj)在索引index处插入obj

x = ['Monday','Tuesday','Webnesday','Thursday','FrIDay']x.insert(2,'Sunday')print(x)

['Monday', 'Tuesday', 'Sunday', 'Webnesday', 'Thursday', 'FrIDay']

4. 删除元素List.remove(obj)依据某值删除对应元素

x = ['Monday','Tuesday','Webnesday','Thursday','FrIDay']x.remove('Monday')print(x)

['Tuesday', 'Webnesday', 'Thursday', 'FrIDay']

List.pop([index = -1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

x = ['Monday','Tuesday','Webnesday','Thursday','FrIDay']y = x.pop()print(y)

FrIDay

del var1[,var2...]删除单个或多个对象。

知道要删除元素在列表中的位置，可以使用del

x = ['Monday','Tuesday','Wednesday','Thursday','FrIDay']del x[0:2]print(x)

['Wednesday', 'Thursday', 'FrIDay']

5. 获取列表中的元素通过元素的索引值，从列表中获取单个元素通过将索引指定为-1，可以让python返回最后一个列表元素，依次类推。

x = ['Monday','Tuesday','Wednesday']print(x[0],x[-1])

Monday Wednesday

切片的通用写法 start:stop:step

x = ['Monday','Tuesday','Wednesday','Thursday','FrIDay']print(x[3:])print(x[:3])print(x[1:3])print(x[1:-1:2])

['Thursday', 'FrIDay']['Monday', 'Tuesday', 'Wednesday']['Tuesday', 'Wednesday']['Tuesday', 'Thursday']

6. 列表的常用 *** 作符等号 *** 作符：==连接 *** 作符 +重复 *** 作符 *成员关系 *** 作符 in、not in

列表拼接有两种方式，用+和*，前者首尾拼接，后者复制拼接

List1 = [123,456]List2 = [456,123]List3 = [123,456]print(List1 == List2)print(List1 == List3)List4 = List1+List2print(List4)List5 = List3*3print(List5)print(123 in List3)print(456 not in List3)

FalseTrue[123, 456, 456, 123][123, 456, 123, 456, 123, 456]TrueFalse

7. 列表的其它方法List.count(obj)统计某个元素在列表中出现的次数

List1 = [123,456]*3print(List1)num = List1.count(123)print(num)

[123, 456, 123, 456, 123, 456]3

List.index(x,start,end)从列表中找出某个值第一个匹配项的索引位置

List1 = [123,456] * 5print(List1.index(123))print(List1.index(123,1))print(List1.index(123,3,7))

024

List.reverse()反向列表中的元素

x = [123,456,789]x.reverse()print(x)

[789, 456, 123]

List.sort(key = None,reverse = False)对原列表进行排序

x = [123,456,789,213]x.sort()print(x)x.sort(reverse=True)print(x)

元组1. 创建并访问元组

t1 = (1,10.31,'python')t2 = 1,10.31,'python'print(t1,type(t1))print(t2,type(t2))tup = (1,2,3,4,5,6,7,8)print(tup[1])print(tup[5:])print(tup[:5])tup1 = tupprint(tup1)

(1, 10.31, 'python') <class 'tuple'>(1, 10.31, 'python') <class 'tuple'>2(6, 7, 8)(1, 2, 3, 4, 5)(1, 2, 3, 4, 5, 6, 7, 8)

注：元组中只包含一个元素时，需要在元素后面添加逗号，不然括号会被当作运算符使用2. 更新和删除一个元组

week = ('Monday','Tuesday','Thursday','FrIDay')week = week[:2] + ('Wednesday',) + week[2:]print(week)

('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'FrIDay')

3. 元组相关的 *** 作符

t1 = (123,456)t2 = (456,123)t3 = (123,456)print(t1 == t2)print(t1 == t3)t4 = t1 + t2print(t4)

4. 内置方法

t = (1,10.31,'python')print(t.count('python'))print(t.index(10.31))

11

5. 解压元组

#解压一维元组t = (1,10.31,'python')(a,b,c) = tprint(a,b,c)#解压二维元组t = (1,10.31,('OK','python'))(a,b,(c,d)) = tprint(a,b,c,d)#通配符提取你想要的变量t = 1,2,3,4,5a,b,*rest,c = tprint(a,b,c)print(rest)#不需要变量名就用*加上下划线代替t = 1,2,3,4,5a,b,*_ = tprint(a,b)

1 10.31 python1 10.31 OK python1 2 5[3, 4]1 2

字符串1. 字符串的定义

t1 = 'i love Python'print(t1,type(t1))

i love Python <class 'str'>

常用转义字符

print('let\'s go')print("let's go")print('C:\Now')print('C:\Program files\Intel\Wifi\Help')

let's golet's goC:\NowC:\Program files\Intel\Wifi\Help

原始字符串只需要加上英文字母r即可

print(r'C:\Program files\Intel\Wifi\Help')

C:\Program files\Intel\Wifi\Help

2. 字符串的切片与拼接

str1 = 'I love LsgoGroup'print(str1[:6])print(str1[5])print(str1[:6]+'插入的字符串'+str1[6:])

I loveeI love插入的字符串 LsgoGroup

3. 字符串的常用内置方法cAPItalize() 将字符串的第一个字符转换为大写

str2 = 'xiaoxIE'print(str2.cAPItalize())

XiaoxIE

lower() 转换字符串中所有大写字符为小写upper() 转换字符串中的小写字母为大写swapcase() 将字符串中大写转换为小写，小写转换为大写

str2 = 'DAXIExiaoxIE'print(str2.lower())print(str2.upper())print(str2.swapcase())

daxIExiaoxIEDAXIEXIAOXIEdaxIEXIAOXIE

count(str,beg = 0,end = len(string))返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数

str2 = 'DAXIExiaoxIE'print(str2.count('xi'))

2

find(str,beg = 0,end = len(string))检测str是否包含在字符串中，包含返回索引值，否则返回-1.rfind(str,beg = 0,end = len(string)) 和 find函数作用相同，从右边开始查找

str2 = 'DAXIExiaoxIE'print(str2.find('xi'))print(str2.find('ix'))print(str2.rfind('xi'))

5-19

isnumeric()如果字符串只包含数字字符，则返回True，否则返回False

str3 = '12345'print(str3.isnumeric())str3 += 'a'print(str3.isnumeric())

TrueFalse

ljust(wIDth,fillchar)返回原字符串的左对齐，并使用fillchar（默认空格填充至长度wIDth的新字符）rjust(wIDth,fillchar)返回原字符串的右对齐。

str4 = '1101'print(str4.ljust(8,'0'))print(str4.rjust(8,'0'))

1101000000001101

lstrip([chars])截掉字符串左边的空格或指定字符rstrip([chars])删除字符串末尾的空格或指定字符strip([chars])在字符串上同时执行lstrip()和rstrip()

str5 = ' I love LsgoGroup 'print(str5.lstrip())print(str5.lstrip().strip('I'))print(str5.rstrip())print(str5.strip())print(str5.strip().strip('p'))

I love LsgoGroup  love LsgoGroup  I love LsgoGroupI love LsgoGroupI love LsgoGrou

partition(sub)找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)

str5 = 'I love LsgoGroup'print(str5.strip().partition('o'))print(str5.strip().partition('m'))

('I L', 'o', 've LsgoGroup')('I love LsgoGroup', '', '')

replace(old,new,max)将字符串中的old替换成new，max指定为最大替换次数

str5 = 'I love LsgoGroup'print(str5.strip().replace('I','We'))

We love LsgoGroup

split(str = "",num)不带参数默认以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num各2子字符串，返回切片后的子字符串拼接的列表。

str5 = 'I love LsgoGroup'print(str5.strip().split())print(str5.strip().split('p'))

['I', 'love', 'LsgoGroup']['I love LsgoGrou', '']

splitlines([keepends])按照行('\r','\r\n',\n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符

str6 = 'I \n love \n LsgoGroup'print(str6.splitlines())print(str6.splitlines(True))

['I ', ' love ', ' LsgoGroup']['I \n', ' love \n', ' LsgoGroup']

maketrans(intab,outtab)创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。translate(table,deletechars = '')根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

str7 = 'this is string example...wow!!!'intab = 'aeIoU'outtab = '12345'trantab = str7.maketrans(intab,outtab)print(trantab)print(str7.translate(trantab))

{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}th3s 3s str3ng 2x1mpl2...w4w!!!

4. 字符串格式化format格式化函数

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

I love LsgogroupI love LsgogroupI love Lsgogroup27.66GB

Python字符串格式化符号

格式化 *** 作符辅助指令

字典1.可变类型与不可变类型序列以连续的整数为索引，字典以'关键字'为索引，关键字可以是任意不可变类型，通常用字符串或数值。字典是Python唯一的一个映射类型，字符串、元组和列表属于序列类型。

判断数据类型X是否为可变类型的方法：

麻烦：用ID(X)函数，比较 *** 作前后的ID，如果不一样就是不可变类型，如果一样就是可变类型。便捷：用hash(X),只要不报错，证明X可被哈希，就是不可变类型，反之为可变类型。

i = 1print(ID(i))i += 2print(ID(i))l = [1,2]print(ID(l))l.append('Python')print(ID(l))

14072672525699214072672525705625538634693762553863469376

print(hash({1,2,3}))

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-26-653299afdf87> in <module>----> 1 print(hash({1,2,3}))TypeError: unhashable type: 'set'

数值、字符和元组都能被哈希，因此它们是不可变类型列表、集合、字典不能被哈希，因此它们是可变类型2. 创建和访问字典

brand = ['李宁','Nike','AdIDas']slogan = ['一切皆有可能','Just do it','Impossible is nothing']print('Nike 的口号是：',slogan[brand.index('Nike')])dic = {'李宁':'一切皆有可能','Nike':'Just do it','AdIDas':'Impossible is nothing'}print('Nike 的口号是：',dic['Nike'])

Nike 的口号是： Just do itNike 的口号是： Just do it

以元组和列表的形式创建字典

dic1 = dict([('apple',4139),('peach',4127),('cherry',4098)])dic2 = dict((('apple',4139),('peach',4127),('cherry',4098)))print(dic1)print(dic2)

{'apple': 4139, 'peach': 4127, 'cherry': 4098}{'apple': 4139, 'peach': 4127, 'cherry': 4098}

4.字典内置方法dict.fromkeys(seq,value)用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

seq = ('name','age','sex')dic1 = dict.fromkeys(seq)print(dic1)dic2 = dict.fromkeys(seq,10)print(dic2)dic3 = dict.fromkeys(seq,('小马','8','男'))print(dic3)

{'name': None, 'age': None, 'sex': None}{'name': 10, 'age': 10, 'sex': 10}{'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}

dict.keys()返回一个迭代器，可以使用List()来转换为列表，列表为字典中的所有值。

dic = {'Sex':'female','Age':7,'name':'Zara'}print(dic.values())print(List(dic.values()))

dict_values(['female', 7, 'Zara'])['female', 7, 'Zara']

dict.items()以列表返回可遍历的元组数组

dic = {'name':'Lsgogroup','Age':7}print(dic.items())print(tuple(dic.items()))print(List(dic.items()))

dict_items([('name', 'Lsgogroup'), ('Age', 7)])(('name', 'Lsgogroup'), ('Age', 7))[('name', 'Lsgogroup'), ('Age', 7)]

dict.get(key,default = None)返回指定键的值，如果值不在字典中则返回默认值

dic = {'name':'Lsgogroup','Age':27}print('Age 值为：%s'% dic.get('Age'))print('Sex 值为：%s'% dic.get('Sex','NA'))print(dic)

Age 值为：27Sex 值为：NA{'name': 'Lsgogroup', 'Age': 27}

dict.setdefault(key,default = None),与get方法类似，如果键不在字典中，则添加键并将值设为默认值

dic = {'name':'Lsgogroup','Age':7}print('Age 键的值为：%s' % dic.setdefault('Age',None))print('Sex 键的值为：%s' % dic.setdefault('Sex',None))print(dic)

Age 键的值为：7Sex 键的值为：None{'name': 'Lsgogroup', 'Age': 7, 'Sex': None}

dict.pop(key,default)删除字典给定键key所对应的值，返回值为被删除的值，key值必须给出，若key不存在，则返回default值。del dict[key] 删除字典给定键key所对应的值

dic1 = {1:'a',2:{1,2}}print(dic1.pop(1),dic1)print(dic1.pop(3,'nokey'),dic1)del dic1[2]print(dic1)

a {2: {1, 2}}nokey {2: {1, 2}}{}

dict.popitem()随机返回并删除字典中的一对键和值

dic1 = {1:'a',2:[1,2]}print(dic1.popitem())print(dic1)

(2, [1, 2]){1: 'a'}

dict.clear()用于删除字典内所有元素

dic = {'name':'Zara','Age':7}print("字典长度：%d" % len(dic))dic.clear()print("字典删除后的长度：%d" % len(dic))

字典长度：2字典删除后的长度：0

集合1. 集合的创建先创建对象再加入元素创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典

basket = set()basket.add('apple')basket.add('banana')print(basket)

{'banana', 'apple'}

集合会自动过滤重复元素

使用set()函数将列表或元组转换成集合

a = set('abracadabra')print(a)b = set(('Google','Lsgogroup','Taobao','Taobao'))print(b)

{'a', 'r', 'b', 'c', 'd'}{'Google', 'Lsgogroup', 'Taobao'}

访问集合中的值

s = set(['Google','BaIDu','Taobao'])for item in s:    print(item)

GoogleBaIDuTaobao

3. 集合内置方法set.add(elmnt)用于给集合添加元素。

fruits = {'apple','banana','cherry'}fruits.add('orange')print(fruits)fruits.add('apple')print(fruits)

{'banana', 'cherry', 'orange', 'apple'}{'banana', 'cherry', 'orange', 'apple'}

set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

x = {'apple','banana','cherry'}y = {'Google','baIDu','apple'}x.update(y)print(x)y.update(['lsgo','dreamtech'])print(y)

{'banana', 'apple', 'baIDu', 'cherry', 'Google'}{'apple', 'baIDu', 'Google', 'dreamtech', 'lsgo'}

set.remove(item)用于移除集合中的指定元素，如果元素不存在，则会发生错误

fruits = {'apple','banana','cherry'}fruits.remove('banana')print(fruits)

{'cherry', 'apple'}

set.discard(value)用于移除指定的集合元素，元素不存在不会发生错误。

fruits = {'apple','banana','cherry'}fruits.discard('banana')print(fruits)

{'cherry', 'apple'}

set.pop()用于随机移除一个元素

fruits = {'apple','banana','cherry'}x = fruits.pop()print(fruits)print(x)

{'cherry', 'apple'}banana

#set.intersection(set1,set2)返回两个集合的交集#set1 & set2 返回两个集合的交集#set.intersection_update(set1,set2)交集，在原始的集合上移除不重叠的元素a = set('abracadabra')b = set('alacazam')print(a)print(b)c = a.intersection(b)print(c)print(a&b)print(a)a.intersection_update(b)print(a)print('*'*80)#set.union(set1,set2)返回两个集合的并集#set1 | set2 返回两个集合的并集a = set('abracadabra')b = set('alacazam')print(a)print(b)print(a | b)print(a.union(b))print('*'*80)#set.difference(set)返回集合的差集#set1 - set2 返回集合的差集#set.difference_update(set)集合的差集，直接在原集合中移除元素，没有返回值a = set('abracadabra')b = set('alacazam')print(a)print(b)c  = a.difference(b)print(c)print(a-b)print(a)a.difference_update(b)print(a)print('*'*80)#set.symmetric_difference(set)返回集合的异或。#set1 ^ set2 返回集合的异或#set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。a = set('abracadabra')b = set('alacazam')print(a)  # {'r', 'a', 'c', 'b', 'd'}print(b)  # {'c', 'a', 'l', 'm', 'z'}c = a.symmetric_difference(b)print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}print(a)  # {'r', 'd', 'c', 'a', 'b'}a.symmetric_difference_update(b)print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}

{'a', 'r', 'b', 'c', 'd'}{'a', 'm', 'z', 'l', 'c'}{'a', 'c'}{'a', 'c'}{'a', 'r', 'b', 'c', 'd'}{'a', 'c'}********************************************************************************{'a', 'r', 'b', 'c', 'd'}{'a', 'm', 'z', 'l', 'c'}{'a', 'm', 'z', 'l', 'r', 'b', 'c', 'd'}{'a', 'm', 'z', 'l', 'r', 'b', 'c', 'd'}********************************************************************************{'a', 'r', 'b', 'c', 'd'}{'a', 'm', 'z', 'l', 'c'}{'d', 'r', 'b'}{'d', 'r', 'b'}{'a', 'r', 'b', 'c', 'd'}{'r', 'b', 'd'}********************************************************************************{'a', 'r', 'b', 'c', 'd'}{'a', 'm', 'z', 'l', 'c'}{'m', 'z', 'l', 'd', 'r', 'b'}{'m', 'z', 'l', 'd', 'r', 'b'}{'a', 'r', 'b', 'c', 'd'}{'m', 'z', 'l', 'r', 'b', 'd'}

4. 集合的转换

se = set(range(4))li = List(se)tu = tuple(se)print(se,type(se))print(li,type(li))print(tu,type(tu))

{0, 1, 2, 3} <class 'set'>[0, 1, 2, 3] <class 'List'>(0, 1, 2, 3) <class 'tuple'>

序列1. 针对序列的内置函数reversed(seq)函数返回一个反转的迭代器

s = 'lsgogroup'x = reversed(s)print(type(x))  # <class 'reversed'>print(x)  # <reversed object at 0x000002507E8EC2C8>print(List(x))# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')print(List(reversed(t)))# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']r = range(5, 9)print(List(reversed(r)))# [8, 7, 6, 5]x = [-8, 99, 3, 7, 83]print(List(reversed(x)))# [83, 7, 3, 99, -8]

<class 'reversed'><reversed object at 0x000002529EC08880>['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l'][8, 7, 6, 5][83, 7, 3, 99, -8]

enumerate(sequence,start) 用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。

seasons = ['Spring','Summer','Fall','Winter']a = List(enumerate(seasons))print(a)b = List(enumerate(seasons,1))print(b)for i,element in a:    print('{0},{1}'.format(i,element))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')][(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]0,Spring1,Summer2,Fall3,Winter

zip(iter1,iter2,...)用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由元组组成的对象，节省内存。我们使用List()转换来输出列表如果各个迭代器对象个数不一致，则返回列表长度与最短对象相同，利用*号 *** 作符，可以将元组解压成列表

a = [1,2,3]b = [4,5,6]c = [4,5,6,7,8]zippd = zip(a,b)print(zippd)print(List(zippd))zippd = zip(a,c)print(List(zippd))a1,a2 = zip(*zip(a,b))print(List(a1))print(List(a2))

<zip object at 0x000002529E144880>[(1, 4), (2, 5), (3, 6)][(1, 4), (2, 5), (3, 6)][1, 2, 3][4, 5, 6]

总结

以上是内存溢出为你收集整理的天池Python训练营笔记—Python基础：数据结构大汇总全部内容，希望文章能够帮你解决天池Python训练营笔记—Python基础：数据结构大汇总所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。