一、快速掌握python中的序列、集合和字典的用法（数据容器）

一、快速掌握python中的序列、集合和字典的用法

1.序列

列表（list）切片用法表

写法	含义	示例
a[i:j]	取从下标 i 到 j-1 的元素	a=[0,1,2,3,4]; a[1:4] → [1,2,3]
a[:j]	从开头到 j-1	a[:3] → [0,1,2]
a[i:]	从 i 到最后	a[2:] → [2,3,4]
a[:]	整个列表复制一份	a[:] → [0,1,2,3,4]
a[::k]	步长 k，隔 k 个取一个	a[::2] → [0,2,4]
a[::-1]	倒序	a[::-1] → [4,3,2,1,0]
a[i:j:k]	从 i 到 j-1，步长 k	a[1:5:2] → [1,3]
a[-m:]	取最后 m 个	a[-3:] → [2,3,4]
a[:-m]	除去最后 m 个	a[:-2] → [0,1,2]
a[::]	等价于 a[:]	a[::] → [0,1,2,3,4]
a[i:i] = [...]	插入元素	a=[1,2,3]; a[1:1]=[9] → [1,9,2,3]
a[i:j] = [...]	替换 i 到 j-1 的元素	a=[0,1,2,3]; a[1:3]=[10,20] → [0,10,20,3]
a[::k] = [...]	按步长替换，数量必须匹配	a=[0,1,2,3,4]; a[::2]=[9,9,9] → [9,1,9,3,9]
del a[i:j]	删除 i 到 j-1	a=[0,1,2,3,4]; del a[1:3] → [0,3,4]
a[i:j]=[]	删除 i 到 j-1	a=[0,1,2,3]; a[1:3]=[] → [0,3]
a[:] = []	清空整个列表	a=[1,2,3]; a[:]=[] → []

---

元组（tuple）切片用法表

写法	含义	示例
t[i:j]	取从下标 i 到 j-1 的元素	t=(10,20,30,40); t[1:3] → (20,30)
t[:j]	从开头到 j-1	t[:2] → (10,20)
t[i:]	从 i 到最后	t[2:] → (30,40)
t[:]	整个元组复制一份	t[:] → (10,20,30,40)
t[::k]	步长 k，隔 k 个取一个	t[::2] → (10,30)
t[::-1]	倒序	t[::-1] → (40,30,20,10)
t[i:j:k]	从 i 到 j-1，步长 k	t[0:4:2] → (10,30)
t[-m:]	取最后 m 个	t[-2:] → (30,40)
t[:-m]	除去最后 m 个	t[:-2] → (10,20)
t[::]	等价于 t[:]	t[::] → (10,20,30,40)

⚠️ 元组是不可变的 → 不能切片赋值、不能删除。

---

字符串（str）切片用法表

写法	含义	示例
s[i:j]	取从下标 i 到 j-1 的子串	s="Hello"; s[1:4] → 'ell'
s[:j]	从开头到 j-1	s[:2] → 'He'
s[i:]	从 i 到最后	s[2:] → 'llo'
s[:]	整个字符串复制一份	s[:] → 'Hello'
s[::k]	步长 k，隔 k 个取一个	s[::2] → 'Hlo'
s[::-1]	倒序	s[::-1] → 'olleH'
s[i:j:k]	从 i 到 j-1，步长 k	s[0:5:2] → 'Hlo'
s[-m:]	取最后 m 个	s[-3:] → 'llo'
s[:-m]	除去最后 m 个	s[:-2] → 'Hel'
s[::]	等价于 s[:]	s[::] → 'Hello'

⚠️ 字符串也是不可变的 → 不能切片赋值、不能删除。

---

✨ 口诀

• 左闭右开：取到起点，不取到终点。
• 省略：开头省略就是 0，结尾省略就是最后。
• 负数：-1 表示最后一个，-2 倒数第二个。
• 步长：正数往右，负数往左，不能是 0。
• 字符串/元组：只能切不能改。
• 列表：能切还能改，还能删还能插。

一、定义

切片（slice）是针对“序列类型”的索引区间操作。它按给定的起始下标、结束下标、步长，从原序列中取出一个子序列并返回同类型（或等价类型）的新对象。
支持切片的常见类型：list、tuple、str、bytes、bytearray、range 等（注意：迭代器/生成器本身不支持切片）。

二、作用

• 快速截取子序列、跳步抽样、倒序。
• 对可变序列（如 list、bytearray）还能做：原位替换、插入、删除（称“切片赋值/删除”）。
• 安全地做浅拷贝（a[:]）。

