容器提供了一组强大而灵活的工具，用于处理和操作数据集合。Python 中常用的容器包括列表(list)、元组(tuple)、字典(dict)、集合(set) ，这些容器中提供了添加、删除、访问和修改元素的功能，使得操作变得简单。

1. List 容器

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)

2. Tuple 容器

Python 中 的 tuple（元组）是一种有序、不可变的容器类型。与 list 相比，tuple 具有不可变性，这意味着一旦创建，就不能修改其内容。

1. 有序性：tuple中的元素按照它们的顺序排列，并且可以通过索引访问和操作特定位置的元素。
2. 不可变性：tuple是不可变的，意味着一旦创建，就不能修改其中的元素。无法添加、删除或修改元组的元素。
3. 可哈希性：由于元组的不可变性，元组是可哈希的，可以作为字典的键值或集合的元素。
4. 紧凑性：相对于 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)

3. Set 容器

Python中 set（集合）是一种无序且不重复的容器类型。set 是一种用于存储和操作独立元素集合的有用工具。集合具有如下特点：

1. 无序性：set中的元素没有定义的顺序，无法通过索引访问或修改元素。
2. 唯一性：set中的元素是唯一的，不允许重复的元素存在。重复的元素将被自动去重。
3. 可变性：set是可变的，可以通过添加或删除元素来改变集合的内容。
4. 数学集合操作：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)

4. Dict 容器

Python 中 dict（字典）是一种无序的键值对容器类型。字典以键（key）和值（value）的形式存储数据，其中每个键都是唯一的。dict 是一种非常常用和灵活的数据结构，可用于快速查找和存储数据。

以下是dict容器的一些重要特性：

1. 无序性：dict中的元素没有定义的顺序，不能通过索引访问或修改元素。
2. 键值对：字典中的元素是以键值对的形式存储的。每个键都是唯一的，而值可不是唯一。
3. 可变性：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())