Python3 基本数据结构总结

你的名字 2023-10-11 10:13 16阅读 0赞

# 简介 #

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'}

以下内容整理自[菜鸟教程][Link 1]。

# 列表 #

列表是最常用的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)                              #<class 'int'>
    tup5 = (50,)                             #<class 'tuple'>

## 元组增删改查 ##

元组不能修改和增加，元组的访问与列表相同，元组同样可以使用`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()	                  #给集合添加元素

[Link 1]: https://www.runoob.com/python3/python3-list.html