• 该笔记整理自牛客Python语法题库：Python入门到实践四十招
• 主要通过刷题中不熟悉的语法知识结合豆包进行知识点查询，本笔记源自对对话结果的整理。

01 Python 格式化输出

Python 提供了3种最常用的格式化输出方式，从简单到灵活依次是：

1. f-string 格式化（Python 3.6+，推荐首选）
2. str.format() 方法
3. % 占位符（旧式写法，了解即可）

下面用最清晰的示例教你快速掌握。

---

1. f-string 格式化（最简单、最常用）

直接在字符串前加 f，变量用 {变量名} 嵌入，代码最简洁。

基础用法

name = "小明"
age = 20
score = 95.5

# 直接拼接变量
print(f"姓名：{name}，年龄：{age}，分数：{score}")

输出：

姓名：小明，年龄：20，分数：95.5

高级用法（保留小数、对齐、进制）

pi = 3.1415926

# 保留2位小数
print(f"圆周率：{pi:.2f}")

# 整数补零（总长度3）
print(f"编号：{12:03d}")

# 进制转换（二进制/十六进制）
print(f"10的二进制：{10:b}，十六进制：{10:x}")

输出：

圆周率：3.14
编号：012
10的二进制：1010，十六进制：a

---

常用格式化符号速查

符号	作用	示例
:d	整数	f"{10:d}"
:f	浮点数	f"{3.14:f}"
:.2f	保留2位小数	f"{3.1415:.2f}"
:05d	整数补零到5位	f"{12:05d}"
:b	二进制	f"{10:b}"
:x	小写十六进制	f"{10:x}"

02 Python内置函数 | 各进制互转

一、内置函数速查表（十进制 ↔ 二/八/十六进制）

功能	函数	示例	输出
十进制 → 二进制字符串	bin(n)	bin(10)	'0b1010'
十进制 → 八进制字符串	oct(n)	oct(10)	'0o12'
十进制 → 十六进制字符串	hex(n)	hex(10)	'0xa'
任意进制字符串 → 十进制	int(s, base)	int('1010',2)	10

说明：

• bin/oct/hex 结果自带前缀：0b(二进制)、0o(八进制)、0x(十六进制)
• int(字符串, 进制) 是万能转十进制，base 可取 2~36

---

二、进制互转完整示例

1. 其他进制字符串 → 十进制

# 二进制串 → 十进制
print(int("1101", 2))   # 13

# 八进制串 → 十进制
print(int("77", 8))     # 63

# 十六进制串 → 十进制
print(int("FF", 16))   # 255

2. 十进制 → 二/八/十六进制

n = 255
print(bin(n))   # '0b11111111' 二进制
print(oct(n))   # '0o377'      八进制
print(hex(n))   # '0xff'       十六进制

3. 不带前缀，纯数字字符串

用格式化输出去掉前缀：

n = 10
print(f"{n:b}")   # 1010  纯二进制
print(f"{n:o}")   # 12    纯八进制
print(f"{n:x}")   # a     纯十六进制小写
print(f"{n:X}")   # A     纯十六进制大写

---

三、跨进制直接互转（不经十进制）

例：二进制字符串 → 十六进制

# 先转十进制，再转十六进制
b_str = "101011"
d = int(b_str, 2)
h_str = f"{d:X}"
print(h_str)  # 2B

---

四、总结口诀

1. 转二进制：bin()
2. 转八进制：oct()
3. 转十六进制：hex()
4. 任意进制转回十进制：int(字符串, 进制)
5. 要无前缀纯字符串：用 f-string 格式化 :b :o :x :X

03 Python 字符串大小写控制 3个核心方法

1. 全小写 lower()

s = "Hello World"
res = s.lower()
print(res)   # hello world

2. 全大写 upper()

s = "Hello World"
res = s.upper()
print(res)   # HELLO WORLD

3. 首字母大写、其余小写 capitalize()

只整个字符串第一个字母大写，其他全部变小写：

s = "hello WORLD"
res = s.capitalize()
print(res)   # Hello world

4. 每个单词首字母大写 title()

空格分隔的每个单词首字母都大写：

s = "hello python world"
res = s.title()
print(res)   # Hello Python World

---

快速汇总表

方法	作用
s.lower()	全部转小写
s.upper()	全部转大写
s.capitalize()	整句首字母大写，其余小写
s.title()	每个单词首字母大写

小技巧：判断是否大小写

s.islower()   # 是否全小写
s.isupper()   # 是否全大写

04 Python 字符串去除两边空格 + 格式化输出

Python 自带内置字符串方法，专门用来去除空格，非常简单好用。

1. 核心方法：去除【两边】空格

strip() —— 专门去掉字符串左边 + 右边的所有空格（中间空格保留）

