> ## Content Index
> Fetch the complete content index at: https://blog.vercanti.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Python 内置函数完全参考
- URL: https://blog.vercanti.com/python-nei-zhi-han-shu-wan-quan-can-kao/
- Published: 2026-08-28T14:34:35.000Z
- Updated: 2026-08-28T14:56:52.000Z
- Description: 见 数据类型(/python-nei-zhi-shu-ju-lei-xing-wan-quan-can-kao/) range 章节。 返回 (index, value) 元组的迭代器。 并行遍历多个迭代器，以最短的为准（strict=False 时）。 返回惰性迭代器，需要 list() 消费。 返回新列表，不修改原对象（区别于 list.sort() 原地排序）。 返回反向迭代器（不创建新列表），要求序列支持 __reversed__ 或 __len__ + __getitem__。 any：任意一个为真返回 True；空迭代器返回 False。 a
- Author: yellowdog
- Tags: Python, 基础

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

---

## 迭代与序列

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

见 [数据类型](https://blog.vercanti.com/python-nei-zhi-shu-ju-lei-xing-wan-quan-can-kao/) `range` 章节。

### `enumerate(iterable, start=0) -> enumerate`

| 参数       | 说明         |
| -------- | ---------- |
| iterable | 可迭代对象      |
| start    | 计数起始值，默认 0 |

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

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

```

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

| 参数          | 说明                                   |
| ----------- | ------------------------------------ |
| \*iterables | 任意多个可迭代对象                            |
| strict      | Python 3.10+；True 时长度不一致抛 ValueError |

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

```python
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`

| 参数          | 说明                                                                  |
| ----------- | ------------------------------------------------------------------- |
| function    | 应用到每个元素的函数；多个 iterable 时接受对应数量的参数                                   |
| \*iterables | 一个或多个可迭代对象（多个时同 zip 一样以最短为准）                                        |
| strict      | Python 3.14+；True 时各 iterable 长度不一致抛 ValueError（同 zip(strict=True)） |

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

```python
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`

| 参数       | 说明                    |
| -------- | --------------------- |
| function | 返回布尔值的函数；None 表示过滤掉假值 |
| iterable | 可迭代对象                 |

```python
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`

| 参数       | 说明                     |
| -------- | ---------------------- |
| iterable | 任意可迭代对象                |
| key      | 排序键函数（接受单个元素，返回用于比较的值） |
| reverse  | True 降序                |

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

```python
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__`。

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

```

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

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

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

```

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

### `sum(iterable, /, start=0)`

| 参数       | 说明         |
| -------- | ---------- |
| iterable | 数值可迭代对象    |
| start    | 初始累加值，默认 0 |

```python
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(...)`

| 参数                | 说明                           |
| ----------------- | ---------------------------- |
| iterable 或 \*args | 可迭代对象或多个位置参数                 |
| key               | 比较键函数                        |
| default           | 迭代器为空时的返回值（不提供则抛 ValueError） |

```python
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`

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

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

```

### `isinstance(object, classinfo) -> bool`

| 参数        | 说明                                                           |
| --------- | ------------------------------------------------------------ |
| object    | 要检查的对象                                                       |
| classinfo | 类、类型，或类型**元组**（满足其一即 True）；Python 3.10+ 起也接受联合类型（int \| str） |

```python
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`）。

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

```

### `hasattr(object, name) -> bool`

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

```

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

| 参数      | 说明                            |
| ------- | ----------------------------- |
| object  | 对象                            |
| name    | 属性名（字符串）                      |
| default | 属性不存在时返回；不提供则抛 AttributeError |

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

```

### `setattr(object, name, value)`

动态设置属性。

### `delattr(object, name)`

动态删除属性。

### `callable(object) -> bool`

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

```python
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)`

| 参数      | 说明                           |
| ------- | ---------------------------- |
| number  | 要舍入的数                        |
| ndigits | 保留小数位数；None 返回 int；负数对整数部分舍入 |

```python
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)`，一次计算整除和余数。

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

```

### `pow(base, exp, mod=None)`

| 参数   | 说明                                        |
| ---- | ----------------------------------------- |
| base | 底数                                        |
| exp  | 指数                                        |
| mod  | 模（三参数时等价于 (base\*\*exp) % mod，但更高效，用于密码学） |

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

```

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

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

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

```

### `int(x=0, base=10)`

字符串按指定进制解析：

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

```

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

Unicode 码点 ↔ 字符互转。

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

```

---

## 输入/输出

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

| 参数        | 说明                 |
| --------- | ------------------ |
| \*objects | 要打印的对象，逐个调用 str()  |
| sep       | 对象之间的分隔符，默认空格      |
| end       | 末尾字符，默认换行          |
| file      | 输出目标，默认 sys.stdout |
| flush     | 是否立即刷新缓冲区          |

```python
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)`

| 参数        | 常用值                   | 说明                                         |
| --------- | --------------------- | ------------------------------------------ |
| file      | 路径/文件描述符              | 要打开的文件                                     |
| mode      | 'r'/'w'/'a'/'rb'/'wb' | 读/写/追加/二进制读/二进制写                           |
| buffering | \-1                   | \-1 系统默认；0 无缓冲（仅二进制）；1 行缓冲（文本）；\>1 指定缓冲区大小 |
| encoding  | 'utf-8'               | 文本模式的编码，None 用系统默认（Windows 常为 GBK！）        |
| errors    | 'strict'              | 编码错误处理策略                                   |
| newline   | None                  | 换行符处理（None 通用换行；'' 不转换）                    |

```python
# 最佳实践：始终指定编码，使用上下文管理器
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)`

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

```python
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)`

| 参数       | 说明                         |
| -------- | -------------------------- |
| object   | 可迭代对象（或可调用对象，配合 sentinel）  |
| sentinel | 哨兵值；当调用 object() 返回该值时停止迭代 |

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

```

### `next(iterator, default=...)`

| 参数       | 说明                          |
| -------- | --------------------------- |
| iterator | 迭代器对象                       |
| default  | 迭代耗尽时返回；不提供则抛 StopIteration |

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

```

---

## 常用速查表

| 函数            | 输入             | 输出   | 特点                    |
| ------------- | -------------- | ---- | --------------------- |
| sorted()      | iterable       | list | 稳定，Timsort，O(n log n) |
| reversed()    | sequence       | 迭代器  | 惰性，不创建新列表             |
| enumerate()   | iterable       | 迭代器  | 带索引遍历                 |
| zip()         | \*iterables    | 迭代器  | 并行遍历，以短者为准            |
| map()         | func, iterable | 迭代器  | 惰性变换                  |
| filter()      | func, iterable | 迭代器  | 惰性过滤                  |
| any() / all() | iterable       | bool | 短路求值                  |
| sum()         | iterable       | 数值   | 用 start 参数可拼接列表       |
| min() / max() | iterable       | 元素   | 支持 key 和 default      |

---

## 最佳实践

**用 `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`，比静默截断更安全：

```python
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()` 做业务逻辑。

---

## 参见

[装饰器与函数高级](https://blog.vercanti.com/python-zhuang-shi-qi-yu-han-shu-gao-ji-yong-fa/)  
[itertools与functools完全指南](https://blog.vercanti.com/itertools-yu-functools-wan-quan-zhi-nan/)  
[数据类型](https://blog.vercanti.com/python-nei-zhi-shu-ju-lei-xing-wan-quan-can-kao/)