Python容器:数据的组织管理

在Python中，“容器”（Container）是一个广泛的概念，指的是那些可以包含其他对象的对象。容器通常用于组织、管理和存储数据。Python中有多种容器类型，主要分为两大类：序列类型（如列表、元组、字符串）和集合类型（如集合、字典）。

序列类型（Sequence Types）

序列类型的数据可以包含多个项目，这些项目按一定的顺序排列，可以通过索引（或键）来访问。Python中常见的序列类型包括：

1. 列表（List）：是最常用的Python容器之一，用于存储一系列有序的项目。列表是可变的，即可以在运行时添加、删除或修改其中的元素。
2. 元组（Tuple）：与列表相似，但元组是不可变的，一旦创建就不能修改其内容（虽然可以包含可变类型的元素，如列表）。元组通常用于存储不需要修改的数据，例如函数的返回值。
3. 字符串（String）：在Python中，字符串也被视为序列类型，因为它们是由字符组成的序列。虽然字符串是不可变的，但可以对它们执行各种操作，如切片、拼接和搜索。

集合类型（Set Types）

集合类型用于存储不重复的元素集合，它们不提供元素的索引或键。Python中的集合类型主要有：

1. 集合（Set）：是一个无序的、不包含重复元素的容器。集合主要用于数学上的集合操作，如并集、交集、差集和对称差集。
2. 字典（Dictionary）：字典是一种可变的容器模型，可以存储任意类型对象。与其他容器不同，字典的每个元素都是一个键值对（key-value pair）。键必须是唯一的，而值则不必。字典在内部是通过哈希表实现的，因此可以非常快速地执行查找、插入和删除操作。

容器的共同特性

虽然各种容器类型在功能和用法上有所不同，但它们通常都具备以下一些共同特性：

• 迭代：几乎所有的容器类型都支持迭代操作，即可以使用循环遍历容器中的元素。
• 嵌套：容器可以嵌套使用，例如列表可以包含其他列表，字典的值可以是列表等。
• 长度：可以使用内置的len()函数来获取大多数容器类型的长度（即元素的数量）。
• 内置方法：每种容器类型都提供了一系列内置的方法来执行常见的操作，如添加、删除和修改元素。

了解和掌握Python中的各种容器类型及其特性，对于编写高效、可读的Python代码至关重要。当然可以，以下是对Python中主要容器类型（列表、元组、字符串、集合、字典）的逐一介绍，并附上相应的代码示例。

1. 列表（List）

列表是Python中最常用的数据结构之一，它是一个有序的数据集合，可以包含多个元素，元素之间用逗号分隔，并且可以被修改（即列表是可变的）。

代码示例：

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""
# 定义一个列表 list
my_list = ["leon", "dog", "python"]
print(my_list)
print(type(my_list))

my_list = ["leon", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[0][1])

常用操作

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
10	len(列表)	统计容器内有多少元素

