Python教程

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

本文主要是介绍天池Python训练营笔记—Python基础:数据结构大汇总,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

列表

简单数据类型:整型,浮点型和布尔型。

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

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]*5
print(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]*4
print(x,type(x))
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
x[0][0] = 1
print(x,type(x))
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
a = [0] * 3
x = [a] * 4
print(x,type(x))
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
x[0][0] = 1
print(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+list2
print(list4)

list5 = list3*3
print(list5)

print(123 in list3)
print(456 not in list3)
False
True
[123, 456, 456, 123]
[123, 456, 123, 456, 123, 456]
True
False

7. 列表的其它方法

  • list.count(obj)统计某个元素在列表中出现的次数
list1 = [123,456]*3
print(list1)
num = list1.count(123)
print(num)
[123, 456, 123, 456, 123, 456]
3
  • list.index(x,start,end)从列表中找出某个值第一个匹配项的索引位置
list1 = [123,456] * 5
print(list1.index(123))
print(list1.index(123,1))
print(list1.index(123,3,7))
0
2
4
  • 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 = tup
print(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 + t2
print(t4)

4. 内置方法

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

5. 解压元组

#解压一维元组
t = (1,10.31,'python')
(a,b,c) = t
print(a,b,c)

#解压二维元组
t = (1,10.31,('OK','python'))
(a,b,(c,d)) = t
print(a,b,c,d)

#通配符提取你想要的变量
t = 1,2,3,4,5
a,b,*rest,c = t
print(a,b,c)
print(rest)

#不需要变量名就用*加上下划线代替
t = 1,2,3,4,5
a,b,*_ = t
print(a,b)
1 10.31 python
1 10.31 OK python
1 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 go
let's go
C:\now
C:\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 love
e
I love插入的字符串 LsgoGroup

3. 字符串的常用内置方法

  • capitalize() 将字符串的第一个字符转换为大写
str2 = 'xiaoxie'
print(str2.capitalize())
Xiaoxie
  • lower() 转换字符串中所有大写字符为小写
  • upper() 转换字符串中的小写字母为大写
  • swapcase() 将字符串中大写转换为小写,小写转换为大写
str2 = 'DAXIExiaoxie'
print(str2.lower())
print(str2.upper())
print(str2.swapcase())
daxiexiaoxie
DAXIEXIAOXIE
daxieXIAOXIE
  • 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
-1
9
  • isnumeric()如果字符串只包含数字字符,则返回True,否则返回False
str3 = '12345'
print(str3.isnumeric())
str3 += 'a'
print(str3.isnumeric())
True
False
  • ljust(width,fillchar)返回原字符串的左对齐,并使用fillchar(默认空格填充至长度width的新字符)
  • rjust(width,fillchar)返回原字符串的右对齐。
str4 = '1101'
print(str4.ljust(8,'0'))
print(str4.rjust(8,'0'))
11010000
00001101
  • 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 LsgoGroup
I love LsgoGroup
I 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 Lsgogroup
I Love Lsgogroup
I Love Lsgogroup
27.66GB
  • Python字符串格式化符号

  • 格式化操作符辅助指令

字典

1.可变类型与不可变类型

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

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

  • 麻烦:用id(X)函数,比较操作前后的id,如果不一样就是不可变类型,如果一样就是可变类型。
  • 便捷:用hash(X),只要不报错,证明X可被哈希,就是不可变类型,反之为可变类型。
i = 1
print(id(i))
i += 2
print(id(i))

l = [1,2]
print(id(l))
l.append('Python')
print(id(l))
140726725256992
140726725257056
2553863469376
2553863469376
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 it
Nike 的口号是: 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 值为:27
Sex 值为: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 键的值为:7
Sex 键的值为: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)
Google
Baidu
Taobao

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,Spring
1,Summer
2,Fall
3,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基础:数据结构大汇总的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!