三、语法格式

seq[start : stop : step]
# start 起始下标（含），可省略；默认序列开头
# stop  结束下标（不含），可省略；默认序列末尾
# step  步长，正负都可，不能为 0；省略等于 1

索引规则与边界：

• 左闭右开：包含 start，不包含 stop。
• 可为负数：-1 表示最后一个元素。
• 越界不报错：自动截断到有效范围（IndexError 只发生在单个下标访问时）。
• 反向切片：step < 0 表示从右向左取；此时若省略 start/stop，分别默认为末尾/开头前一位，如 seq[::-1]。

四、所有常见用法速览

• 基本区间：s[i:j]
• 省略端点：s[:j]、s[i:]、s[:]（浅拷贝）
• 跳步抽样：s[::k]（每 k 个取一个）
• 负步长倒序：s[::-1]（整体反转）、s[j:i:-1]
• 负索引：s[-3:]、s[:-3]、s[-5:-2]
• 列表切片赋值：a[i:j] = iterable（替换/插入）、a[i:j:k] = iterable（步长赋值，长度须匹配）
• 列表切片删除：del a[i:j]、del a[::k]、a[:] = [] 清空
• slice 对象：idx = slice(i, j, k); s[idx]；idx.indices(len(s)) 可规范化三元组
• 迭代器等的“切片”替代：itertools.islice(iterable, start, stop, step)

---

五、示例代码（含注释）

1) 基本、负索引、步长与倒序

s = ['a','b','c','d','e','f','g','h']print(s[2:5])      # ['c', 'd', 'e']   从索引2到4
print(s[:3])       # ['a','b','c']     省略 start，默认开头
print(s[5:])       # ['f','g','h']     省略 stop，默认末尾
print(s[:])        # 浅拷贝（新列表）print(s[-3:])      # ['f','g','h']     末尾3个
print(s[:-3])      # ['a','b','c','d','e']  去掉最后3个
print(s[::2])      # ['a','c','e','g'] 每隔1个取1个
print(s[::-1])     # ['h','g','f','e','d','c','b','a']  倒序
print(s[5:1:-1])   # ['f','e','d','c'] 从索引5降到2（不含1）

细节：step 不能为 0，否则 ValueError。start/stop 越界会被“钳制”，返回尽可能合理的子序列（不会抛错）。

2) 列表切片赋值（替换 / 插入 / 等长步长赋值）

a = [0, 1, 2, 3, 4, 5]a[2:4] = [20, 30, 40]     # 替换+扩容：在 [2,4) 放入 3 个元素
# a 现在是 [0, 1, 20, 30, 40, 4, 5]a[1:1] = ['X','Y']        # 在索引1处插入两个
# a 现在是 [0, 'X', 'Y', 1, 20, 30, 40, 4, 5]a[::2] = [9,9,9,9,9]      # 步长赋值：目标位置是索引 0,2,4,6,8
# 长度必须严格相等，否则 ValueErrordel a[3:7]                 # 删除区间
# 也可：a[3:7] = []       # 等价效果a[:] = []                  # 清空列表（等价于 a.clear()）

3) 字符串与元组（只读序列：只能“取”，不能切片赋值）

t = (10, 20, 30, 40, 50)
print(t[1:4])       # (20, 30, 40)  返回新元组st = "Hello, world!"
print(st[7:12])     # 'world'
print(st[::-1])     # '!dlrow ,olleH'
# st[0:1] = 'h'     # ❌ 不允许：字符串不可变

4) bytes / bytearray（bytearray 可切片赋值）

ba = bytearray(b'abcdef')
ba[1:4] = b'XYZ'       # 可变字节序列可直接替换
print(ba)              # bytearray(b'aXYZef')b = b'abcdef'
print(b[1:4])          # b'bcd'（bytes 只读，不能赋值）

5) 使用 slice 对象与 indices

s  = ['A','B','C','D','E','F','G']
idx = slice(1, 6, 2)         # 等价于 [1:6:2]
print(s[idx])                # ['B','D','F']
print(idx.indices(len(s)))   # (1, 7, 2)  -> 规范化为合法范围（stop 可能被扩展到 len）

6) 迭代器“切片”替代：itertools.islice

from itertools import islicedef gen():for i in range(10):yield i*ig = gen()
# g[2:8:2]  # ❌ 生成器不支持切片
part = list(islice(g, 2, 8, 2))  # ✅ 取索引 2,4,6 的元素
print(part)  # [4, 16, 36]

---

六、行为与性能要点（容易踩坑）