"""
演示数据容器之：list列表的常用操作
"""
mylist = ["dog", "leon", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("leon")
print(f"leon在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "派生到家"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("添砖加瓦")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["dog", "leon", "python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["dog", "leon", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["dog", "leon", "dog", "leon", "python"]
mylist.remove("leon")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["dog", "leon", "dog", "leon", "python"]
count = mylist.count("leon")
print(f"列表中leon的数量是：{count}")

# 10. 统计列表中全部的元素数量
mylist = ["dog", "leon", "dog", "leon", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

遍历

"""
演示使用while和for循环遍历列表
"""


def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["派生到家", "添砖加瓦", "Python"]
    # 循环控制变量：通过下标索引来控制，默认是0
    # 每一次循环，将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量，用来标记列表的下标
    index = 0       # 初始下标为0
    while index < len(mylist):
        # 通过index变量取出对应下标的元素
        element = mylist[index]
        print(f"列表的元素：{element}")

        # 至关重要：将循环变量（index）每一次循环都+1
        index += 1


def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{element}")


if __name__ == '__main__':
    # list_while_func()
    list_for_func()

特点

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个）

• 可以容纳不同类型的元素（混装）

• 数据是有序存储的（有下标序号）

• 允许重复数据存在

• 可以修改（增加或删除元素等）

2. 元组（Tuple）

元组与列表类似，但它是不可变的。一旦创建了元组，就不能更改其元素（虽然元组可以包含可变类型的元素，如列表，但这些内部列表的元素是可以修改的）。

常用操作

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

代码示例：

"""
演示tuple元组的定义和操作
"""

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")

# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index查找方法
t6 = ("派生到家", "添砖加瓦", "Python")
index = t6.index("添砖加瓦")
print(f"在元组t6中查找添砖加瓦，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("派生到家", "添砖加瓦", "添砖加瓦", "添砖加瓦", "Python")
num = t7.count("添砖加瓦")
print(f"在元组t7中统计添砖加瓦的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("派生到家", "添砖加瓦", "添砖加瓦", "添砖加瓦", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")

# 修改元组内容
# t8[0] = "dog"

# 定义一个元组
t9 = (1, 2, ["leon", "dog"])
print(f"t9的内容是：{t9}")
t9[2][0] = "添砖加瓦"
t9[2][1] = "派生到家"
print(f"t9的内容是：{t9}")

特点

• 可以容纳多个数据

• 可以容纳不同类型的数据（混装）

• 数据是有序存储的（下标索引）

• 允许重复数据存在

• 不可以修改（增加或删除元素等）

• 支持for循环

3. 字符串（String）

字符串是Python中的基本数据类型之一，用于表示文本数据。字符串是不可变的，但可以执行各种操作，如切片、拼接、搜索等。

代码示例：

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "leon and dog"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

# my_str[2] = "H"

# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

# replace方法
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")

# split方法
my_str = "hello python leon dog"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# strip方法
my_str = "  leon and dog  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12leon and dog21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某字符串的出现次数, count
my_str = "leon and dog"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

常用操作

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

特点

• 只可以存储字符串

• 长度任意（取决于内存大小）

• 支持下标索引

• 允许重复字符串存在

• 不可以修改（增加或删除元素等）

• 支持for循环

序列切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

•起始下标表示从何处开始，可以留空，留空视作从头开始

•结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

•步长表示，依次取元素的间隔

•步长1表示，一个个取元素

•步长2表示，每次跳过1个元素取

•步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

代码示例

"""
演示对序列进行切片操作
"""

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")


# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")


# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")


# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

4. 集合（Set）

集合是一个无序的、不包含重复元素的容器。集合主要用于数学上的集合操作，如并集、交集、差集和对称差集。

代码示例：

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"派生到家", "添砖加瓦", "leon", "派生到家", "添砖加瓦", "leon", "派生到家", "添砖加瓦", "leon"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("Python")
my_set.add("派生到家")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("添砖加瓦")
print(f"my_set移除添砖加瓦后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"派生到家", "添砖加瓦", "leon"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

常用操作

c****编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

特点

• 可以容纳多个数据

• 可以容纳不同类型的数据（混装）

• 数据是无序存储的（不支持下标索引）

• 不允许重复数据存在

• 可以修改（增加或删除元素等）

• 支持for循环

5. 字典（Dictionary）

字典是Python中一种可变容器模型，可以存储任意类型对象。字典的每个元素都是一个键值对（key-value pair），其中键（key）必须是唯一的，而值（value）则不必。字典在内部是通过哈希表实现的，因此可以非常快速地执行查找、插入和删除操作。

代码示例：

"""
演示数据容器字典的定义
"""

# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")

# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")

# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")

常用操作

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

容器对比

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key：Value Key：除字典外任意类型 Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以Key检索Value的数据记录场景

容器通用功能

功能	描述
通用for循环	遍历容器（字典是遍历key）
max	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse=True])	排序，reverse=True表示降序 得到一个排好序的列表