s = "  Hello Python  "
# 去除两边空格
new_s = s.strip()
print(new_s)  # 输出：Hello Python

---

2. 常用组合：去空格 + 格式化输出

直接在 f-string / print 里一边去空格一边输出：

s = "  小明  "
# f-string 格式化 + 自动去两边空格
print(f"姓名：{s.strip()}")

输出：

姓名：小明

---

3. 扩展：只去左边 / 只去右边

• lstrip()：只去掉左边空格
• rstrip()：只去掉右边空格

s = "  hello world  "
print(s.lstrip())  # 去掉左边：hello world  
print(s.rstrip())  # 去掉右边：  hello world
print(s.strip())   # 去掉两边：hello world

---

4. 超级常用组合（去空格 + 大小写）

s = "  HeLLo PyThon  "

res = s.strip().lower()  # 去空格 + 全小写
print(res)  # hello python

---

一句话速记

• 去除两边空格：字符串.strip()
• 去除左边空格：字符串.lstrip()
• 去除右边空格：字符串.rstrip()

直接和 f-string 格式化输出一起用最方便！

05 Python 输入 + map 批量类型转换 超全用法

核心语法

# 读取一行输入，按空格分割，批量转类型
变量1, 变量2... = map(类型, input().split())

---

1. 输入两个整数

# 输入：10 20
a, b = map(int, input().split())
print(a, b)
print(type(a))  # int

2. 输入两个浮点数

# 输入：3.14 2.5
x, y = map(float, input().split())
print(x, y)

3. 多个数存列表（常用）

不知道个数，全部转整数存列表：

# 输入：1 2 3 4 5
lst = list(map(int, input().split()))
print(lst)  # [1,2,3,4,5]

4. 输入字符串批量处理

# 输入：hello python
s1, s2 = map(str, input().split())
# str可以省略，split默认就是字符串

5. 进阶：一行输入多类型（少用）

# 输入：10 3.14 abc
arr = input().split()
a = int(arr[0])
b = float(arr[1])
c = arr[2]

6. 指定分隔符（不是空格）

以逗号 , 分割：

# 输入：1,2,3
lst = list(map(int, input().split(',')))
print(lst)  # [1,2,3]

---

必背口诀

1. 两个变量：a,b = map(int, input().split())
2. 多个变量列表：lst = list(map(int, input().split()))
3. 改分隔符：split(',') 换成逗号即可

06 Python 列表(list) 常用内置方法汇总表

列表常用操作方法一览表

方法	语法	功能说明	示例
append	lst.append(x)	尾部追加单个元素	[1,2].append(3) → [1,2,3]
extend	lst.extend(可迭代对象)	尾部批量追加多个元素	[1,2].extend([3,4]) → [1,2,3,4]
insert	lst.insert(索引, x)	在指定索引位置插入元素	[1,3].insert(1,2) → [1,2,3]
pop	lst.pop(索引)	删除并返回指定索引元素，默认删最后一个	[1,2,3].pop() → 3
remove	lst.remove(x)	删除第一个匹配的指定元素	[1,2,2,3].remove(2) → [1,2,3]
clear	lst.clear()	清空列表所有元素，保留空列表	[1,2].clear() → []
del	del lst[索引]	删除指定索引元素（内置语句，非方法）	lst=[1,2,3]; del lst[1] → [1,3]
index	lst.index(x)	返回元素第一次出现的索引	[1,2,3].index(2) → 1
count	lst.count(x)	统计元素出现次数	[1,2,2].count(2) → 2
sort	lst.sort()	原地升序排序，直接修改原列表	[3,1,2].sort() → [1,2,3]
reverse	lst.reverse()	原地反转列表顺序	[1,2,3].reverse() → [3,2,1]
copy	lst.copy()	浅拷贝生成新列表	a=[1,2]; b=a.copy()

补充：Python 全局内置函数（作用于列表）

函数	作用	示例
len(lst)	获取列表元素个数	len([1,2,3]) → 3
max(lst)	获取列表最大值	max([1,5,3]) → 5
min(lst)	获取列表最小值	min([1,5,3]) → 1
sum(lst)	列表元素求和（仅限数字）	sum([1,2,3]) → 6
sorted(lst)	返回新排序列表，不改动原列表	sorted([3,1,2])

• sorted(lst,reverse=True)，返回降序排列的列表。

易混小结

1. append 加整体；extend 拆开来加
2. pop 删了能拿值；remove 只删不返回
3. sort() 改原列表；sorted() 生成升序新列表，reverse=True为降序
4. reverse() 原地反转；切片 lst[::-1] 生成新反转列表

07 Python 接收【不定行输入】三种常用方法（随时停止、不限行数）

方法一：回车空行结束（最常用）

