Python 内置函数完全参考

官方文档：https://docs.python.org/3/library/functions.html
适用版本：Python 3.13（2026-05-08 核实）

迭代与序列

range(start=0, stop, step=1)

见 数据类型 range 章节。

enumerate(iterable, start=0) -> enumerate

返回 (index, value) 元组的迭代器。

for i, item in enumerate(['a', 'b', 'c'], start=1):
    print(i, item)   # 1 a, 2 b, 3 c

zip(*iterables, strict=False) -> zip

并行遍历多个迭代器，以最短的为准（strict=False 时）。

names = ['Alice', 'Bob']
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

# 解压（unzip）
pairs = [(1, 'a'), (2, 'b')]
nums, letters = zip(*pairs)   # (1, 2), ('a', 'b')

map(function, *iterables, strict=False) -> map

返回惰性迭代器，需要 list() 消费。

list(map(str, [1, 2, 3]))            # ['1', '2', '3']
list(map(lambda x, y: x + y, [1,2], [3,4]))  # [4, 6]

# 推荐用推导式代替简单 map
[str(x) for x in [1, 2, 3]]         # 更 Pythonic

filter(function, iterable) -> filter

list(filter(None, [0, 1, '', 'a', None, 2]))  # [1, 'a', 2]
list(filter(lambda x: x > 0, [-1, 0, 1, 2])) # [1, 2]

sorted(iterable, *, key=None, reverse=False) -> list

返回新列表，不修改原对象（区别于 list.sort() 原地排序）。

sorted([3, 1, 2])                                # [1, 2, 3]
sorted('hello')                                  # ['e', 'h', 'l', 'l', 'o']
sorted(items, key=lambda x: x['score'], reverse=True)
sorted(items, key=lambda x: (x['age'], x['name']))  # 多字段排序

reversed(sequence) -> reversed

返回反向迭代器（不创建新列表），要求序列支持 __reversed__ 或 __len__ + __getitem__。

list(reversed([1, 2, 3]))   # [3, 2, 1]

any(iterable) -> bool / all(iterable) -> bool

any：任意一个为真返回 True；空迭代器返回 False。
all：全部为真返回 True；空迭代器返回 True。

any(x > 0 for x in [-1, 0, 1])   # True
all(x > 0 for x in [1, 2, 3])    # True

使用生成器表达式（不加 []），利用短路特性。

sum(iterable, /, start=0)

sum([1, 2, 3])               # 6
sum([[1,2], [3,4]], [])      # [1, 2, 3, 4]（列表拼接）

Python 3.12 起，浮点数求和使用更高精度算法（Neumaier 补偿求和），减少浮点累积误差。精确计算仍推荐 math.fsum()。

min(iterable, *, key=None, default=...) / max(...)

min([3, 1, 2])                             # 1
max(items, key=lambda x: x['score'])       # 分数最高的 item
min([], default=0)                         # 0（空时不报错）

类型/对象相关

type(object) -> type / type(name, bases, dict) -> type

单参数：返回对象的类型。三参数：动态创建类。

type(42)          # <class 'int'>
type([])          # <class 'list'>
type('MyClass', (object,), {'x': 1})   # 动态创建类

isinstance(object, classinfo) -> bool

isinstance(42, int)              # True
isinstance(42, (int, float))     # True
isinstance('hello', str)         # True

# Python 3.10+：支持 X | Y 联合类型语法
isinstance(42, int | float)      # True

# 注意：bool 是 int 的子类
isinstance(True, int)            # True

issubclass(class, classinfo) -> bool

检查类的继承关系。Python 3.10+ 起 classinfo 也接受联合类型（int | str）。

issubclass(bool, int)          # True
issubclass(bool, int | float)  # True（Python 3.10+）

hasattr(object, name) -> bool

hasattr(obj, 'method')   # 等价于 try: getattr(obj, 'method') except AttributeError: False

getattr(object, name, default=...)

getattr(obj, 'method', None)   # 安全获取属性
getattr(obj, method_name)()    # 动态调用方法

setattr(object, name, value)

动态设置属性。

delattr(object, name)

动态删除属性。

callable(object) -> bool

检查对象是否可调用（有 __call__）。

callable(print)       # True
callable(42)          # False
callable(lambda: 1)   # True

id(object) -> int

返回对象的唯一标识符（CPython 中是内存地址）。用于判断两个变量是否指向同一对象。

hash(object) -> int

返回对象哈希值（用于 dict/set 存储）。不可变对象才可哈希。

数值

abs(x)

绝对值，支持 int、float、complex（返回模）。

round(number, ndigits=None)

round(3.14159, 2)   # 3.14
round(2.5)          # 2（银行家舍入，Python 3）
round(3.5)          # 4
round(1234, -2)     # 1200

注意：Python 3 用银行家舍入（四舍六入五成双），2.5 → 2 而非 3。

