51工具盒子容器提供了一组强大而灵活的工具，用于处理和操作数据集合。Python 中常用的容器包括列表(list)、元组(tuple)、字典(dict)、集合(set) ，这些容器中提供了添加、删除、访问和修改元素的功能，使得操作变得简单。
- List 容器 {#title-0} =====================
Python List 是一种动态数组，它是一种有序、可变、可重复的容器类型。list可以存储任意类型的元素，包括整数、浮点数、字符串、对象等。
- 有序性：
list中的元素按照它们的插入顺序排列，并且可以通过索引访问和操作特定位置的元素。 - 可变性：
list是可变的，意味着可以通过修改、添加或删除元素来改变列表的内容。 - 可重复性：
list允许存储重复的元素。 - 动态性：
list长度随着操作的进行而自动调整。
List 容器操作示例：
# 列表初始化
def demo00():
my_list = []
my_list = [10, 20]
my_list = list()
print(my_list)
# 1. 列添加元素
def demo01():
my_list = []
# 尾部添加
my_list.append(300)
# 指定位置添加
my_list.insert(1, 400)
# 将列表元素逐个添加
my_list.extend([10, 20])
print(my_list)
# 2. 列表删除元素
def demo02():
my_list = [100, 200, 300, 400, 500]
# 按值删除
my_list.remove(300)
# 按索引删除
my_list.pop()
my_list.pop(2)
print(my_list)
# 清空列表
my_list.clear()
print(my_list)
# 3. 列表修改元素
def demo03():
my_list = [100, 200, 300, 400, 500]
my_list[1] = 666
print(my_list)
# 4. 列表查询元素
def demo04():
my_list = [100, 200, 300, 400, 500]
result = my_list.index(200)
print(result)
# 5. 列表其他操作
def demo05():
my_list = [100, 200, 300, 400, 500]
# 列表长度
print(len(my_list))
# 元素排序
my_list.sort(reverse=True)
print(my_list)
# 统计元素数量
cnt = my_list.count(400)
print(cnt)
# 列表逆序
my_list.reverse()
print(my_list)
new_list = my_list.copy()
my_list[0] = 666
print(my_list, new_list)
# 6. 列表操作符
def test06():
# * 运算符
my_list = [10, 20] * 2
print(my_list)
# in 和 not in 运算符
print(10 in [10, 20])
print(10 not in [10, 20])
# + 运算符
my_list1 = [10, 20]
my_list2 = [30, 40]
print(my_list1 + my_list2)
# += 运算符
my_list1 = [10, 20]
my_list2 = [30, 40]
my_list1 += my_list2
print(my_list1)
- Tuple 容器 {#title-1} ======================
Python 中 的 tuple（元组）是一种有序、不可变的容器类型。与 list 相比，tuple 具有不可变性，这意味着一旦创建，就不能修改其内容。
- 有序性：
tuple中的元素按照它们的顺序排列，并且可以通过索引访问和操作特定位置的元素。 - 不可变性：
tuple是不可变的，意味着一旦创建，就不能修改其中的元素。无法添加、删除或修改元组的元素。 - 可哈希性：由于元组的不可变性，元组是可哈希的，可以作为字典的键值或集合的元素。
- 紧凑性：相对于
list，元组在内存中的占用空间较小。
Tuple 容器操作示例：
# 1. 元组初始化
def demo00():
my_tuple = ()
my_tuple = (10, 20)
my_tuple = tuple()
print(my_tuple)
# 2. 元组查询操作
def demo01():
my_tuple = (10, 20, 30, 40)
result = my_tuple.index(20)
print(result)
# 3. 元组其他操作
def demo02():
my_tuple = (10, 20, 30, 40)
cnt = my_tuple.count(30)
print(cnt)
# 3. 元组运算符操作
def demo03():
# * 运算符
my_tuple = (10, 20) * 2
print(my_tuple)
# + 运算符
my_tuple = (10, 20) + (30, 40)
print(my_tuple)
# in 和 not in 运算符
print(10 in my_tuple)
print(10 not in my_tuple)
# += 运算符
# 注意: my_tuple 会返回一个新的元组，并没有修改原来的元组
my_tuple += (10, 20)
print(my_tuple)
- Set 容器 {#title-2} ====================
Python中 set（集合）是一种无序且不重复的容器类型。set 是一种用于存储和操作独立元素集合的有用工具。集合具有如下特点：
- 无序性：
set中的元素没有定义的顺序，无法通过索引访问或修改元素。 - 唯一性：
set中的元素是唯一的，不允许重复的元素存在。重复的元素将被自动去重。 - 可变性：
set是可变的，可以通过添加或删除元素来改变集合的内容。 - 数学集合操作：
set支持常见的数学集合操作，如交集、并集、差集和对称差等。
Set 容器操作示例：
# 1. 集合初始化
def demo00():
my_set = set()
# 集合不允许重复元素
my_set = {10, 20, 20, 'a'}
print(my_set)
# 2. 集合添加操作
def demo01():
my_set = set()
# 添加一个元素
my_set.add(10)
my_set.add(10)
print(my_set)
# 添加一个集合
my_set.update({10, 'abc', 20})
print(my_set)
# 3. 集合删除操作
def demo02():
my_set = {10, 20, 20, 'a', 'b'}
# 根据值删除元素, 元素不存在抛出异常
my_set.remove(20)
print(my_set)
# 根据值删除元素, 元素不存在不抛异常
my_set.discard(10)
# 随机删除一个元素
my_set.pop()
print(my_set)
# 删除所有元素
my_set.clear()
print(my_set)
# 4. 集合相关操作操作
def demo03():
my_set1 = {10, 20, 30, 40, 50}
my_set2 = {10, 20, 30}
# 计算交集
print(my_set1.intersection(my_set2))
# 计算并集
print(my_set1.union(my_set2))
# 计算差集
print(my_set1.difference(my_set2))
print(my_set2.difference(my_set1))
# 是否是超集、子集
print(my_set1.issuperset(my_set2))
print(my_set2.issubset(my_set1))
# 5. 集合支持运算符
def demo04():
my_set1 = {10, 20}
my_set2 = {30, 40}
# *、+、+= 不支持
# 由于集合不支持重复元素，不支持用于复制的 * 运算符
# 集合的涉及初中适用于交并集计算，由于其内部复杂的机制，会导致简单合并操作非常耗时，故而不支持
print(10 in my_set1)
print(10 not in my_set2)
- Dict 容器 {#title-3} =====================
Python 中 dict（字典）是一种无序的键值对容器类型。字典以键（key）和值（value）的形式存储数据，其中每个键都是唯一的。dict 是一种非常常用和灵活的数据结构，可用于快速查找和存储数据。
以下是dict容器的一些重要特性：
- 无序性：
dict中的元素没有定义的顺序，不能通过索引访问或修改元素。 - 键值对：字典中的元素是以键值对的形式存储的。每个键都是唯一的，而值可不是唯一。
- 可变性：
dict是可变的，可以通过添加、修改或删除键值对来改变字典的内容。
Dict 容器示例代码：
# 1. 字典初始化
def demo00():
my_dict = {}
my_dict = dict()
# 字典键值不能重复
my_dict = {'name': 'smith', 'age': 18}
print(my_dict)
# 2. 字典添加元素
def demo01():
my_dict = {}
# 直接添加元素
my_dict['name'] = 'smith'
my_dict['age'] = 18
print(my_dict)
# 添加字典中元素
my_dict.update({'gender': '男', 'height': 197})
print(my_dict)
# 3. 字典删除操作
def demo02():
my_dict = {'name': 'smith', 'age': 18}
# 删除指定键元素
my_dict.pop('name')
print(my_dict)
# 删除所有元素
my_dict.clear()
print(my_dict)
# 4. 字典查询操作
def demo03():
my_dict = {'name': 'smith', 'age': 18}
# 直接根据键查询，键值不存在则抛出异常
# print(my_dict['abc'])
# 直接根据键查询，键值不存在不会抛出异常，并可以设置默认返回值
print(my_dict.get('abc', 'default'))
# 5. 字典遍历操作
def demo04():
my_dict = {'name': 'smith', 'age': 18}
# 只遍历键
for key in my_dict.keys():
print(key)
# 只遍历值
for value in my_dict.values():
print(value)
# 遍历键值
for key, value in my_dict.items():
print(key, value)
# 6. 字典其他操作
def demo05():
my_dict = {'name': 'smith', 'age': 18, 'abc': 1000}
# 字典中元素的个数
print(len(my_dict))
# 给某个键设置默认值，当该键不存在时返回默认值
my_dict.setdefault('abc', 100)
print(my_dict['abc'])
# 7. 字典支持运算符
def demo06():
my_dict1 = {'name': 'smith', 'age': 18, 'abc': 1000}
my_dict2 = {'name': 'smith', 'age': 18, 'abc': 1000}
# 字典不支持 *、+、+=
# 字典支持 in 和 not in 运算符
print('name' in my_dict1) # 默认判断 key 是否存在
print('name' in my_dict1.keys())
print('18' in my_dict1.values())