不停输入，输入空回车就停止

lines = []
while True:
    line = input()
    if not line:   # 读入空字符串，结束
        break
    lines.append(line)

print("你输入的所有内容：")
for s in lines:
    print(s)

方法二：指定特殊结束符（如输入 exit 结束）

随便输多少行，输入 exit 停止

lines = []
while True:
    line = input("请输入(输入exit结束)：")
    if line == "exit":
        break
    lines.append(line)

print(lines)

方法三：读取控制台所有输入（适合刷题/EOF 结束）

Windows：Ctrl+Z 结束
Mac/Linux：Ctrl+D 结束

import sys

# 一次性读取所有行
lines = [line.strip() for line in sys.stdin]
print(lines)

---

刷题常用简写（一行读所有不定行）

import sys
data = sys.stdin.read().splitlines()
print(data)

08 Python 列表解析式（List Comprehension）

作用：用一行代码快速生成/处理列表，替代普通 for 循环，简洁、运行更快。

一、基础语法

[表达式 for 变量 in 可迭代对象]

等价普通循环：

res = []
for 变量 in 可迭代对象:
    res.append(表达式)

示例1：生成 1~10 列表

# 列表解析式
lst = [i for i in range(1, 11)]
print(lst)  # [1,2,3,4,5,6,7,8,9,10]

示例2：全部平方

square = [i*i for i in range(1,6)]
print(square)  # [1, 4, 9, 16, 25]

---

二、带条件筛选（if）

语法：

[表达式 for 变量 in 可迭代对象 if 条件]

示例：只保留偶数

even = [i for i in range(1,11) if i % 2 == 0]
print(even)  # [2,4,6,8,10]

---

三、双层循环解析式

语法：

[表达式 for 变量1 in 迭代1 for 变量2 in 迭代2]

示例：二维转一维

matrix = [[1,2],[3,4],[5,6]]
flat = [x for row in matrix for x in row]
print(flat)  # [1,2,3,4,5,6]

---

四、带 if-else 表达式

语法：

[表达式1 if 条件 else 表达式2 for 变量 in 迭代]

示例：偶数不变，奇数变0

res = [i if i%2==0 else 0 for i in range(1,6)]
print(res)  # [0,2,0,4,0]

---

五、优点

1. 代码极简一行，代替多行 for 循环
2. 执行效率比普通 for + append 更高
3. 可读性强，适合简单生成、筛选、转换列表

六、使用建议

• 简单生成、筛选：优先用列表解析式
• 逻辑特别复杂、多层嵌套太深：改用普通 for 循环，可读性更好

09 Python 快速生成多维列表（二维/三维）

一、最常用：列表解析式生成二维列表

1. 生成 3行4列 全0矩阵

# 3行4列
arr = [[0 for _ in range(4)] for _ in range(3)]
print(arr)
# [[0,0,0,0], [0,0,0,0], [0,0,0,0]]

2. 生成规律二维列表

# 1~3 每行翻倍
arr = [[i * j for j in range(1,4)] for i in range(1,4)]
print(arr)

---

二、❌ 千万别用错误写法（大坑）

很多人图省事这么写，会引发引用复用bug：

# 错误！千万别这么写
arr = [[0]*4] * 3

特点：三行是同一个列表引用，改一行全变：

arr[0][1] = 99
print(arr)  
# 所有行第2位都变成99

原理：[0]*4 创建一个列表，再复制3次引用，不是3个独立列表。

---

三、快速生成一维再转二维

# 先一维，再切片分二维
lst = list(range(12))
arr = [lst[i:i+4] for i in range(0,12,4)]
print(arr)

---

四、生成三维列表

语法嵌套即可：

# 2层3行4列 全0三维列表
arr = [[[0 for _ in range(4)] for _ in range(3)] for _ in range(2)]

---

五、极简速记

1. 正确标准写法：[[val for 列 in 列数] for 行 in 行数]
2. 禁止：[[0]*n]*m 会浅拷贝共用地址
3. 几维就嵌套几层列表解析式

10 Python 异常处理机制 超清晰完整版

一、什么是异常

程序运行时出错（除零、索引越界、类型错误、文件不存在等），不处理就直接崩溃退出，异常处理就是用来捕获错误、程序不崩、优雅容错。

二、核心语法结构

基础完整结构

try:
    # 可能出错的代码
except 错误类型1:
    # 处理类型1异常
except 错误类型2 as e:
    # 处理类型2异常，e是异常对象
except:
    # 捕获所有未知异常
else:
    # try 没报错才执行
finally:
    # 无论是否报错，**一定会执行**

---

三、各关键字作用

1. try
   包裹可能抛出异常的代码块。

2. except
   捕获指定类型异常，写多个可区分不同错误。

