数据容器能大幅简化代码、提升效率，尤其是处理动态数据、快速查找、优先级处理等场景，在Python中无需复杂框架，核心高频实用的 4 种数据容器即可覆盖绝大多数场景：List（列表 / 动态数组）、Set（无序不重复集合）、Dict（字典 / 键值对映射）、deque（双端队列）。
同时为满足复习需要, 也添加了字符串(str)和元组(tuple)的有关知识点.

1. list（列表 / 动态数组）

• 核心作用：替代普通固定长度数组，解决数组长度不可变的问题，竞赛中处理动态增长的列表（比如存储输入数据、结果集、临时缓存）。
• 优势：随机访问快（O (1)），尾部增删元素快（O (1)），支持索引操作，适合需要频繁读取、尾部修改的场景。
• 核心语法：

    # 1. 初始化
    lst = []  # 空列表
    lst = list()
    lst2 = [1, 2, 3]  # 带初始值
    
    # 2. 增：添加元素（尾部/指定位置）
    lst.append(5)       # 尾部添加：[5]
    lst.insert(0, 3)    # 索引0添加：[3,5]
    lst.extend(lst2)    # 批量添加：[3,5,1,2,3]
    
    # 3. 删：按索引/元素删除
    lst.pop(1)          # 删除索引1的元素（返回值）：[3,1,2,3]
    lst.remove(3)       # 删除第一个值为3的元素：[1,2,3]
    
    # 4. 查：按索引/判断存在
    val = lst[1]        # 获取索引1的元素：2
    has5 = 5 in lst     # 判断是否包含5：False
    index = lst.index(2) # 找元素2的第一个索引：1
    
    # 5. 改：修改指定索引元素
    lst[0] = 10         # [10,2,3]
    
    # 6. 遍历（竞赛常用两种方式）
    # 方式1：普通for（需要索引时用）
    for i in range(len(lst)):
        print(lst[i], end=" ")
    # 方式2：增强for（仅遍历）
    for num in lst:
        print(num, end=" ")
    
    # 7. 竞赛高频操作：排序、反转、清空
    lst.sort()          # 升序排序：[2,3,10]
    lst.reverse()       # 反转：[10,3,2]
    lst.clear()         # 清空列表

2. set（无序不重复集合）

• 核心作用：快速去重、快速判断元素是否存在（O (1)），竞赛中常用于 “判重”“统计唯一元素” 场景（比如：判断数组是否有重复元素、找两个数组的交集）。
• 核心特点：无序、无重复、不支持索引，底层是哈希表，支持集合运算（交集、并集、差集）。
• 核心语法:

    # 1. 初始化
    s = set()
    s2 = {1, 2, 3}  # 带初始值（注意：{}是空字典，不是空集合）
    
    # 2. 增：添加元素（重复元素自动忽略）
    s.add(1)
    s.add(2)
    s.add(1)  # 重复，不会添加
    
    # 3. 删：删除元素
    s.remove(2)  # 删除值为2的元素（元素不存在会报错）
    s.discard(3) # 删除值为3的元素（元素不存在不报错，竞赛更常用）
    
    # 4. 查：判断元素是否存在（竞赛最常用）
    has1 = 1 in s  # True
    has3 = 3 in s  # False
    
    # 5. 遍历（无索引，只能普通for）
    for num in s:
        print(num, end=" ")  # 输出1
    
    # 6. 竞赛高频：转列表/集合运算
    lst = list(s)  # 转列表
    arr = tuple(s) # 转元组
    # 集合运算（找交集/并集/差集）
    s1 = {1,2,3}
    s2 = {2,3,4}
    intersection = s1 & s2  # 交集 {2,3}
    union = s1 | s2         # 并集 {1,2,3,4}
    difference = s1 - s2    # 差集 {1}
    
    # 7. 清空/长度
    size = len(s)  # 1
    s.clear()

3. dict（字典 / 键值对映射）

• 核心作用：通过 “键” 快速找 “值”（O (1)），竞赛中常用于 “统计频次”“映射关系”（比如：统计数组中每个元素出现的次数、字符串字符计数）。
• 核心特点：键唯一（必须是不可变类型：字符串 / 数字 / 元组）、值可重复，Python3.7+ 字典有序（按插入顺序）。
• 核心语法：

	from collections import defaultdict
    # 无 key → 自动创建默认值，无需手动判断
    # 初始化时必须指定默认值类型（list/int/set）
    dd = defaultdict(int)
    d = dict(dd) # 后续也可转化为dict类型
    
    # 1. 初始化：键=字符串，值=出现次数
    d = {}
    d = dict()
    d2 = {"a":1, "b":2}
    
    # 2. 增/改：直接赋值（键存在则改值，不存在则新增）
    d["a"] = 1
    d["b"] = 2
    d["a"] = 3  # 键"a"已存在，值改为3
    
    # 3. 查：get（键不存在返回None/指定默认值，竞赛必用，避免KeyError）
    countA = d["a"]          # 3（键不存在会报错，慎用）
    countC = d.get("c", 0)   # 键c不存在，返回默认值0（竞赛首选）
    
    # 4. 判：是否包含键/值
    hasKeyA = "a" in d       # True
    hasValue2 = 2 in d.values() # False
    
    # 5. 删：删除键值对
    del d["b"]               # 删除键为b的键值对
    d.pop("a", None)        # 删除键为a的键值对，不存在则返回None
    
    # 6. 遍历（竞赛三种常用方式）
    # 方式1：遍历所有键（最常用）
    for key in d:
        value = d[key]
        print(f"{key}:{value}")
    # 方式2：遍历键值对（效率更高）
    for key, value in d.items():
        print(f"{key}:{value}")
    # 方式3：仅遍历值
    for value in d.values():
        print(value)
    
    # 7. 大小/清空
    size = len(d)  # 0
    d.clear()