divmod(a, b) -> (quotient, remainder)

返回 (a // b, a % b)，一次计算整除和余数。

divmod(17, 5)   # (3, 2)

pow(base, exp, mod=None)

pow(2, 10)          # 1024
pow(2, 10, 1000)    # 24（等价于 1024 % 1000，但用快速模幂）

bin(x) -> str / oct(x) -> str / hex(x) -> str

整数转二进制/八进制/十六进制字符串（带前缀）。

bin(10)   # '0b1010'
oct(10)   # '0o12'
hex(255)  # '0xff'

int(x=0, base=10)

字符串按指定进制解析：

int('0xff', 16)    # 255
int('0b1010', 2)   # 10
int('0o17', 8)     # 15
int('ff', 16)      # 255（不需要前缀）

chr(i) -> str / ord(c) -> int

Unicode 码点 ↔ 字符互转。

chr(65)    # 'A'
ord('中')  # 20013

输入/输出

print(*objects, sep=' ', end='\n', file=None, flush=False)

print('a', 'b', 'c', sep=', ', end='!\n')   # a, b, c!
print('loading...', end='', flush=True)      # 无换行，立即输出
print('error', file=sys.stderr)             # 输出到标准错误

input(prompt='') -> str

显示提示并等待用户输入，始终返回字符串。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

# 最佳实践：始终指定编码，使用上下文管理器
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()

# 二进制读取
with open('image.png', 'rb') as f:
    data = f.read()

反射/元编程

dir(object=None) -> list

返回对象的属性/方法列表（按字母排序）。None 返回当前作用域名称。

vars(object=None) -> dict

返回对象的 __dict__（实例属性字典）。无参数返回当前局部变量字典。

globals() -> dict / locals() -> dict

返回全局/局部命名空间字典。

eval(expression, globals=None, locals=None)

执行字符串表达式并返回结果。

安全警告：不要对用户输入使用 eval，有代码注入风险。

exec(object, globals=None, locals=None)

执行代码对象或字符串，无返回值。

对象创建

object() / super() / property() / staticmethod() / classmethod()

property(fget=None, fset=None, fdel=None, doc=None)

创建属性描述符。常用装饰器形式：

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError('半径不能为负')
        self._radius = value

    @property
    def area(self):
        import math
        return math.pi * self._radius ** 2

迭代器/生成器

iter(object, sentinel=None)

# 两参数形式：从文件逐行读取直到空行
for line in iter(file.readline, ''):
    process(line)

next(iterator, default=...)

it = iter([1, 2, 3])
next(it)          # 1
next(it, None)    # 在耗尽时返回 None

常用速查表

最佳实践

用 key 参数替代 lambda + 手动比较：sorted(items, key=lambda x: x.price) 比手写比较函数更简洁；key=str.lower 等内置方法作为 key 比 lambda 快（避免 Python 函数调用开销）。

zip 配合 strict=True 验证等长：Python 3.10+ 的 zip(..., strict=True) 在可迭代对象长度不一致时抛出 ValueError，比静默截断更安全：

for a, b in zip(list1, list2, strict=True):
    process(a, b)

enumerate 替代 range(len(...))：for i, item in enumerate(items) 比 for i in range(len(items)) 更 Pythonic，且能直接获取元素无需下标访问。

any() / all() 利用短路特性：any(is_valid(x) for x in items) 生成器表达式配合短路，找到第一个有效值即停止，比先生成列表再 any 高效。

vars() / dir() 用于调试，不用于生产逻辑：vars(obj) 返回 obj.__dict__，dir(obj) 返回所有属性名，是调试利器，但生产代码应用明确的属性访问而非反射。

常见陷阱

陷阱：sorted() 和 list.sort() 返回值不同

现象： result = mylist.sort() 后 result 是 None，而不是排序后的列表。
原因： list.sort() 原地排序并返回 None；sorted() 返回新列表，不修改原列表。
解决： 需要新列表用 sorted(mylist)；需要原地排序用 mylist.sort()（不接收返回值）。

陷阱：map() / filter() 是惰性迭代器，只能消费一次

现象： m = map(int, strs) 后 list(m) 正常，再次 list(m) 得到空列表。
原因： map 和 filter 返回迭代器（不是列表），遍历后耗尽，不能重复消费。
解决： 需要多次使用时转换为列表 list(map(...))，或重新创建迭代器。

陷阱：id() 不能用于判断对象相等

现象： 两个 id() 相同的对象在不同时刻可能是不同对象，判断逻辑出错。
原因： CPython 的 id() 是内存地址，小整数、短字符串有缓存池（interning），但一般对象销毁后地址可被复用，不保证唯一性跨时间段有效。
解决： 判断对象同一性用 is，判断值相等用 ==，不要依赖 id() 做业务逻辑。

参见

装饰器与函数高级
itertools与functools完全指南
数据类型