• except ZeroDivisionError: 只捕获除零错误
• except: 兜底捕获所有异常（不推荐滥用）

3. as e
   把异常实例赋值给 e，可以打印错误信息：

except Exception as e:
    print("错误原因：", e)

4. else
   try 代码没异常 才会执行，有异常就跳过。

5. finally
   无论报错与否必执行，常用于：关闭文件、释放资源、数据库断开。

---

四、常见内置异常类型

• ZeroDivisionError：除零错误
• IndexError：列表索引越界
• KeyError：字典键不存在
• ValueError：数值类型错误（如把字母转数字）
• TypeError：类型不匹配
• FileNotFoundError：文件不存在
• Exception：所有异常的父类

---

五、实战示例

示例1：除数容错

try:
    a = int(input("请输入数字："))
    print(10 / a)
except ZeroDivisionError:
    print("不能除以0！")
except ValueError:
    print("请输入合法数字！")
else:
    print("计算正常完成")
finally:
    print("程序执行结束")

示例2：主动抛出异常 raise

自己手动触发异常，用于参数校验：

def age_check(age):
    if age < 0:
        raise ValueError("年龄不能为负数")
    print("年龄合法")

try:
    age_check(-5)
except ValueError as e:
    print("捕获异常：", e)

示例3：自定义异常

自己定义异常类，业务场景专用：

class MyError(Exception):
    pass

try:
    raise MyError("自定义错误触发")
except MyError as e:
    print(e)

---

六、使用原则

1. 不要裸写 except: 吞掉所有错误，不利于调试；
2. 能预判的错误精准捕获具体异常类型；
3. 资源释放（文件、连接）放 finally；
4. 正常业务逻辑不要用异常代替条件判断。

---

七、极简总结

• try 放危险代码
• except 抓错误、做处理
• else 无错执行
• finally 必执行、清资源
• raise 手动抛异常
• 可自定义异常类

11 Python 字典（dict）常用方法大全

字典是键值对结构，下面按最常用 → 进阶整理，附示例，考试/刷题高频。

先定义一个示例字典：

d = {"name":"Tom", "age":18, "gender":"male"}

一、获取键、值、键值对

1. dict.keys()
   获取所有键，返回可迭代对象

print(d.keys())  # dict_keys(['name', 'age', 'gender'])

2. dict.values()
   获取所有值

print(d.values())  # dict_values(['Tom', 18, 'male'])

3. dict.items()
   获取所有 (键,值) 元组

print(d.items())
# dict_items([('name', 'Tom'), ('age', 18), ('gender', 'male')])
# 常用于遍历：for k,v in d.items():

---

二、安全取值（重点！）

4. dict.get(key, default=None)

• 键存在：返回对应值
• 键不存在：返回 None，或你指定的默认值，不报错

print(d.get("height"))        # None
print(d.get("height", 170))   # 170

5. dict.setdefault(key, default)

• 键存在：返回原值
• 键不存在：添加该键值对，返回默认值

d.setdefault("height", 170)
print(d)  # 新增 height:170

---

三、增、改、删

6. dict.update(其他字典/键值对)
   批量添加/修改键值对

d.update({"age":20, "score":90})
print(d)  # age更新为20，新增score

7. dict.pop(key)
   删除指定键，返回对应值；键不存在报错

d.pop("gender")  # 删除gender，返回male

8. dict.popitem()
   删除最后插入的键值对（Python3.7+有序），返回元组

d.popitem()

9. dict.clear()
   清空字典，变为空字典

d.clear()
print(d)  # {}

---

四、其他常用方法

10. dict.copy()
    浅拷贝字典，生成新字典

d2 = d.copy()

11. dict.fromkeys(序列, 默认值)
    快速创建字典，所有键初始值相同

new_d = dict.fromkeys(["a","b","c"], 0)
print(new_d)  # {'a':0, 'b':0, 'c':0}

---

高频记忆总结

• 查全部：keys()、values()、items()
• 安全取：get() 不报错；setdefault() 不存在就新增
• 删：pop()删指定、popitem()删最后、clear()清空
• 增改：update()批量更新
• 建：fromkeys()快速初始化

12 Python zip() 函数详解

一、基本作用

zip() 把多个可迭代对象（列表、元组、字符串等），按位置配对打包成元组，返回一个 zip 对象（迭代器）。

语法：

zip(*iterables)

---

二、基础用法

1. 两个列表配对

a = [1, 2, 3]
b = ['x', 'y', 'z']

res = zip(a, b)
print(list(res))
# [(1, 'x'), (2, 'y'), (3, 'z')]

2. 多个序列一起打包

a = [1,2]
b = [3,4]
c = [5,6]
print(list(zip(a,b,c)))
# [(1, 3, 5), (2, 4, 6)]