4. deque（双端队列）

• 核心作用：既可以当栈（后进先出），也可以当队列（先进先出），竞赛中替代列表做栈 / 队列（列表头部操作效率低 O (n)，deque 两端操作 O (1)），用于 DFS（栈）、BFS（队列）。
• 优势：两端增删效率极高（O (1)），功能全，是 Python 官方推荐的栈 / 队列实现。
• 核心语法：

	# 需要导入collections中的deque
	from collections import deque
	# 初始化
    dq = deque()
    
    # 1. 当队列用（FIFO）：尾部加，头部取
    dq.append(1)  # 尾部添加
    dq.append(2)
    q_head = dq.popleft()  # 取出头部1（列表pop(0)效率低，禁用）
    
    # 2. 当栈用（LIFO）：尾部加，尾部取（或头部加/取，效果一致）
    dq.append(3)  # 尾部添加（等价于栈push）
    dq.append(4)
    s_top = dq.pop()  # 取出尾部4（等价于栈pop）
    # 也可头部加/取（和Java Deque栈用法对齐）
    dq.appendleft(5)  # 头部添加
    s_top2 = dq.popleft()  # 取出头部5
    
    # 3. 查头部/尾部（不删除）
    peek_head = dq[0]      # 头部3（直接索引，也可用dq[0]）
    peek_tail = dq[-1]     # 尾部2
    # 或用专用方法
    peek_head2 = dq[0]     # 等价于dq.peek()（Python无peek，直接索引更直观）
    peek_tail2 = dq[-1]

5. str（字符串）

• 核心作用：存储文本 / 字符序列，是 Python 最常用的文本处理容器.
• 核心特点：有序可通过索引访问(序列型容器)，无法修改
• 核心语法：

    # 1. 初始化
    s1 = "hello"          # 双引号
    s2 = 'python'         # 单引号
    s3 = ""               # 空字符串
    s3 = str()
    s4 = "123abc"         # 混合字符

    # 2. 索引访问（有序，从0开始）
    print(s1[0])    # h
    print(s1[-1])   # o（倒数第一个）

    # 3. 切片（左闭右开，生成新字符串）
    print(s1[1:4])     # ell
    print(s1[::2])     # hlo（步长2）
    print(s1[::-1])    # olleh（反转字符串）

    # 4. 遍历
    for char in s1:
        print(char, end=" ")  # h e l l o

    # 5. 高频操作（重点！）
    # 拼接
    new_s = s1 + " " + s2     # hello python
    # 统计/查找
    print(s1.count("l"))	  # 2
    print(s1.find("e"))       # 1（返回索引，不存在返回-1）
    print("e" in s1)          # True
    # 前后缀判断
    print(s1.startswith("h")) # True
    print(s1.endswith(("h","o"))) # 支持元组多前后缀 → True
    # 替换（生成新字符串，原字符串不变）
    print(s1.replace("l", "x")) # hexxo
    # 分割/拼接
    print("a,b,c".split(",")) # ['a','b','c']
    print("-".join(["a","b"]))# a-b
    # 大小写
    print(s1.upper())  # HELLO
    print(s1.lower())  # hello
    # 去掉首尾空格/换行/制表符
    s.strip() 
    # 判断
    print("123".isdigit())    # True（是否纯数字）
    print(s1.isalpha())       # True（是否纯字母）

    # 6. 长度
    print(len(s1))  # 5

6. tuple（元组）

• 核心作用：不可变的列表，用于保护数据不被修改、函数多返回值、作为字典的键。
• 核心特点：有序可通过索引访问(序列型容器)，无法修改
• 核心语法：

    # 1. 初始化
    t1 = (1, 2, 3)            # 标准元组
    t2 = 1, 2, 3              # 省略括号，效果一样
    t3 = ()                   # 空元组
    t3 = tuple()
    t4 = (10,)                # 单元素元组（必须加逗号！）
    t5 = (1, "abc", [2, 3])   # 存储不同类型数据

    # 2. 索引/切片（和列表、字符串完全一致）
    print(t1[0])      # 1
    print(t1[1:])     # (2, 3)

    # 3. 遍历
    for num in t1:
        print(num, end=" ")  # 1 2 3

    # 4. 高频操作
    # 判重
    print(2 in t1)            # True
    # 统计/查找
    print(t1.count(1))        # 1（元素出现次数）
    print(t1.index(2))        # 1（元素索引）
    # 元组解包（高频！）
    a, b, c = t1
    print(a, b, c)  # 1 2 3
    # 列表 ↔ 元组
    lst = list(t1)   # [1,2,3]
    new_t = tuple(lst) # (1,2,3)
      
    # 5. 长度
    print(len(t1))  # 3

    # ⚠️ 重要：元组不可变！以下操作会报错
    # t1[0] = 100  # 报错！TypeError