欢迎大家订阅【Python从入门到精通】专栏，一起探索Python的无限可能！

---

前言

Python 作为一种高级编程语言，内置了多种强大的数据容器，帮助开发者以更加直观和灵活的方式处理复杂的数据结构。常见的 Python 数据容器包括列表（List）、元组（Tuple）、字典（Dict）和集合（Set）。每种容器都有其独特的特性和适用场景，适合存储不同类型的数据。

---

本篇文章参考：黑马程序员

一、数据容器对比

在前面章节的学习中，我们深入了解了列表（List）、元组（Tuple）、字典（Dict）和集合（Set）这五类数据容器的特点及其应用场景。
数据容器特点对比：

二、数据容器的通用操作

数据容器通用功能：

①遍历：
五类数据容器都支持for循环遍历。
基本语法：
for 临时变量 in 数据容器:
  对临时变量进行处理

列表、元组、字符串支持while循环，集合、字典不支持while循环（因为无法下标索引）。

②统计数据容器的元素总数：
统计数据容器中全部元素的数量
语法：len(数据容器)

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)}")

输出结果：
列表的元素个数：5
元组的元素个数：5
字符串的元素个数：7
集合的元素个数：5
字典的元素个数：5

③统计数据容器的最大元素：
语法：max(数据容器)

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}

# 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)}")

输出结果：
列表最大的元素：5
元组最大的元素：5
字符串最大的元素：g
集合最大的元素：5
字典最大的元素：key5

④统计数据容器的最小元素：
语法：min(数据容器)

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}

# 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)}")

输出结果：
列表最小的元素：1
元组最小的元素：1
字符串最小的元素：a
集合最小的元素：1
字典最小的元素：key1

⑤排序：
方式一：正向排序
语法：sorted(容器)
注意：排序后得到的对象为列表类型。

# 进行容器的排序
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 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)}")#将字典的value统统抛弃，只保留key

输出结果：
列表对象的排序结果：[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’]

方式二：反向排序
语法：sorted(容器, [reverse=True])
注意：排序后得到的对象为列表类型。

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

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)}")

输出结果：
列表对象的反向排序结果：[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’]

⑥类型转换：
list(容器)：将给定容器转换为列表
tuple(容器)：将给定容器转换为元组
str(容器)：将给定容器转换为字符串
set(容器)：将给定容器转换为集合

# 类型转换: 容器转列表
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)}")   #将字典的value统统抛弃，只保留key

输出结果：
列表转列表的结果：[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’]

# 类型转换: 容器转元组
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)}")   #将字典的value统统抛弃，只保留key

输出结果：
列表转元组的结果：(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’)

# 类型转换: 容器转字符串
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)
字符串转字符串结果是：abcdefg
集合转字符串的结果是：{1, 2, 3, 4, 5}
字典转字符串的结果是：{‘key1’: 1, ‘key2’: 2, ‘key3’: 3, ‘key4’: 4, ‘key5’: 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)}")   #将字典的value统统抛弃，只保留key

输出结果：
列表转集合的结果：{1, 2, 3, 4, 5}
元组转集合的结果：{1, 2, 3, 4, 5}
字符串转集合结果：{‘a’, ‘e’, ‘c’, ‘g’, ‘f’, ‘d’, ‘b’}
集合转集合的结果：{1, 2, 3, 4, 5}
字典转集合的结果：{‘key1’, ‘key2’, ‘key4’, ‘key3’, ‘key5’}

【拓展】字符串大小比较

在程序中，字符串所用的所有字符，如大小写英文单词、数字、特殊符号(!、\、|、@、#、空格等）都有其对应的ASCII码表值，即每一个字符都能对应上一个数字的码值。

比较规则：

• 字符比较：
  基于数字的码值大小进行比较
• 字符串比较：
  从字符串的第一个字符开始逐一比较，直到找到不同的字符为止。如果某个字符串在比较中到达了结束而另一个字符串还有剩余字符，则较长的字符串被认为大于较短的字符串。
  
  【分析】字符串"abc"与字符串"abd"进行比较：
  先比较 “abc” 的第一个字符 ‘a’ 和 “abd” 的第一个字符 ‘a’，‘a’ 等于 ‘a’，继续比较下一个字符；
  比较 “abc” 的第二个字符 ‘b’ 和 “abd” 的第二个字符 ‘b’，‘b’ 等于 ‘b’，继续比较下一个字符；
  比较 “abc” 的第三个字符 ‘c’ 和 “abd” 的第三个字符 ‘d’，此时’c’ 和 ‘d’ 是不同的字符，根据ASCII码表，‘c’ 的编码值为 99，‘d’ 的编码值为 100，因此，‘c’ < ‘d’。
  综上所述，字符串"abc"小于字符串"abd"。
  
  【分析】字符串"a"与字符串"ab"进行比较：
  先比较 “a” 的第一个字符 ‘a’ 和 “ab” 的第一个字符 ‘a’，‘a’ 等于 ‘a’，继续比较下一个字符；
  对于字符串 “a”，已经没有更多的字符可以比较，因为它只有一个字符。而对于字符串 “ab”，第二个字符是 ‘b’。根据字符串比较的规则，字符串"a"小于字符串"ab"。

# abc比较abd
print(f"abd>abc:{"abd">"abc"}")
# a比较ab
print(f"ab>a:{"ab">"a"}")
# a比较A
print(f"a>A:{"a">"A"}")
# key1比较key2
print(f"Key2>key2:{"key2">"key1"}")

输出结果：
abd>abc:True
ab>a:True
a>A:True
Key2>key2:True