---

三、长度不一样时

以最短的序列为准，多余部分直接舍弃

a = [1,2,3,4]
b = ['a','b']
print(list(zip(a,b)))
# [(1, 'a'), (2, 'b')]

---

四、zip 解压（反向操作：*解包）

用 * 把打包后的 zip 对象还原成原来的序列

a = [1,2,3]
b = ['x','y','z']
z = list(zip(a,b))

# 解压
a2, b2 = zip(*z)
print(a2)  # (1, 2, 3)
print(b2)  # ('x', 'y', 'z')

---

五、常用实战场景

1. 快速生成字典

keys = ['name','age']
vals = ['Tom',18]
d = dict(zip(keys, vals))
print(d)  # {'name': 'Tom', 'age': 18}

2. 同时遍历两个列表

names = ['A','B']
ages = [18,20]
for n,a in zip(names, ages):
    print(n, a)

---

六、关键特点总结

1. 返回迭代器，用 list() 转成列表查看
2. 配对长度 = 最短序列长度
3. zip(*x) 实现解压
4. 常用于：并行遍历、字典构建、行列转置

13 Python中一句话打印，元素空格隔开（3种最常用写法）

假设列表：

lst = [1, 2, 3, 4, 5]

方法1（最简单，推荐）

print(' '.join(map(str, lst)))

输出：1 2 3 4 5

原理：

• map(str, lst)：把所有元素转成字符串
• ' '.join(...)：用空格连接

方法2（直接打印，自带空格）

print(*lst)

输出：1 2 3 4 5

• * 解包列表，相当于 print(1,2,3,4,5)
• print 默认用空格分隔

方法3（字符串列表直接join）

lst = ["a","b","c"]
print(' '.join(lst))

---

一句话速记

• 数字/混合类型：print(*lst) 最省事
• 要字符串结果：' '.join(map(str, lst))

14 Python 用字典优雅实现计数器（4种写法，从基础到最优）

假设计数目标：统计列表中每个元素出现次数

data = [1,2,2,3,3,3,4]

---

方式1：原生 dict + get（最通用、优雅）

用 dict.get() 安全取值，不存在默认0，一行更新

cnt = {}
for x in data:
    cnt[x] = cnt.get(x, 0) + 1
print(cnt)  # {1:1, 2:2, 3:3, 4:1}

优点：代码简洁、无异常、原生字典、不用导入

---

方式2：dict.setdefault 写法

cnt = {}
for x in data:
    cnt.setdefault(x, 0)
    cnt[x] += 1

---

方式3：collections.defaultdict（最适合连续计数）

自动给不存在的键默认值0

from collections import defaultdict
cnt = defaultdict(int)
for x in data:
    cnt[x] += 1
# 可直接转普通字典：dict(cnt)

---

方式4：collections.Counter（终极优雅，专门做计数）

一行直接搞定，最推荐

from collections import Counter
cnt = Counter(data)
print(cnt)

• 自带 most_common(n) 取出现最多的前n个

print(cnt.most_common(2))  # 出现最多前2个：[(3,3), (2,2)]

---

选型总结

1. 不想导入模块 → 用 dict.get()：cnt[x] = cnt.get(x,0)+1
2. 大量计数场景 → defaultdict(int)
3. 直接统计频率 → Counter（最强、最优雅）

15 Python collections.Counter 超全讲解（专门用来计数）

Counter 是 Python 内置模块 collections 里的字典子类，专门用于统计可迭代对象中元素出现次数，比自己写字典计数器优雅太多。

1. 导入 & 基本创建

from collections import Counter

# 1. 从列表/元组/字符串创建
c1 = Counter([1,2,2,3,3,3])
c2 = Counter("abracadabra")
c3 = Counter(a=2, b=3)  # 直接传键值对

print(c1)  # Counter({3: 3, 2: 2, 1: 1})

2. 核心常用方法（必背）

① 直接访问计数（像字典一样）

c = Counter([1,2,2,3])
print(c[2])   # 2
print(c[99])  # 不存在返回 0，**不会报 KeyError**！

② most_common(n)：取出现最多的前 n 个

c = Counter([1,2,2,3,3,3,4])
print(c.most_common())       # 全部，降序：[(3,3),(2,2),(1,1),(4,1)]
print(c.most_common(2))      # 前2个：[(3, 3), (2, 2)]

③ elements()：按次数展开成迭代器

c = Counter({2:2,3:3})
print(list(c.elements()))  # [2,2,3,3,3]

④ subtract()：减法计数（次数相减）

c1 = Counter(a=3, b=2)
c2 = Counter(a=1, b=1)
c1.subtract(c2)
print(c1)  # Counter({'a': 2, 'b': 1})
# 允许负数