• 拷贝语义：a[:] 是浅拷贝，只复制最外层容器；嵌套对象仍然共享引用。深拷贝用 copy.deepcopy(a)。
• 时间复杂度：创建切片大致 O(k)（k 为切片长度）；大切片会占用额外内存。
• 等长要求：a[i:j:k] = iterable 时，右侧可迭代对象的元素个数必须与目标位置个数一致。
• 负步长默认端点：seq[::-1] 等价于 seq[len(seq)-1 : None : -1]，记住“左闭右开”仍然成立。
• 越界安全：s[100:200] 返回空序列，不抛错；但 s[100] 会 IndexError。

---

七、实用模板（拿来即用）

# 1) 常见片段
left3      = s[:3]
right3     = s[-3:]
middle     = s[i:j]
skip_2     = s[::2]
reversed_s = s[::-1]# 2) 安全浅拷贝（不可变/可变通用）
copy_s     = s[:]# 3) 列表原位操作
a[i:j]     = new_block       # 替换/插入
del a[i:j]                   # 删除
a[:]       = []              # 清空# 4) 复杂切片复用
take_even  = slice(0, None, 2)   # 偶数位
print(s[take_even])

2.集合

一、定义

集合（set） 是一种 无序、可变、元素不重复 的数据类型，用于存储多个唯一值。
集合里的元素必须是 可哈希的（比如数字、字符串、元组），但 不能是 list/dict/set 这种可变类型。

---

二、作用

1. 去重：自动去掉重复元素。
2. 成员测试：快速判断某个元素是否在集合里。
3. 集合运算：并集、交集、差集、对称差等。
4. 数据清洗：比如快速去掉列表里重复的数据。

---

三、语法格式

# 创建集合
s = {元素1, 元素2, ...}       # 用大括号
s = set([可迭代对象])          # 用 set() 函数# 常见操作
s.add(x)                      # 添加一个元素
s.remove(x)                   # 删除元素（不存在会报错）
s.discard(x)                  # 删除元素（不存在也不报错）
s.pop()                       # 随机删除并返回一个元素
s.clear()                     # 清空集合

---

四、集合常见语法汇总表

操作	语法	说明
创建集合	{1,2,3} 或 set([1,2,3])	定义集合，自动去重
添加	s.add(x)	加一个元素
删除	s.remove(x)	删一个元素，不存在时报错
删除（安全）	s.discard(x)	删一个元素，不存在不报错
随机删除	s.pop()	随机取出并删除一个元素
清空	s.clear()	清空集合
成员测试	x in s，x not in s	判断元素是否在集合里
并集	`s	t或s.union(t)`
交集	s & t 或 s.intersection(t)	取两个集合共同的部分
差集	s - t 或 s.difference(t)	在 s 里但不在 t 里
对称差集	s ^ t 或 s.symmetric_difference(t)	在 s 或 t 中，但不同时在两个里
子集判断	s <= t 或 s.issubset(t)	判断 s 是否是 t 的子集
真子集	s < t	s 是 t 的子集但不等于 t
超集判断	s >= t 或 s.issuperset(t)	判断 s 是否包含 t
真超集	s > t	s 包含 t 但不等于 t
长度	len(s)	集合中元素个数
转换	list(s)，tuple(s)	把集合转成列表或元组

• 补充

difference_update()

• 作用：把集合 1 中与集合 2 重叠的元素删掉，直接修改集合 1，不返回新集合。
• 示例：

a = {1,2,3,4}
b = {3,4,5}
a.difference_update(b)
print(a)  # {1,2}   （3 和 4 被删掉了）

对比：a.difference(b) 返回新集合，a 不变。

五、基础示例（带详细注释）

# 1. 创建集合
s1 = {1, 2, 3, 3, 2}      # 自动去重
print(s1)  # {1, 2, 3}s2 = set([2, 3, 4])       # 用 set() 从列表创建集合
print(s2)  # {2, 3, 4}# 2. 添加元素
s1.add(5)
print(s1)  # {1, 2, 3, 5}# 3. 删除元素
s1.remove(2)              # 删除 2
print(s1)  # {1, 3, 5}s1.discard(10)            # 删除一个不存在的元素，不报错
print(s1)  # {1, 3, 5}# 4. 成员测试
print(3 in s1)   # True
print(4 not in s1) # True# 5. 并集、交集、差集、对称差集
print(s1 | s2)  # 并集 {1, 3, 4, 5, 2}
print(s1 & s2)  # 交集 {3}
print(s1 - s2)  # 差集 {1, 5}
print(s1 ^ s2)  # 对称差集 {1, 2, 4, 5}# 6. 子集、超集
a = {1,2}
b = {1,2,3}
print(a <= b)   # True，a 是 b 的子集
print(b >= a)   # True，b 是 a 的超集
print(a < b)    # True，真子集
print(b > a)    # True，真超集# 7. 清空
s1.clear()
print(s1)  # set()，空集合

