关于Python中常用的数据结构：列表、元组、字典、集合之间的类型区分

目录

一、列表（List）

二、元组（Tuple）

三、字典（Dictionary）

四、集合（Set）

五、相互转换

六、使用场合及选择

列表（List）

元组（Tuple）

字典（Dictionary）

集合（Set）

七、实际应用场景示例

---

一、列表（List）

定义：用方括号 [] 定义，元素之间用逗号分隔。

特点：

• 有序：元素有固定的顺序。
• 可变：可以修改、添加或删除元素。
• 支持重复元素：允许相同的值出现多次
• 列表中元素的值可以是列表，称为二级列表（二维列表）或者多维列表

操作：

• 访问元素：使用索引，例如 list[0]。
• 修改元素：例如 list[0] = new_value。
• 添加元素：使用 append()、extend()、insert() 方法。
• 删除元素：使用 remove()、pop()、del 语句

#代码示例
my_list = [1, 2, 3, 4]#定义列表
my_list.append(5)#元素添加
print(my_list)  # 输出: [1, 2, 3, 4, 5]

print("*" * 20, "分隔符", "*" * 20)
my_list[0]#元素访问


varlist=[1,2,3,[11,22,33],'a','b','c']#定义多维列表

二、元组（Tuple）

• 定义：用圆括号()定义，元素之间用逗号分隔。
• 特点：
  • 有序：元素有固定的顺序。
  • 不可变：一旦创建，无法修改元素。
  • 支持重复元素：允许相同的值出现多次。
• 操作：
  • 访问元素：使用索引，例如 tuple[0]。
  • 元素无法修改，但可以包含可变对象。
  • 可以连接和重复：使用 + 和 * 操作符。

#代码示例
my_tuple = (1, 2, 3, 4)#元组定义
print(my_tuple[0])  # 关于在自定义的元组中访问有关位置，输出: 1


vart=('abc');#此时打印的类型为字符型
 
vart=(123);#此时打印的类型为int类型
 
vart=(123,)#加上一个逗号之后就会变成元组类型，因此在定义元组时，如果元组中只有一个元素，那么需要加“,”，否则就不是元组类型了

varl=[1,2,3]
 
varl[2]=33
 
#通过下标来修改元素的值
 
art=(1,2,3)
 
vart[2]=33#修改元组类型的值会报错，元组的值不能被改变
 
print(vart)

三、字典（Dictionary）

• 定义：用花括号 {} 定义，键值对之间用逗号分隔，键和值之间用冒号分隔。
• 特点：
  • 无序：元素没有固定的顺序（Python 3.7+ 保持插入顺序）。
  • 可变：可以修改、添加或删除键值对。
  • 键唯一：键必须是唯一的，值可以重复。
  • 键必须是不可变对象：如字符串、数字或元组。
• 操作：
  • 访问值：使用键，例如 dict[key]。
  • 修改值：例如 dict[key] = new_value。
  • 添加键值对：直接赋值，例如 dict[new_key] = value。
  • 删除键值对：使用 del 语句或 pop() 方法。

#代码示例
my_dict = {'a': 1, 'b': 2, 'c': 3}#字典定义
my_dict['d'] = 4#为字典添加新元素
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

四、集合（Set）

• 定义：用花括号 {} 定义，元素之间用逗号分隔，或者使用 set() 函数创建。
• 特点：
  • 无序：元素没有固定的顺序。
  • 可变：可以添加或删除元素，但集合本身是不可变对象。
  • 不支持重复元素：每个元素必须是唯一的,故此利用该种特性在某种情况下，如果需要将列表中的重复元素进行剔除时，可以先转化为为集合，然后回转为列表类型。
  • 元素必须是不可变对象：如字符串、数字或元组。
• 操作：
  • 添加元素：使用 add() 方法。
  • 删除元素：使用 remove() 或 discard() 方法。
  • 集合运算：如并集 |、交集 &、差集 -、对称差集 ^。

#代码示例
my_set = {1, 2, 3, 4}#集合定义
my_set.add(5)#集合元素添加
print(my_set)  # 输出: {1, 2, 3, 4, 5}


#无法获取集合中的单个元素，但是可以添加和删除 
a.discard('a') #删除元素
print(a) 

#集合主要用于运算，交集，差集，并集，对称集合 ，此处的集合可以简单理解为数学中的集合概念
a = {1,2,3,'a','b'} 
 
b = {1,'a',22,33} 
 
print(a & b) # 交集 {1, 'a'} 
 
print(a - b) # 差集 {'b', 2, 3} a 集合有，b集合没有的 
 
print(a | b) # 并集 {1, 2, 3, 33, 'a', 'b', 22} 两个集合，放到一起，并且去重 
 
print(a ^ b) # 对称差集 {33, 2, 3, 'b', 22} 将两个集合中都重复的去掉，把剩下的元素取出来

 

五、相互转换

1、列表转元组：tuple(list)

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(type(my_tuple))  # <class 'tuple'>

2、元组转转：list(tuple)

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(type(my_list))  # <class 'list'>

3、列表转集合：set(list)

my_list = [1, 2, 3, 1]
my_set = set(my_list)  # 输出: {1, 2, 3}

4、集合转列表：list(set)

my_set = {1, 2, 3}
my_list = list(my_set)
print(type(my_list))  # <class 'list'>

5、字典的键/值转列表：list(dict.keys()) 或 list(dict.values())

my_dict = {'a': 1, 'b': 2}
keys_list = list(my_dict.keys())
values_list = list(my_dict.values())

6、列表转字典（需符合字典格式）：dict(list_of_tuples) 

my_list = [('a', 1), ('b', 2)]
my_dict = dict(my_list)

六、使用场合及选择

列表（List）

• 使用场合：
  • 存储有序的数据。
  • 需要频繁修改数据。
  • 处理相同类型的数据。
  • 迭代和批处理。
• 选择：
  • 数据有顺序且需要修改时。
  • 需要进行增删操作时。

元组（Tuple）

• 使用场合：
  • 存储有序且不可变的数据。
  • 存储一组相关的数据，且数据类型不同。
  • 作为字典的键或集合的元素。
• 选择：
  • 数据有顺序但不需要修改时。
  • 需要保证数据不被修改时。

字典（Dictionary）

• 使用场合：
  • 需要存储键值对数据。
  • 快速查找、添加、删除数据。
  • 需要通过键快速访问数据。
• 选择：
  • 数据以键值对形式存在时。
  • 需要快速查找、插入和删除时。

集合（Set）

• 使用场合：
  • 需要存储唯一的元素。
  • 集合运算（并集、交集、差集）。
  • 快速检查元素是否存在。
• 选择：
  • 数据需要唯一性时。
  • 需要进行集合运算时。

七、实际应用场景示例

• 列表：

  • 存储学生的成绩、购物清单等有序数据。
  • 需要动态增删改的任务列表。

• 元组：

  • 存储地理坐标（纬度、经度），确保其不被修改。
  • 作为函数的返回值传递多个相关但不同类型的数据。

• 字典：

  • 存储联系人信息，键为姓名，值为电话号码。
  • 存储配置项，键为配置名称，值为配置值。

• 集合：

  • 存储唯一的标识符，如用户ID集合。
  • 快速去重，如从一个列表中去除重复元素。

       综上所述，这四种数据结构各有优缺点，选择时应根据具体需求来决定。列表适合存储有序且可变的数据，元组适合存储有序且不可变的数据，字典适合存储键值对数据，集合适合存储无序且唯一的数据。每种数据结构都有其独特的优势和适用场景，选择合适的数据结构可以提高程序的效率和可读性。