⑤ update()：增加计数（合并）

c = Counter([1,2])
c.update([2,3])
print(c)  # Counter({2:2, 1:1, 3:1})

3. 支持字典操作

c = Counter([1,2,2])
print(c.keys())
print(c.values())
print(c.items())

# 转普通字典
d = dict(c)

4. 数学运算（+ - & |）

• +：次数相加
• -：次数相减（去掉≤0）
• &：取最小次数（交集）
• |：取最大次数（并集）

c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)  # a:4, b:3
print(c1 - c2)  # a:2
print(c1 & c2)  # a:1, b:1
print(c1 | c2)  # a:3, b:2

5. 对比普通 dict 优势

1. 键不存在默认返回0，不用 get
2. 自带 most_common 直接取高频元素
3. 自带加减、合并、展开，一行搞定统计
4. 代码极度简洁，刷题/数据分析神器

一句话使用模板

from collections import Counter
cnt = Counter(可迭代对象)

16 Python 常用内置函数总结表

按功能分类，刷题、考试、日常开发高频，精简好记

一、类型转换类

函数	作用	示例
int(x)	转整数	int('12') → 12
float(x)	转浮点数	float('3.14')
str(x)	转字符串	str(123) → '123'
bool(x)	转布尔值	bool(0)→False
list(x)	转列表	list((1,2))→[1,2]
tuple(x)	转元组	tuple([1,2])→(1,2)
dict()	创建字典	dict(a=1)
set(x)	转集合（去重）	set([1,2,2])

二、数学运算类

函数	作用	示例
abs(x)	绝对值	abs(-5) →5
max(iter)	最大值	max([1,3,2])
min(iter)	最小值	min([1,3,2])
sum(iter)	求和	sum([1,2,3])
pow(a,b)	幂运算	pow(2,3)=8
round(x,n)	四舍五入	round(3.1415,2)

三、序列操作类（列表/元组/字符串）

函数	作用	示例
len(x)	获取长度	len('abc')=3
sorted(x)	排序，返回新列表	sorted([3,1,2])
reversed(x)	反转迭代器	list(reversed([1,2]))
enumerate(x)	带索引遍历	for i,v in enumerate(lst)
zip(*iter)	打包配对	zip([1,2],[3,4])

四、高阶函数（迭代/映射/过滤）

函数	作用	简单示例
map(func, iter)	批量映射	map(str,[1,2])
filter(func, iter)	过滤元素	filter(lambda x:x>0, lst)
all(iter)	全部为真返回True	all([1,2,3])
any(iter)	任意一个为真返回True	any([0,1])

五、输入输出 & 对象类

函数	作用
input()	接收控制台输入
print()	打印输出
type(x)	返回数据类型
isinstance(x,类型)	判断是否属于该类型
id(x)	获取内存地址

六、字符串/编码常用

函数	作用
ord(c)	字符转ASCII码
chr(n)	ASCII码转字符

---

极简记忆口诀

• 转换：int float str list tuple set
• 数学：abs max min sum pow round
• 序列：len sorted zip enumerate
• 高阶：map filter all any
• IO：input print type isinstance

17 Python 字符串常用方法（精简表格版）

1. 大小写转换

方法	功能
s.upper()	全部转大写
s.lower()	全部转小写
s.capitalize()	首字母大写，其余小写
s.title()	每个单词首字母大写

2. 查找与统计

方法	功能
s.find(sub)	查找子串，返回下标，找不到返回 -1
s.index(sub)	查找子串，找不到直接报错
s.count(sub)	统计子串出现次数
s.startswith(x)	判断是否以 x 开头
s.endswith(x)	判断是否以 x 结尾

3. 字符判断（返回布尔值）

方法	功能
s.isdigit()	是否全为数字
s.isalpha()	是否全为字母
s.isalnum()	是否由字母+数字组成
s.isspace()	是否全为空白字符

4. 分割、拼接、替换

方法	功能
s.split(sep)	按分隔符分割成列表
s.rsplit(sep)	从右侧分割
sep.join(iter)	用 sep 连接可迭代对象
s.replace(old, new)	替换子串

5. 去除空白 & 对齐

方法	功能
s.strip()	去除左右空白（空格、换行、制表符）
s.lstrip()	去除左侧空白
s.rstrip()	去除右侧空白
s.ljust(n, c)	左对齐，总长度n，不足补c
s.rjust(n, c)	右对齐
s.center(n, c)	居中对齐

18 Python 中的 hasattr 和 setattr 详解

hasattr 和 setattr 是 Python 内置的对象属性操作函数，专门用于动态操作对象的属性（不用提前写死属性名），搭配 getattr（获取属性）可以完成属性的查、改、增、删全操作。

它们的核心作用：

