Python3 基本数据结构总结

简介

Python3基本数据结构有列表（list），元组（tuple），字典（dictionary）和集合（set）四种，结构如下：

list = ['Google', 'Runoob', 1997, 2000]
tup = ('Google', 'Runoob', 1997, 2000)
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
set = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

以下内容整理自菜鸟教程。

列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list = ['Google', 'Runoob', 1997, 2000]

列表索引从0开始。列表可以进行索引，切片，加，乘，检查成员等操作，此外，列表是支持添加，更新，删除等修改操作的。

列表增删改查

list = ['Google', 'Runoob', 1997, 2000]
print ("list[0]: ", list1[0])     				#下标索引访问
list[2] = 2001    								#列表修改
print ("修改后的第三个元素为 : ", list[2])
del list[2]       								#列表删除
print ("删除第三个元素 : ", list)

打印结果：

list[0]: Google
更新后的第三个元素为 : 2001
删除第三个元素 : [‘Google’, ‘Runoob’, 2000]

• 除了关键字del，列表的删除操作还可以使用列表方法中的list.pop([index=-1])或list.remove(obj)
• 列表的增加操作在列表方法中的list.append(obj)

列表截取与拼接

list = ['Google', 'Runoob', 1997, 2000]
list_add = ['baidu', 2001]
print ("list[1:3]: ", list2[1:3]) 				#截取1到3位
print ("list[-1]: ", list2[-1]) 				#截取倒数第二位 
print ("list[1:]: ", list2[1:]) 				#截取第一位到最后 
print ("list+list_add: ", list2[1:3]) 			#拼接

打印结果：

list[1:3]: [‘Runoob’, 1997, 2000]
list[-1] : 1997
list[1:] : [‘Runoob’, 1997, 2000]
list+list_add：[‘Google’, ‘Runoob’, 1997, 2000, ‘baidu’, 2001]

列表内置函数

len(list) #列表元素个数
max(list) #返回列表元素最大值
min(list) #返回列表元素最小值
list(seq) #将元组转换为列表

列表内置方法

list.append(obj)         #在列表末尾添加新的对象
list.count(obj)          #统计某个元素在列表中出现的次数
list.extend(seq)         #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)          #从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)  #将对象插入列表
list.pop([index=-1])     #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)         #移除列表中某个值的第一个匹配项
list.reverse()           #反向列表中元素
list.sort()              #对原列表进行排序
list.clear()             #清空列表
list.copy()              #复制列表

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改，所以元组是一种不可变容器。
元组使用小括号，列表使用方括号。

tup1 = ('Google', 'Runoob', 1997, 2000)  #元组
tup2 = "a", "b", "c", "d";               #不需要括号也可以
tup3 = ();                               #空元组
#元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
tup4 = (50)                              #
tup5 = (50,)                             #

元组增删改查

元组不能修改和增加，元组的访问与列表相同，元组同样可以使用del关键字，但是作用是删除整个元组。

tup = ('Google', 'Runoob', 1997, 2000) 
del tup;
print ("删除后的元组 tup : ")
print (tup)

打印结果：
删除后的元组 tup :
Traceback (most recent call last):
File “test.py”, line 8, in
print (tup)
NameError: name ‘tup’ is not defined

元组截取与拼接

与列表相同

元组内置函数

len(list) #元组元素个数
max(list) #返回元组元素最大值
min(list) #返回元组元素最小值
list(seq) #将列表转换为元组

字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 。
字典中键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

字典增删改查

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])      #需要按照键值访问
print ("dict['Alice']: ", dict['Alice'])    #如果用字典里没有的键访问数据，会出现KeyError: 'Alice'
dict['Age'] = 8                             # 修改键Age的值
del dict['Name']                            # 删除键 'Name'
dict.clear()                                # 清空字典
del dict                                    # 删除字典

字典内置函数

len(dict)      #计算字典元素个数，即键的总数
str(dict)      #输出字典，以可打印的字符串表示
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型

字典内置方法

radiansdict.clear()                      #删除字典内所有元素
radiansdict.copy()                       #返回一个字典的浅复制
radiansdict.fromkeys()                   #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)       #返回指定键的值，如果值不在字典中返回default值
key in dict                              #如果键在字典dict里返回true，否则返回false
radiansdict.items()                      #以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys()                       #返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)#和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)                #把字典dict2的键/值对更新到dict里
radiansdict.values()                     #返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default])                       #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()                                #随机返回并删除字典中的最后一对键和值。

集合

集合（set）是一个无序的不重复元素序列，集合是可变类型。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 集合的不重复性
{'orange', 'banana', 'pear', 'apple'}

集合增删改查

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket[1])             		# 错误，集合是无序的
'orange' in basket                  # 快速判断元素是否在集合内

由于集合的无序性，没有修改操作，集合的添加、删除操作使用集合内置方法完成。

集合间运算

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

集合内置方法

set.add()	                      #为集合添加元素
set.clear()	                      #移除集合中的所有元素
set.copy()	                      #拷贝一个集合
set.difference()	              #返回多个集合的差集
set.difference_update()	          #移除集合中的元素，该元素在指定的集合也存在。
set.discard()	                  #删除集合中指定的元素
set.intersection()	              #返回集合的交集
set.intersection_update()	      #返回集合的交集。
set.isdisjoint()	              #判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
set.issubset()	                  #判断指定集合是否为该方法参数集合的子集。
set.issuperset()	              #判断该方法的参数集合是否为指定集合的子集
set.pop()	                      #随机移除元素
set.remove()	                  #移除指定元素
set.symmetric_difference()	      #返回两个集合中不重复的元素集合。
set.symmetric_difference_update() #移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
set.union()	                      #返回两个集合的并集
set.update()	                  #给集合添加元素