【Python基础】Python数据容器（总结）

类数据容器的总结对比

数据容器分类

数据容器可以从以下视角进行简单分类：

• 是否支持下标索引：

  • 支持：列表、元组、字符串 ——序列类型
  • 不支持：集合、字典 ——非序列类型

• 是否支持重复元素：

  • 支持：列表、元组、字符串 ——序列类型
  • 不支持：集合、字典 ——非序列类型

• 是否可以修改：

  • 支持：列表、集合、字典 ——序列类型
  • 不支持：元组、字符串 ——非序列类型

基于各类数据容器的特点，它们的应用场景如下：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，用Key检索Value的存储场景

数据容器的通用操作

遍历

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

尽管遍历的形式各有不同，但是，它们都支持遍历操作

统计功能

快捷按键：按住shift+alt+拖动鼠标

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len元素个数统计
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串 元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

print()
# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是有：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")

print()
# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是有：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")

运行效果：
列表 元素个数有：5
元组 元素个数有：5
字符串 元素个数有：7
集合 元素个数有：5
字典 元素个数有：5

列表 最大的元素是：5
元组 最大的元素是：5
字符串最大的元素是有：g
集合 最大的元素是：5
字典 最大的元素是：key5

列表 最小的元素是：1
元组 最小的元素是：1
字符串最小的元素是有：a
集合 最小的元素是：1
字典 最小的元素是：key1

容器的通用转换功能

# 类型转换：容器转元组
print(f"列表 转列表，结果是：{list(my_list)}")
print(f"元组 转列表，结果是：{list(my_tuple)}")
print(f"字符串 转列表，结果是：{list(my_str)}")
print(f"集合 转列表，结果是：{list(my_set)}")
print(f"字典 转列表，结果是：{list(my_dict)}")

# 类型转换：容器转元组
print(f"列表 转元组，结果是：{tuple(my_list)}")
print(f"元组 转元组，结果是：{tuple(my_tuple)}")
print(f"字符串 转元组，结果是：{tuple(my_str)}")
print(f"集合 转元组，结果是：{tuple(my_set)}")
print(f"字典 转元组，结果是：{tuple(my_dict)}")

print()
# 类型转换：容器转字符串
print(f"列表 转字符串，结果是：{str(my_list)}")
print(f"元组 转字符串，结果是：{str(my_tuple)}")
print(f"字符串 字符串表，结果是：{str(my_str)}")
print(f"集合 转字符串，结果是：{str(my_set)}")
print(f"字典 转字符串，结果是：{str(my_dict)}")
# 列表 转字符串，结果是：[1, 2, 3, 4, 5]     代码中的本体："[1, 2, 3, 4, 5]"
# 元组 转字符串，结果是：(1, 2, 3, 4, 5)     代码中的本体："(1, 2, 3, 4, 5)"

# 类型转换：容器转集合
print(f"列表 转集合，结果是：{set(my_list)}")
print(f"元组 转集合，结果是：{set(my_tuple)}")
print(f"字符串 转集合，结果是：{set(my_str)}")
print(f"集合 转集合，结果是：{set(my_set)}")
print(f"字典 转集合，结果是：{set(my_dict)}")

dict()
# 有转换成字典的函数dict(),但由于他需要 键值对 才能对应，
# 而我们无法凭空变出Value，所以如果试图转换是会报错的
# 但是，字典是可以转换成别的元素的  【过程中，存在丢失Value的问题】
# 仅有转成字符串 Value会保存 ，，转成其他 value都会丢失

运行效果：
列表 转列表，结果是：[1, 2, 3, 4, 5]
元组 转列表，结果是：[1, 2, 3, 4, 5]
字符串 转列表，结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合 转列表，结果是：[1, 2, 3, 4, 5]
字典 转列表，结果是：['key1', 'key2', 'key3', 'key4', 'key5']
列表 转元组，结果是：(1, 2, 3, 4, 5)
元组 转元组，结果是：(1, 2, 3, 4, 5)
字符串 转元组，结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
集合 转元组，结果是：(1, 2, 3, 4, 5)
字典 转元组，结果是：('key1', 'key2', 'key3', 'key4', 'key5')

列表 转字符串，结果是：[1, 2, 3, 4, 5]
元组 转字符串，结果是：(1, 2, 3, 4, 5)
字符串 字符串表，结果是：abcdefg
集合 转字符串，结果是：{1, 2, 3, 4, 5}
字典 转字符串，结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
列表 转集合，结果是：{1, 2, 3, 4, 5}
元组 转集合，结果是：{1, 2, 3, 4, 5}
字符串 转集合，结果是：{'c', 'b', 'a', 'd', 'f', 'g', 'e'}
集合 转集合，结果是：{1, 2, 3, 4, 5}
字典 转集合，结果是：{'key2', 'key4', 'key5', 'key1', 'key3'}

通用排序功能

语法：sorted(容器,[reverse = True])

说明：第一个参数是被排序的容器，第二个参数是一个有默认值的参数reverse，默认等于false [[[[ 如果想让容器的排序结果进行反转，可以传入Ture

False：从小到大排序

True：从大到小排序

# sorted排序
my_list = [3, 1, 2, 4, 5]
my_tuple = (3, 1, 2, 4, 5)
my_str = "bcadefg"
my_set = {3, 1, 2, 4, 5}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key4": 4, "key5": 5}

# 正向排序
print(f"列表 排序是：{sorted(my_list)}")
print(f"元组 排序是：{sorted(my_tuple)}")
print(f"字符串排序是：{sorted(my_str)}")
print(f"集合 排序是：{sorted(my_set)}")
print(f"字典 排序是：{sorted(my_dict)}")
# 反向排序
print(f"列表 反向排序是：{sorted(my_list, reverse = True)}")
print(f"元组 反向排序是：{sorted(my_tuple, reverse = True)}")
print(f"字符串反向排序是：{sorted(my_str, reverse = True)}")
print(f"集合 反向排序是：{sorted(my_set, reverse = True)}")
print(f"字典 反向排序是：{sorted(my_dict, reverse = True)}")

运行效果：
列表 排序是：[1, 2, 3, 4, 5]
元组 排序是：[1, 2, 3, 4, 5]
字符串排序是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合 排序是：[1, 2, 3, 4, 5]
字典 排序是：['key1', 'key2', 'key3', 'key4', 'key5']
列表 反向排序是：[5, 4, 3, 2, 1]
元组 反向排序是：[5, 4, 3, 2, 1]
字符串反向排序是：['g', 'f', 'e', 'd', 'c', 'b', 'a']
集合 反向排序是：[5, 4, 3, 2, 1]
字典 反向排序是：['key5', 'key4', 'key3', 'key2', 'key1']