• hasattr：判断对象是否拥有指定名称的属性/方法
• setattr：动态设置/新增对象的属性值（属性不存在就创建，存在就修改）

---

一、hasattr(object, name)

语法

hasattr(对象, 属性名字符串)

功能

检查对象是否包含指定名称的属性或方法，返回布尔值：

• 有 → True
• 无 → False

示例代码

# 定义一个测试类
class Person:
    def __init__(self):
        self.name = "小明"  # 实例属性
    def say_hello(self):   # 实例方法
        print("你好")

# 创建对象
p = Person()

# 1. 判断是否有 name 属性
print(hasattr(p, "name"))   # True

# 2. 判断是否有 age 属性（不存在）
print(hasattr(p, "age"))    # False

# 3. 判断是否有 say_hello 方法
print(hasattr(p, "say_hello"))  # True

常用场景

1. 避免访问不存在的属性导致程序报错
2. 动态判断对象结构，适配不同数据格式

---

二、setattr(object, name, value)

语法

setattr(对象, 属性名字符串, 属性值)

功能

动态给对象设置属性：

• 如果属性已存在 → 修改属性值
• 如果属性不存在 → 新增属性

示例代码

class Person:
    def __init__(self):
        self.name = "小明"

p = Person()

# 1. 新增属性 age（原本没有）
setattr(p, "age", 18)
print(p.age)  # 18

# 2. 修改已有属性 name
setattr(p, "name", "小红")
print(p.name) # 小红

# 3. 动态变量作为属性名（最常用场景）
attr_name = "gender"
setattr(p, attr_name, "女")
print(p.gender) # 女

---

三、核心特点（必看）

1. 属性名必须是字符串
   这是动态操作的关键：hasattr(p, "name") ✅，hasattr(p, name) ❌
2. 不仅能操作实例属性，也能操作类属性
3. 方法也能被检测：hasattr 可以判断方法是否存在
4. 无权限限制：可以操作对象的所有属性（包括私有属性，不推荐）

---

四、组合使用（最实用）

先判断属性是否存在，再设置，防止意外覆盖：

class Student:
    pass

s = Student()

# 安全设置属性
if not hasattr(s, "score"):
    setattr(s, "score", 90)  # 不存在则新增

print(s.score)  # 90

---

总结

1. hasattr(obj, name)：判断对象是否有指定属性/方法，返回 True/False
2. setattr(obj, name, value)：动态新增/修改对象属性
3. 核心用途：动态编程（属性名不固定，用字符串传入）

19 Python 运算符重载（魔法方法重载）

Python 里不能直接重载函数名，但可以通过重写双下划线魔法方法（__xxx__），让自定义对象支持 + - * / > < == [] 等运算符，这就叫运算符重载。

核心：运算符 ↔ 对应魔法方法

---

一、常用运算符与对应魔法方法（必背）

运算符	魔法方法	作用
+	__add__(self, other)	加法
-	__sub__(self, other)	减法
*	__mul__(self, other)	乘法
/	__truediv__(self, other)	除法
==	__eq__(self, other)	等于
!=	__ne__(self, other)	不等于
>	__gt__(self, other)	大于
<	__lt__(self, other)	小于
>=	__ge__(self, other)	大于等于
<=	__le__(self, other)	小于等于
[] 索引	__getitem__(self, key)	取值 obj[key]
() 调用	__call__(self, *args)	对象当函数调用
str(obj)	__str__(self)	打印对象

---

二、完整示例：重载 +、==、[]

以二维向量举例，最经典：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 重载 +
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    # 重载 ==
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    # 重载 [] 索引
    def __getitem__(self, idx):
        if idx == 0:
            return self.x
        elif idx == 1:
            return self.y

    # 重载打印
    def __str__(self):
        return f"({self.x}, {self.y})"

# 测试
v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2)      # (4, 6)
print(v1 == v2)     # False
print(v1[0])        # 1

---

三、反向运算符重载（__radd__）

当数字 + 对象时，__add__ 不生效，需要 __radd__：

class Num:
    def __init__(self, n):
        self.n = n
    def __add__(self, other):
        return self.n + other
    def __radd__(self, other):
        return other + self.n

a = Num(5)
print(a + 3)   # 8
print(3 + a)   # 8（靠 __radd__）

---

四、常用重载速记口诀

1. 算术运算：+__add、-__sub、*__mul
2. 比较运算：==__eq、>__gt、<__lt
3. 索引取值：[] → __getitem__
4. 打印输出：__str__
5. 反向运算：加 r → __radd__

20 Python 正则表达式（re模块）超清晰总结

正则用来匹配、查找、替换、分割字符串，Python 用内置模块 re。

一、核心用法（4个最常用函数）

import re

