Python►数据结构

常用内置函数汇总

Python 提供了 70 多个内置函数（built-in functions），它们不用 import 就能直接用。掌握它们，你能减少 50% 的手写循环代码。这一篇不是一个字典式的罗列，而是按用途分组——数值、序列、迭代、类型转换、面向对象、IO、反射——每类都举例说明什么时候用哪个。收藏本文，之后写代码前先来这里翻一下。

一、数值类

1
2
3
4
5
6
7
abs(-5)              # 5    绝对值
divmod(17, 5)        # (3, 2)  同时算商和余数
pow(2, 10)           # 1024   等价 2 ** 10
pow(2, 10, 1000)     # 24     快速幂取模，密码学常用
round(3.5)           # 4      银行家舍入（四舍六入五留双）
round(3.14159, 2)    # 3.14
round(2.5)           # 2      不是 3！

注意 round 的”银行家舍入”陷阱：round(0.5)、round(2.5)、round(4.5) 都朝偶数舍入。真正的”四舍五入”要用 decimal.Decimal 或者 math.floor(x + 0.5)。

min / max 也算数值类：

1
2
3
4
5
6
7
min(3, 1, 4, 1, 5, 9, 2, 6)
max([3, 1, 4])
min("banana")                    # 'a'   字符串按字典序
min(users, key=lambda u: u.age)  # 按 key 找最小

# default 参数
max([], default=0)               # 空序列不报错

sum 只对数字：

1
2
sum([1, 2, 3])
sum([1, 2, 3], start=100)        # 106

别用 sum 拼列表——性能巨差。用 itertools.chain 或 functools.reduce。

二、序列构造与转换

1
2
3
4
5
6
7
8
9
list(iter)           # 转列表
tuple(iter)          # 转元组
set(iter)            # 转集合
frozenset(iter)      # 转不可变集合
dict([("a", 1)])     # 转字典
str(x)               # 转字符串
bytes(iter)          # 转字节
bytearray(iter)      # 转可变字节
range(n)             # 数字序列

三、序列聚合

1
2
3
4
5
6
7
8
9
10
11
12
len(seq)             # 长度
sum(seq)             # 求和
min(seq), max(seq)   # 极值
sorted(seq)          # 排序（返回新列表）
sorted(seq, key=..., reverse=True)
reversed(seq)        # 反转迭代器
list(reversed([1, 2, 3]))    # [3, 2, 1]

any([False, True])   # True，任一为真
all([True, True])    # True，全为真
any([])              # False
all([])              # True   空的"全部为真"是空真

any / all 常和生成表达式搭配：

1
2
3
4
5
if any(x < 0 for x in nums):
    print("有负数")

if all(u.active for u in users):
    print("所有用户都活跃")

四、迭代辅助

1
2
3
4
5
6
7
8
enumerate(seq, start=0)         # 产生 (index, item)
zip(a, b)                       # 并行迭代，最短为准
zip(a, b, strict=True)          # Python 3.10+，长度不等抛错
map(func, iter)                 # 每个元素调用 func
filter(pred, iter)              # 保留 pred 返回真的
range(start, stop, step)        # 数字序列
iter(iterable)                  # 拿到迭代器
next(iterator, default)         # 取下一个

enumerate 常用

1
2
for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

zip 组合

1
2
for a, b, c in zip(list_a, list_b, list_c):
    ...

map 与 filter：现代 Python 更推荐推导式

1
2
3
4
5
6
7
8
9
# map
uppercase = list(map(str.upper, words))
# 等价推导式（更 Pythonic）
uppercase = [w.upper() for w in words]

# filter
positives = list(filter(lambda x: x > 0, nums))
# 等价推导式
positives = [x for x in nums if x > 0]

五、类型与检查

1
2
3
4
5
6
type(x)                          # 返回类型对象
isinstance(x, (int, float))      # x 是 int 或 float
issubclass(cls, base)            # cls 是不是 base 的子类
callable(x)                      # x 是不是可调用（函数/类/带 __call__）
id(x)                            # 对象唯一 id，一般不用
hash(x)                          # 计算哈希，不可哈希会报错

六、字符与编码

1
2
3
4
5
6
7
ord("A")            # 65
chr(65)             # 'A'
bin(10)             # '0b1010'
oct(10)             # '0o12'
hex(255)            # '0xff'
ascii("你好")        # "'\\u4f60\\u597d'"
repr(x)             # 对象的 repr，一般 print(repr(x))

七、IO 与文件

1
2
3
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
input(prompt)
open(path, mode="r", encoding="utf-8")

open 一般搭配 with，见 with 语句与上下文管理器。

八、对象与反射

1
2
3
4
5
6
getattr(obj, "name", default)    # 取属性，可给默认
setattr(obj, "name", value)      # 设属性
hasattr(obj, "name")             # 有没有该属性
delattr(obj, "name")             # 删属性
dir(obj)                         # 列出所有属性/方法
vars(obj)                        # 相当于 obj.__dict__

反射适合写”框架”代码，日常业务不用太深入。

getattr 的实用套路

1
2
3
4
5
6
7
# 根据用户输入的操作名调用方法
op = input("操作：")
handler = getattr(controller, f"do_{op}", None)
if handler:
    handler()
else:
    print("未知操作")

九、动态执行

1
2
3
eval("1 + 2")              # 3    求值一个表达式
exec("x = 5")              # 执行任意语句
compile(src, "<string>", "exec")  # 编译代码对象

警告：eval / exec 危险——用户输入直接放进去等于给攻击者开后门。除非你完全控制输入且没有别的选择，否则不要用。

十、面向对象辅助

