📚 Python入门到高级（知识点二）
💡 关键知识点（容器）
一、字符串
1. 字符串概述
字符串：用引号包裹，元素是字符，任意类型都可以转换为字符串
特点：字符串是不可变类型，支持索引访问
索引规则：
- 正索引：从
0开始，从左到右依次递增 - 负索引：从
-1开始，从右到左依次递减
示例：name = 'hello'
| 字符 | h | e | l | l | o |
|---|---|---|---|---|---|
| 正索引 | 0 | 1 | 2 | 3 | 4 |
| 负索引 | -5 | -4 | -3 | -2 | -1 |
2. 字符串的定义方式
# 1. 定义空字符串（4种方式）
s1 = ""
s1 = ''
s1 = """"""
s1 = ''''''
# 2. 定义非空字符串（4种方式）
s2 = "你好"
s2 = '你好'
s2 = """你好"""
s2 = '''你好'''
3. 字符串常用方法速查表（按开发频率排序）
🔥 高频使用（天天见）
| 方法 | 作用 | 示例 |
|---|---|---|
f"{var}" | f-string 格式化（Python 3.6+ 推荐）✅ | f"你好{name}" → "你好张三" |
s.strip() | 去除两端空白（空格、换行、制表符） | " hi ".strip() → "hi" |
s.split(sep) | 按 sep 切割字符串，返回列表 | "a,b,c".split(",") → ['a','b','c'] |
sep.join(list) | 用 sep 连接列表元素，返回字符串 | "-".join(['a','b']) → "a-b" |
s.replace(old, new) | 将 old 替换为 new | "你TMD".replace("TMD","***") → "你***" |
x in s | 判断 x 是否在 s 中 | "h" in "hello" → True |
len(s) | 获取字符串长度 | len("hello") → 5 |
s.startswith(x) | 是否以 x 开头 | "hello".startswith("h") → True |
s.endswith(x) | 是否以 x 结尾 | "hello".endswith("o") → True |
s.upper() / s.lower() | 大小写转换 | "abc".upper() → "ABC" |
👍 次高频（经常用）
| 方法 | 作用 | 示例 |
|---|---|---|
s.find(sub) | 从左查 sub 索引（找不到返回 -1）✅ | "hello".find("a") → -1 |
s.count(sub) | 统计子串 sub 出现的次数 | "hello".count("l") → 2 |
s.zfill(width) | 右对齐，左边用 0 填充 | "42".zfill(5) → "00042" |
s.lstrip() / s.rstrip() | 去除左侧/右侧空白 | " hi ".lstrip() → "hi " |
s.isdigit() | 是否全是数字 | "123".isdigit() → True |
s.isalpha() | 是否全是字母（含中文） | "你好".isalpha() → True |
s.isalnum() | 是否全是字母或数字 | "abc123".isalnum() → True |
💡 低频但实用（特定场景）
| 方法 | 作用 | 示例 |
|---|---|---|
s.rsplit(sep, n) | 从右边切割，可指定切割次数 | "a,b,c".rsplit(",", 1) → ['a,b','c'] |
s.partition(sep) | 按 sep 分割成三元组 | "a-b".partition("-") → ('a','-','b') |
s.casefold() | 更强的小写转换（支持多语言） | "Straße".casefold() → "strasse" |
s.title() | 每个单词首字母大写 | "hello world".title() → "Hello World" |
s.center(width) | 居中填充 | "hi".center(5) → " hi " |
s.ljust(width) / s.rjust(width) | 左/右对齐填充 | "hi".ljust(4) → "hi " |
s.isspace() | 是否全是空白字符 | " ".isspace() → True |
s.isdecimal() / s.isnumeric() | 是否全为数字（含中文数字） | "三".isnumeric() → True |
s.swapcase() | 大小写互换 | "Hello".swapcase() → "hELLO" |
s.capitalize() | 首字母大写，其余小写 | "hello".capitalize() → "Hello" |
⚠️ 了解即可（有更好替代方案）
| 方法 | 作用 | 替代方案 |
|---|---|---|
s.index(sub) | 从左查索引（找不到报错） | 用 find() 更安全 |
s.rindex(sub) | 从右查索引（找不到报错） | 用 rfind() 更安全 |
s.format(*args) | 格式化字符串 | 用 f-string 更简洁 |
s.format_map(dict) | 用字典格式化字符串 | 用 f-string + **dict |
二、列表
1. 列表概述
列表：用中括号 [] 包裹，元素可以是任意类型，支持重复元素。
特点：列表是可变类型，支持索引访问。
索引规则：
- 正索引：从
0开始，从左到右依次递增 - 负索引：从
-1开始，从右到左依次递减
示例：names = ['张三', '李四', '王五', '张三', '赵六']
| 元素 | 张三 | 李四 | 王五 | 张三 | 赵六 |
|---|---|---|---|---|---|
| 正索引 | 0 | 1 | 2 | 3 | 4 |
| 负索引 | -5 | -4 | -3 | -2 | -1 |
2. 列表的定义方式
# 1. 定义空列表（2种方式）
l1 = []
l1 = list()
# 2. 定义非空列表
l2 = ['你好', 10, 3.14, True]
# 3. 建议列表存储同类型元素
name_list = ['张三', '李四', '王五']
age_list = [18, 28, 38]
# 4. 列表支持嵌套
big_list = [name_list, age_list]
print(big_list) # [['张三', '李四', '王五'], [18, 28, 38]]
3. 列表常用方法速查表（按开发频率排序）
🔥 高频使用（天天见）
| 方法 | 作用 | 示例 |
|---|---|---|
len(list) | 获取列表长度 | len(['a','b','c']) → 3 |
list.append(x) | 在列表末尾追加一个元素 | [1,2].append(3) → [1,2,3] |
list.extend(iter) | 在列表末尾一次性追加多个元素 | [1,2].extend([3,4]) → [1,2,3,4] |
list.insert(i, x) | 在指定索引位置插入元素 | [1,3].insert(1,2) → [1,2,3] |
list.pop(i) | 删除指定索引位置的元素（默认删除最后一个） | [1,2,3].pop(1) → [1,3] |
list.remove(x) | 删除列表中第一个匹配的元素 | [1,2,3,2].remove(2) → [1,3,2] |
x in list | 判断 x 是否在列表中 | 2 in [1,2,3] → True |
list.clear() | 清空列表所有元素 | [1,2].clear() → [] |
👍 次高频（经常用）
| 方法 | 作用 | 示例 |
|---|---|---|
list.count(x) | 统计 x 在列表中出现的次数 | [1,2,2,3].count(2) → 2 |
list.index(x) | 查找 x 的索引（找不到报错） | ['a','b'].index('b') → 1 |
list.sort() | 对列表进行排序（原地修改） | [3,1,2].sort() → [1,2,3] |
sorted(list) | 返回排序后的新列表（原列表不变）✅ | sorted([3,1,2]) → [1,2,3] |
list.reverse() | 反转列表（原地修改） | [1,2,3].reverse() → [3,2,1] |
list.copy() | 浅拷贝列表 | [1,2].copy() → [1,2] |
💡 低频但实用（特定场景）
| 方法 | 作用 | 示例 |
|---|---|---|
min(list) | 获取列表中的最小值 | min([1,2,3]) → 1 |
max(list) | 获取列表中的最大值 | max([1,2,3]) → 3 |
sum(list) | 对列表中的数字求和 | sum([1,2,3]) → 6 |
list1 + list2 | 列表拼接（返回新列表） | [1,2] + [3,4] → [1,2,3,4] |
list * n | 列表重复 n 次 | [1,2] * 2 → [1,2,1,2] |
⚠️ 了解即可（有更好替代方案）
| 方法 | 作用 | 替代方案 |
|---|---|---|
del list[i] | 删除指定索引位置的元素 | 用 pop(i) 更直观 |
list.remove(x) 批量删除 | 一次只删除第一个匹配项 | 用列表推导式批量删除 |
三、元组
1. 元组概述
元组：用小括号 () 包裹，元素可以是任意类型，支持重复元素。
特点：元组是不可变类型，支持索引访问。
索引规则：
- 正索引：从
0开始，从左到右依次递增 - 负索引：从
-1开始，从右到左依次递减
示例：names = ('张三', '李四', '王五', '张三', '赵六')
| 元素 | 张三 | 李四 | 王五 | 张三 | 赵六 |
|---|---|---|---|---|---|
| 正索引 | 0 | 1 | 2 | 3 | 4 |
| 负索引 | -5 | -4 | -3 | -2 | -1 |
注意：元组和列表几乎一样，唯一区别是元组不支持修改（没有增删改操作）。
2. 元组的定义方式
# 1. 定义空元组（2种方式）
t1 = ()
t1 = tuple()
# 2. 定义非空元组
t2 = ('你好', 10, 3.14, True)
# ⚠️ 元组如果存储1个元素，必须加逗号！！！
t2 = ('你好',)
print(type(t2)) # <class 'tuple'>
# 3. 建议元组存储同类型元素
name_tuple = ('张三', '李四', '王五')
age_tuple = (18, 28, 38)
# 4. 元组支持嵌套
big_tuple = (name_tuple, age_tuple)
print(big_tuple) # (('张三', '李四', '王五'), (18, 28, 38))
注意：定义只有一个元素的元组时，必须加逗号
('你好',)，否则会被识别为字符串。
3. 元组常用方法速查表（按开发频率排序）
🔥 高频使用（天天见）
| 方法 | 作用 | 示例 |
|---|---|---|
len(tuple) | 获取元组长度/元素个数 | len(('a','b','c')) → 3 |
x in tuple | 判断 x 是否在元组中 | 2 in (1,2,3) → True |
x not in tuple | 判断 x 是否不在元组中 | 5 not in (1,2,3) → True |
tuple.count(x) | 统计 x 在元组中出现的次数 | (1,2,2,3).count(2) → 2 |
tuple.index(x) | 查找 x 的索引（找不到报错） | ('a','b').index('b') → 1 |
👍 次高频（偶尔用）
| 方法 | 作用 | 示例 |
|---|---|---|
tuple(iterable) | 将其他可迭代对象转换为元组 | tuple([1,2,3]) → (1,2,3) |
max(tuple) | 获取元组中的最大值 | max((1,2,3)) → 3 |
min(tuple) | 获取元组中的最小值 | min((1,2,3)) → 1 |
sum(tuple) | 对元组中的数字求和 | sum((1,2,3)) → 6 |
sorted(tuple) | 返回排序后的列表（原元组不变） | sorted((3,1,2)) → [1,2,3] |
💡 特定场景（了解即可）
| 方法 | 作用 | 示例 |
|---|---|---|
tuple1 + tuple2 | 元组拼接（返回新元组） | (1,2) + (3,4) → (1,2,3,4) |
tuple * n | 元组重复 n 次 | (1,2) * 2 → (1,2,1,2) |
any(tuple) | 判断是否有元素为 True | any((0, False, 1)) → True |
all(tuple) | 判断是否所有元素为 True | all((1, 2, 3)) → True |
enumerate(tuple) | 返回索引和值的枚举对象 | list(enumerate(('a','b'))) → [(0,'a'),(1,'b')] |
zip(tuple1, tuple2) | 将多个元组按位置配对 | list(zip((1,2),('a','b'))) → [(1,'a'),(2,'b')] |
💡 元组解包（开发中非常实用！）
# 1. 基本解包：变量数量 = 元组长度
t = (10, 20, 30)
a, b, c = t
print(a, b, c) # 10 20 30
# 2. 用 * 收集剩余元素
t = (1, 2, 3, 4, 5)
a, b, *rest = t
print(a, b, rest) # 1 2 [3, 4, 5]
# 3. 忽略不想要的元素（用 _）
t = ('张三', 18, '男', '北京')
name, age, *_, address = t
print(name, age, address) # 张三 18 北京
# 4. 交换两个变量
a, b = 10, 20
a, b = b, a
print(a, b) # 20 10
# 5. 函数返回多个值
def get_user():
return '张三', 18, '北京'
name, age, city = get_user()
print(name, age, city) # 张三 18 北京
四、集合
1. 集合概述
集合：用大括号 {} 包裹，元素可以是任意不可变类型，自动去重。
特点：集合是可变类型，但元素不支持重复，且没有索引。
⚠️ 注意：空的
{}代表空字典，不是空集合！空集合用set()定义。
集合特点：
- 元素只能是不可变类型（字符串、整数、浮点数、元组）
- 自动去重：重复元素会被自动合并
- 无序：没有索引，不支持通过下标访问
- 可变：可以添加和删除元素
示例：names = {'张三', '李四', '王五', '张三', '赵六'}
自动去重为 {'张三', '李四', '王五', '赵六'}
2. 集合的定义方式
# 1. 定义空集合（只能用 set()，{} 是空字典！）
s1 = set()
print(s1, type(s1)) # set() <class 'set'>
# ❌ 错误示范：{} 是空字典，不是空集合！！！
d1 = {}
print(d1, type(d1)) # {} <class 'dict'>
# 2. 定义非空集合
s2 = {'你好', 10, 3.14, True}
print(s2, type(s2)) # {True, 10, 3.14, '你好'} <class 'set'>
# 3. 元素只能是不可变类型
num_set = {'你好', 10, 3.14, (1, 2, 3)} # ✅ 元组可以
print(num_set)
# num_set = {'你好', 10, [1, 2, 3]} # ❌ 列表不行！会报错
3. 集合的自动去重
names = {'张三', '李四', '王五', '张三', '赵六'}
print(names) # {'王五', '赵六', '张三', '李四'} ← 自动去重，顺序可能不同
# 集合没有索引，不支持以下操作：
# print(names[0]) # ❌ 报错：'set' object is not subscriptable
# print(names.count('张三')) # ❌ 报错：集合没有 count() 方法
# print(names.index('张三')) # ❌ 报错：集合没有 index() 方法
# ✅ 支持的操作
print(len(names)) # 4（去重后的数量）
print('张三' in names) # True
print('赵六' in names) # True
4. 集合常用方法速查表（按开发频率排序）
⚠️ 集合没有索引，所以没有
count()、index()等索引相关方法！
🔥 高频使用（天天见）
| 方法 | 作用 | 示例 |
|---|---|---|
len(set) | 获取集合长度（去重后的元素个数） | len({1,2,3,2}) → 3 |
x in set | 判断 x 是否在集合中 | 2 in {1,2,3} → True |
x not in set | 判断 x 是否不在集合中 | 5 not in {1,2,3} → True |
set.add(x) | 添加一个元素（如果已存在则无变化） | {1,2}.add(3) → {1,2,3} |
set.remove(x) | 删除指定元素（不存在则报错 ❌） | {1,2,3}.remove(2) → {1,3} |
set.discard(x) | 删除指定元素（不存在也不报错 ✅） | {1,2,3}.discard(5) → {1,2,3} |
set.pop() | 随机删除并返回一个元素 | {1,2,3}.pop() → 随机返回一个元素 |
set.clear() | 清空集合所有元素 | {1,2}.clear() → set() |
👍 次高频（经常用）
| 方法 | 作用 | 示例 |
|---|---|---|
set(iterable) | 将其他可迭代对象转换为集合（自动去重） | set([1,2,2,3]) → {1,2,3} |
set.update(iter) | 将其他可迭代对象添加到集合中 | {1,2}.update([3,4]) → {1,2,3,4} |
set.copy() | 浅拷贝集合 | {1,2}.copy() → {1,2} |
set1.union(set2) 或 | | 并集：返回两个集合的并集 | {1,2}.union({2,3}) → {1,2,3} |
set1.intersection(set2) 或 & | 交集：返回两个集合的交集 | {1,2} & {2,3} → {2} |
set1.difference(set2) 或 - | 差集：返回在 set1 但不在 set2 的元素 | {1,2} - {2,3} → {1} |
set1.symmetric_difference(set2) 或 ^ | 对称差集：返回不同时在两个集合中的元素 | {1,2} ^ {2,3} → {1,3} |
💡 低频但实用（特定场景）
| 方法 | 作用 | 示例 |
|---|---|---|
set1.issubset(set2) 或 <= | 判断 set1 是否是 set2 的子集 | {1,2}.issubset({1,2,3}) → True |
set1.issuperset(set2) 或 >= | 判断 set1 是否是 set2 的超集 | {1,2,3}.issuperset({1,2}) → True |
set1.isdisjoint(set2) | 判断两个集合是否没有交集 | {1,2}.isdisjoint({3,4}) → True |
min(set) | 获取集合中的最小值 | min({3,1,2}) → 1 |
max(set) | 获取集合中的最大值 | max({3,1,2}) → 3 |
sum(set) | 对集合中的数字求和 | sum({1,2,3}) → 6 |
sorted(set) | 返回排序后的列表（原集合不变） | sorted({3,1,2}) → [1,2,3] |
any(set) | 判断是否有元素为 True | any({0, False, 1}) → True |
all(set) | 判断是否所有元素为 True | all({1, 2, 3}) → True |
💡 集合典型应用场景
# 1. 列表去重（最常用！）
num_list = [10, 10, 20, 10, 30, 40, 60, 50]
new_num_list = list(set(num_list))
print(new_num_list) # [40, 10, 50, 20, 60, 30]（顺序可能不同）
# 2. 取两个列表的共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = set(list1) & set(list2)
print(common) # {4, 5}
# 3. 取两个列表的差集（在 list1 但不在 list2 中）
diff = set(list1) - set(list2)
print(diff) # {1, 2, 3}
# 4. 取两个列表的并集
union = set(list1) | set(list2)
print(union) # {1, 2, 3, 4, 5, 6, 7, 8}
# 5. 快速判断元素是否在大量数据中（集合查找比列表快得多）
# 列表查找：O(n) 集合查找：O(1)
五、字典
1. 字典概述
字典：用大括号 {} 包裹，每个元素是键值对 key: value。
特点：字典是可变类型，键不能重复且只能是不可变类型，值可以是任意类型。
⚠️ 注意：
- 字典不支持索引（没有下标），但可以根据键
key获取值value- 字典的键如果重复，后面的值会覆盖前面的值
示例：d = {"name": "张三", "age": 18, "city": "北京"}
2. 字典的定义方式
# 1. 定义空字典（2种方式）
d1 = {}
print(d1, type(d1)) # {} <class 'dict'>
d1 = dict()
print(d1, type(d1)) # {} <class 'dict'>
# 2. 定义非空字典
# ⚠️ 如果 key 重复，后面的值会覆盖前面的值
d2 = {"name": "张三", "age": 18}
print(d2) # {'name': '张三', 'age': 18}
d2 = {"name": "张三", "age": 18, "name": "李四"}
print(d2) # {'name': '李四', 'age': 18} ← 覆盖了
特别注意：字典的键必须是不可变类型（字符串、数字、元组），值可以是任意类型。
3. 字典的嵌套
stu_score = {
"张三": {"语文": 88, "数学": 99, "英语": 92},
"李四": {"语文": 82, "数学": 95, "英语": 88},
"王五": {"语文": 90, "数学": 97, "英语": 85}
}
# 根据 key 获取值
# 1. 直接通过 key 获取（如果 key 不存在会报错 ❌）
print(stu_score["张三"]) # {'语文': 88, '数学': 99, '英语': 92}
print(stu_score["张三"]["语文"]) # 88
# 2. 通过 get() 获取（如果 key 不存在返回 None，不报错 ✅）
print(stu_score.get("张三")) # {'语文': 88, '数学': 99, '英语': 92}
print(stu_score.get("张三").get("语文")) # 88
print(stu_score.get("赵六")) # None（不报错）
4. 字典常用方法速查表（按开发频率排序）
⚠️ 字典不支持索引，通过
key访问值！
🔥 高频使用（天天见）
| 方法 | 作用 | 示例 |
|---|---|---|
len(dict) | 获取字典键值对的数量 | len({'a':1, 'b':2}) → 2 |
dict[key] | 根据 key 获取 value（不存在报错 ❌） | d['name'] → '张三' |
dict.get(key) | 根据 key 获取 value（不存在返回 None ✅） | d.get('name') → '张三' |
key in dict | 判断 key 是否在字典中 | 'name' in d → True |
key not in dict | 判断 key 是否不在字典中 | 'age' not in d → False |
dict[key] = value | 新增或修改键值对（key 不存在则新增，存在则修改） | d['age'] = 18 |
del dict[key] | 删除指定 key 的键值对（不存在报错） | del d['name'] |
dict.pop(key) | 删除指定 key 并返回对应的 value | d.pop('name') → '张三' |
dict.clear() | 清空字典所有键值对 | d.clear() → {} |
👍 次高频（经常用）
| 方法 | 作用 | 示例 |
|---|---|---|
dict.keys() | 获取所有 key 的视图对象 | d.keys() → dict_keys(['name', 'age']) |
dict.values() | 获取所有 value 的视图对象 | d.values() → dict_values(['张三', 18]) |
dict.items() | 获取所有 (key, value) 元组的视图对象 | d.items() → dict_items([('name','张三'), ('age',18)]) |
dict.update(other) | 将其他字典的键值对更新到当前字典 | d.update({'city': '北京'}) |
dict.copy() | 浅拷贝字典 | d.copy() → {'name':'张三', 'age':18} |
dict.popitem() | 随机删除并返回一个键值对（元组） | d.popitem() → ('age', 18) |
dict.setdefault(key, default) | 如果 key 不存在则添加并返回默认值，存在则返回原值 | d.setdefault('city', '北京') → '北京' |
💡 低频但实用（特定场景）
| 方法 | 作用 | 示例 |
|---|---|---|
dict.fromkeys(keys, value) | 用指定的键和值创建新字典（类方法） | dict.fromkeys(['a','b'], 0) → {'a':0, 'b':0} |
dict.get(key, default) | 获取值，不存在返回自定义默认值 | d.get('city', '未知') → '未知' |
sorted(dict) | 返回排序后的 key 列表 | sorted({'b':2, 'a':1}) → ['a', 'b'] |
max(dict) | 获取 key 的最大值 | max({'a':1, 'b':2}) → 'b' |
min(dict) | 获取 key 的最小值 | min({'a':1, 'b':2}) → 'a' |
len(dict) | 键值对个数 | len({'a':1, 'b':2}) → 2 |
str(dict) | 将字典转为字符串 | str({'a':1}) → "{'a': 1}" |
💡 字典遍历方式
score = {"语文": 88, "数学": 99, "英语": 100}
# 1. 遍历 keys（键）
for key in score.keys():
print(key) # 语文 数学 英语
# 2. 遍历 values（值）
for value in score.values():
print(value) # 88 99 100
# 3. 遍历 items（键值对）— 最常用！ ✅
for key, value in score.items():
print(f"{key}: {value}") # 语文: 88 数学: 99 英语: 100
# 4. 直接遍历字典（默认遍历 keys）
for key in score:
print(key) # 语文 数学 英语
⚠️ 五种容器类型大对比
| 对比项 | 字符串 str | 列表 list | 元组 tuple | 集合 set | 字典 dict |
|---|---|---|---|---|---|
| 符号 | "" / '' / """""" | [] | () | {}（不能为空） | {key: value} |
| 是否可变 | ❌ 不可变 | ✅ 可变 | ❌ 不可变 | ✅ 可变 | ✅ 可变 |
| 是否有序 | ✅ 有序 | ✅ 有序 | ✅ 有序 | ❌ 无序 | ✅ 有序（Python 3.7+） |
| 是否可重复 | ✅ 允许重复 | ✅ 允许重复 | ✅ 允许重复 | ❌ 自动去重 | ❌ key 唯一 |
| 是否支持索引 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ❌ 不支持 | ❌ 不支持（通过 key 访问） |
| 元素类型 | 只能是字符 | 任意类型 | 任意类型 | 不可变类型 ✅ | key 必须不可变 |
| 查找效率 | O(n) 较慢 | O(n) 较慢 | O(n) 较慢 | O(1) 极快 ✅ | O(1) 极快 ✅ |
| 适用场景 | 文本处理、字符串操作 | 需要频繁修改、有顺序的数据 | 固定不变、有顺序的数据 | 去重、交集并集运算、快速查找 | Key-Value 映射关系 |
💡 开发建议：
- 字符串：文本处理首选，不可变特性使其更安全
- 列表：最常用的容器，适合存储同类型数据，支持增删改查
- 元组：数据不需要修改时优先使用，更安全、更快、更省内存
- 集合：需要去重或集合运算时使用，查找速度极快
- 字典：需要建立映射关系时使用，通过 key 快速查找 value