1. re.match(pattern, s)
   从开头匹配，匹配到返回对象，否则 None

re.match(r'^abc', 'abcd')

2. re.search(pattern, s)
   全文搜索，找到第一个匹配就返回

re.search(r'\d+', 'a123b456')

3. re.findall(pattern, s)
   返回所有匹配结果，列表形式（最常用）

re.findall(r'\d+', 'a123b456')  # ['123','456']

4. re.sub(pattern, new, s)
   替换匹配内容

re.sub(r'\d', '*', 'a1b2')  # 'a*b*'

5. re.split(pattern, s)
   按正则分割字符串

re.split(r'\s+', 'a b  c')

---

二、常用正则符号（必背）

1. 元字符

符号	含义
.	任意单个字符（除换行）
^	开头
$	结尾
\d	数字 0-9
\D	非数字
\w	字母/数字/下划线
\W	非单词字符
\s	空白（空格、tab、换行）
\S	非空白

2. 量词（控制出现次数）

符号	含义
*	0次或多次
+	1次或多次
?	0次或1次
{n}	恰好n次
{n,}	至少n次
{n,m}	n~m次

3. 分组与或

• ()：分组，可提取内容
• |：或
• []：字符集，如 [0-9] [a-z] [aeiou]
• [^]：取反，[^0-9] 非数字

---

三、原始字符串 r’’ 重要

正则里 \ 容易转义冲突，一律用 r’’

re.findall(r'\d+', '123abc')

---

四、实战示例

1. 提取所有数字

s = "价格100，数量20"
print(re.findall(r'\d+', s))  # ['100','20']

2. 匹配手机号

phone = "13812345678"
res = re.match(r'^1[3-9]\d{9}$', phone)

3. 提取邮箱

email = "test@qq.com"
re.findall(r'\w+@\w+\.\w+', email)

4. 替换空格

re.sub(r'\s+', '', 'a b  c')  # 'abc'

---

五、贪婪与非贪婪（高频坑）

• .*、.+ 默认贪婪：尽可能多匹配
• .*?、.+? 非贪婪：尽可能少匹配

s = "<a>1</a><b>2</b>"
re.findall(r'<.*>', s)   # 贪婪：['<a>1</a><b>2</b>']
re.findall(r'<.*?>', s)   # 非贪婪：['<a>','</a>','<b>','</b>']

---

六、极简记忆

1. 模块：import re
2. 查全部：findall
3. 替换：sub
4. 开头匹配：match
5. 找第一个：search
6. 数字：\d，多次：+，任意：.
7. 非贪婪：加 ?

21 Python re 模块常用函数（精简版，考试/刷题必背）

先导入：

import re

一、核心匹配函数

1. re.match(pattern, string, flags=0)

• 只从字符串开头匹配
• 匹配成功返回匹配对象，失败返回 None

re.match(r'\d+', '123abc')   # 匹配
re.match(r'\d+', 'abc123')   # 不匹配

2. re.search(pattern, string, flags=0)

• 全文搜索，找到第一个匹配项就返回
• 不限制开头

re.search(r'\d+', 'abc123')  # 匹配到 123

3. re.findall(pattern, string, flags=0) 【最常用】

• 查找所有匹配内容，返回列表
• 有分组时，返回分组内容

re.findall(r'\d+', 'a1b2c3')  # ['1','2','3']

4. re.finditer(pattern, string, flags=0)

• 返回迭代器，每个元素是匹配对象
• 适合数据量大、节省内存

---

二、替换与分割

5. re.sub(pattern, repl, string, count=0, flags=0)

• 替换匹配到的内容
• count=0：全部替换；count=n：只替换前n个

re.sub(r'\d', '*', 'a1b2')  # 'a*b*'

6. re.split(pattern, string, maxsplit=0, flags=0)

• 按正则分割字符串，返回列表

re.split(r'\s+', 'a b  c')  # ['a','b','c']

---

三、编译与匹配对象（进阶）

7. re.compile(pattern, flags=0)

• 预编译正则，多次使用时效率更高

p = re.compile(r'\d+')
p.findall('123abc')

8. 匹配对象常用方法（match/search 返回的对象）

• .group()：返回匹配到的整体字符串
• .group(1)：返回第1个分组内容
• .start() / .end()：匹配起始、结束下标

m = re.search(r'(\d+)', 'a123b')
print(m.group())   # '123'
print(m.group(1))  # '123'

---

四、flags 常用标志

• re.I / re.IGNORECASE：忽略大小写
• re.S / re.DOTALL：. 匹配换行符
• re.M / re.MULTILINE：多行模式，^ $ 匹配每行首尾

---

一句话速记

• 开头匹配：match
• 找第一个：search
• 找全部：findall
• 替换：sub
• 分割：split
• 预编译：compile