1
2
3
4
object                    # 所有类的祖先
super()                   # 调用父类方法
staticmethod, classmethod, property   # 装饰器
type("MyClass", (Base,), {"x": 1})    # 动态建类

十一、迭代进阶：sorted/reversed/enumerate 深入

sorted 详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
sorted(iter, key=None, reverse=False)

# 按长度排
sorted(words, key=len)

# 按元组第 2 项
sorted(pairs, key=lambda p: p[1])

# 稳定排序，可以多次 sort 组合多字段
records.sort(key=lambda r: r.age)
records.sort(key=lambda r: r.name)     # 主排序：name，次排序：age

# 或者一次搞定
records.sort(key=lambda r: (r.name, r.age))

reversed 只能对序列或实现 __reversed__ 的对象

1
2
3
list(reversed([1, 2, 3]))         # [3, 2, 1]
list(reversed(range(5)))          # [4, 3, 2, 1, 0]
list(reversed({1, 2, 3}))         # ❌ set 无序，不能 reversed

十二、数学与工具（要 import 但很常用）

不是严格意义的内置函数，但用得跟内置一样多：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import math
math.sqrt(16)              # 4.0
math.floor(3.7)            # 3
math.ceil(3.2)             # 4
math.pi, math.e            # 常量

import random
random.random()            # [0.0, 1.0)
random.randint(1, 10)      # [1, 10]
random.choice([1, 2, 3])
random.shuffle(lst)        # 就地打乱

import statistics
statistics.mean([1, 2, 3])
statistics.median([1, 2, 3])

十三、Python 3.10+ / 3.11+ 新增

1
2
3
4
5
6
7
8
9
10
11
# 3.10：zip strict
zip([1, 2, 3], [4, 5], strict=True)   # ValueError

# 3.11：ExceptionGroup（并发场景多个异常聚合）
try:
    ...
except* ValueError as eg:
    ...

# 3.12：type 语法糖
type Vector = list[float]

十四、”常见但不常见”的冷门内置

一些容易被遗忘但偶尔很好用的：

1
2
3
4
5
6
memoryview(b"hello")       # 零拷贝的内存视图
slice(1, 5, 2)             # 可复用的切片对象
zip(*matrix)               # 矩阵转置的一行代码

# 组合技：一次拿多个属性
attrgetter, itemgetter, methodcaller  # 在 operator 模块

来自 operator 模块（虽然要 import，但极其常用）：

1
2
3
4
5
6
7
8
9
10
from operator import attrgetter, itemgetter

# 按属性排序
users.sort(key=attrgetter("age"))

# 按 dict 的 key 排序
data.sort(key=itemgetter("score"))

# 多字段
data.sort(key=itemgetter("category", "price"))

这几乎是所有排序场景最快的写法，比 lambda 更快、更清晰。

十五、一个综合例子：数据集统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# stats.py
"""对一个学生成绩表做各种统计，尽量用内置函数。"""

students = [
    {"name": "张三", "score": 92, "class": "A"},
    {"name": "李四", "score": 78, "class": "B"},
    {"name": "王五", "score": 85, "class": "A"},
    {"name": "赵六", "score": 60, "class": "C"},
    {"name": "孙七", "score": 95, "class": "B"},
]

from operator import itemgetter

# 总人数、总分、平均、最大/最小
print("人数：", len(students))
print("总分：", sum(map(itemgetter("score"), students)))
print("平均：", sum(s["score"] for s in students) / len(students))
print("最高：", max(students, key=itemgetter("score")))
print("最低：", min(students, key=itemgetter("score")))

# 60 分以下
print("不及格：", list(filter(lambda s: s["score"] < 70, students)))

# 是否全员及格
print("全过：", all(s["score"] >= 60 for s in students))

# 是否有满分
print("有满分：", any(s["score"] == 100 for s in students))

# 排序（成绩降序）
print("排名：")
for i, s in enumerate(sorted(students, key=itemgetter("score"), reverse=True), 1):
    print(f"{i}. {s['name']} {s['score']}")

# 按班级分组（简单版）
from itertools import groupby
data_sorted = sorted(students, key=itemgetter("class"))
for cls, group in groupby(data_sorted, key=itemgetter("class")):
    group = list(group)
    print(f"班级 {cls}: 平均 {sum(g['score'] for g in group)/len(group):.1f}")

十六、常见陷阱

  1. round 是银行家舍入：round(0.5) == 0。要传统四舍五入用 decimal。
  2. sum 别用来拼字符串：sum(strings, "") 报错，也慢。用 "".join。
  3. filter/map 返回迭代器：filter(...) 结果需要 list() 转才能反复用。
  4. sorted 与 sort：一个返回新列表，一个就地。前者接受任何可迭代，后者只在 list 上有。
  5. any([]) 是 False，all([]) 是 True：空的”全部为真”是”空真”（vacuous truth）。
  6. eval 别接用户输入：安全事故大坑。
  7. hash(-1) 是 -2：CPython 实现细节，-1 被用作错误信号。
  8. isinstance(True, int) 是 True：bool 是 int 的子类。

十七、小结与延伸阅读

  • Python 内置函数约 70 个，日常写代码高频用到的不到 30 个；
  • 数值类：abs / sum / min / max / round / pow / divmod；
  • 序列构造：list / tuple / set / dict / str；
  • 序列聚合：sorted / reversed / any / all / len；
  • 迭代：enumerate / zip / map / filter / range；
  • 类型/反射：isinstance / type / getattr / setattr / hasattr；
  • 从 operator 引入 itemgetter / attrgetter 加速排序；
  • 有困惑先 help(内置函数) 或 dir() 看看再上网搜。

延伸阅读：

到这里模块二（数据结构）8 篇结束！ 下一篇我们进入 模块三：函数与模块，从 函数定义与调用 开始。