3.字典

一、定义

字典（dict） 是 键值对（key-value） 的无序可变集合。

• 键（key）：必须是不可变、可哈希的类型（数字、字符串、元组）。
• 值（value）：可以是任意对象（数字、字符串、列表、字典等）。
• 一个键只能对应一个值，键不能重复。

---

二、作用

1. 快速查找：基于键访问，效率高。
2. 存储映射关系：如学号 → 姓名，商品名 → 价格。
3. 数据组织：比列表更灵活，适合存储结构化数据。

---

三、语法格式

# 定义字典
d = {"key1": value1, "key2": value2}
d = dict(key1=value1, key2=value2)   # 用 dict() 函数# 访问
d["key"]          # 取值
d.get("key", 默认) # 取值，不存在返回默认# 增改
d["key"] = value# 删除
del d["key"]
d.pop("key", 默认)   # 删除并返回值
d.popitem()         # 删除并返回最后一对键值
d.clear()           # 清空字典

---

四、字典常见语法汇总表

操作	语法	说明
创建字典	{"a":1,"b":2} 或 dict(a=1,b=2)	定义字典
访问值	d["a"]	键存在返回值，不存在报错
安全访问	d.get("a", 默认)	键不存在返回默认值
新增或修改	d["c"]=3	没有就新增，有就修改
删除指定键	del d["a"]	删除键对应的项
删除并返回值	d.pop("a", 默认)	不存在时返回默认
删除最后一项	d.popitem()	删除并返回最后一个键值对
清空	d.clear()	清空整个字典
键列表	d.keys()	返回所有键（可迭代视图）
值列表	d.values()	返回所有值（可迭代视图）
键值对列表	d.items()	返回所有 (key,value)
遍历	for k,v in d.items():	遍历键值对
更新	d.update({"x":100})	合并或更新字典
判断键存在	"a" in d	返回 True/False
长度	len(d)	返回字典中键值对数量
拷贝	d.copy()	浅拷贝
fromkeys	dict.fromkeys(["a","b"],0)	生成新字典，初始值为0

---

五、基础示例（详细注释）

# 1. 创建字典
d = {"name":"Alice", "age":20}
print(d)  # {'name': 'Alice', 'age': 20}# 2. 访问
print(d["name"])        # Alice
# print(d["gender"])    # ❌ KeyError
print(d.get("gender", "未知"))  # "未知"# 3. 新增与修改
d["gender"] = "female"  # 新增
d["age"] = 21           # 修改
print(d)  # {'name':'Alice','age':21,'gender':'female'}# 4. 删除
del d["gender"]
print(d)  # {'name':'Alice','age':21}val = d.pop("age")      # 删除并返回值
print(val)  # 21
print(d)    # {'name':'Alice'}# 5. 遍历
d = {"a":1,"b":2,"c":3}
print(list(d.keys()))    # ['a','b','c']
print(list(d.values()))  # [1,2,3]
print(list(d.items()))   # [('a',1),('b',2),('c',3)]for k,v in d.items():print(k, "→", v)
# 输出：
# a → 1
# b → 2
# c → 3# 6. 更新
d.update({"b":200,"d":4})
print(d)  # {'a':1,'b':200,'c':3,'d':4}# 7. 清空
d.clear()
print(d)  # {}

python数据容器对比表

特性	列表 list	元组 tuple	字符串 str	集合 set	字典 dict
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符（本质仍是 str 对象）	任意可哈希对象	Key：不可变类型；Value：任意类型
下标索引	支持	支持	支持	不支持	不支持（通过键访问）
重复元素	支持	支持	支持	不支持	Key 不支持重复，Value 支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	✅ 有序	✅ 有序	✅ 有序	❌ 无序	❌ 无序（3.7+ 插入顺序保留，但逻辑上无序）
复元素	支持	支持	支持	不支持	Key 不支持重复，Value 支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	✅ 有序	✅ 有序	✅ 有序	❌ 无序	❌ 无序（3.7+ 插入顺序保留，但逻辑上无序）
使用场景	可修改、可重复的一批数据记录	不可修改、可重复的一批数据记录	一串字符的记录与处理	不可重复的数据集合、集合运算	Key-Value 形式的数据映射与查找