Python内置函数大全：按常用程度与功能分类详解（涵盖至python3.15共71个函数）

一、高频使用函数

（一）基础操作

1.print()

简介

用于将内容输出到控制台（默认标准输出），可打印字符串、变量、表达式结果等。

语法

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

示例

print("Hello", "World", sep="-")  # 输出：Hello-World
print(1 + 2)                      # 输出：3
print("No newline", end="")       # 输出后不换行

Python语言参考手册

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

将 objects 打印输出至 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 分隔并在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。 如果没有给出 objects，则 print() 将只写入 end。

file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。 对于这些对象，应改用 file.write(...)。

输出缓冲通常由 file 确定。 但是，如果 flush 为真值，流将被强制刷新。

在 3.3 版本发生变更: 增加了 flush 关键字参数。

2.len()

简介

返回容器（字符串、列表、元组、字典等）中元素的个数。

语法

len(object)

示例

s = "Python"
lst = [1, 2, 3]
d = {"a": 1, "b": 2}

print(len(s))    # 输出：6（字符串字符数）
print(len(lst))  # 输出：3（列表元素数）
print(len(d))    # 输出：2（字典键值对数）

Python语言参考手册

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

len 对于大于 sys.maxsize 的长度如 range(2 ** 100) 会引发 OverflowError。

3.type()

简介

返回对象的类型（如 int, str, list 等），常用于调试或类型检查。

语法

type(object)  
type(name, bases, dict)

示例

print(type(10))          # <class 'int'>
print(type("Hello"))     # <class 'str'>

# 动态创建类
MyClass = type('MyClass', (), {'x': 10})
obj = MyClass()
print(obj.x)            # 10

Python语言参考手册

传入一个参数时，返回 object 的类型。 返回值是一个 type 对象并且通常与 object.__class__ 所返回的对象相同。

推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式。 name 字符串即类名并会成为 __name__ 属性；bases 元组包含基类并会成为 __bases__ 属性；如果为空，则会添加所有类的终极基类，即 object。 dict 字典包含类体的属性和方法定义；它在成为 __dict__ 属性之前可能会被拷贝或包装。 下面两条语句会创建同样的 type 对象：

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

提供给三参数形式的关键字参数会被传递给适当的元类机制 (通常为 __init_subclass__())，相当于类定义中关键字 (除了 metaclass) 的行为方式。

在 3.6 版本发生变更: type 的子类如果未重写 type.__new__ 将不再能使用一个参数的形式来获取对象的类型。

4.input()

简介

从标准输入读取用户输入，返回字符串。

语法

input([prompt])

示例

name = input("请输入姓名：")
print(f"你好，{name}！")

age = int(input("年龄："))  # 输入转换为整数

Python语言参考手册

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。例如:

>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

如果加载了 readline 模块，input() 将使用它来提供复杂的行编辑和历史记录功能。

在读取输入前引发一个 审计事件 builtins.input 附带参数 prompt

在成功读取输入之后引发一个 审计事件 builtins.input/result 附带结果。

5.range()

简介

生成不可变的整数序列。

语法

range(stop)  
range(start, stop[, step])

示例

for i in range(3):      # 0, 1, 2
    print(i)

nums = list(range(1, 10, 2))  # [1, 3, 5, 7, 9]

Python语言参考手册

虽然被称为函数，但 range 实际上是一个不可变的序列类型，参见在 range 对象 与 序列类型 — list, tuple, range 中的文档说明。

（二）类型转换

1.int()

简介

将数字或字符串转换为整数（十进制）。

语法

int(x=0, base=10)

示例

print(int("10"))      # 10（字符串→整数）
print(int(3.14))      # 3（浮点数→整数）
print(int("1010", 2)) # 10（二进制字符串→十进制整数）

Python语言参考手册

返回从一个数字或字符串构建的整数对象，或者如果未给出参数则返回 0。

示例：

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

如果参数定义了 __int__() , int(x) 返回 x.__int__() 。 如果参数定义了 __index__() ，则返回 x.__index__()。 对于浮点数，则向零截断。

如果参数不是数字或者如果给定了 base，则它必须是表示一个以 base 为基数的整数的字符串、bytes 或 bytearray 实例。 字符串前面还可选择加上 + 或 - (中间没有空格)，带有前导的零，带有两侧的空格，以及带有数位之间的单个下划线。

一个以 n 为基数的整数字符串包含多个数位，每个数位代表从 0 到 n-1 范围内的值。 0–9 的值可以用任何 Unicode 十进制数码来表示。 10–35 的值可以用 a 到 z (或 A 到 Z) 来表示。 默认的 base 为 10。 允许的基数为 0 和 2–36。 对于基数 2, -8 和 -16 来说字符串前面还能加上可选的 0b/0B, 0o/0O 或 0x/0X 前缀，就像代码中的整数字面值那样。 对于基数 0 来说，字符串会以与 代码中的整数字面值 类似的方式来解读，即实际的基数将由前缀确定为 2, 8, 10 或 16。 基数为 0 还会禁用前导的零: int('010', 0) 将是无效的，而 int('010') 和 int('010', 8) 则是有效的。

整数类型定义请参阅 数字类型 — int, float, complex 。

在 3.4 版本发生变更: 如果 base 不是 int 的实例，但 base 对象有 base.__index__ 方法，则会调用该方法来获取进制数。以前的版本使用 base.__int__ 而不是 base.__index__。

在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。

在 3.7 版本发生变更: 第一个形参现在是仅限位置形参。

在 3.8 版本发生变更: 如果 __int__() 未定义则回退至 __index__()。

在 3.11 版本发生变更: int 字符串输入和字符串表示形式可受到限制以帮助避免拒绝服务攻击。当将一个字符串转换为 int 或者将一个 int 转换为字符串的操作走出限制时会引发 ValueError。 请参阅 整数字符串转换长度限制 文档。

在 3.14 版本发生变更: int() 不再委托 __trunc__() 方法

2.float()

简介

将数字或字符串转换为浮点数。

语法

float(x=0.0)

示例

print(float("3.14"))  # 3.14（字符串→浮点数）
print(float(10))      # 10.0（整数→浮点数）

Python语言参考手册

返回基于一个数字或字符串构建的浮点数。

示例：

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

如果该参数是一个字符串，则它应当包含一个十进制数字，前面可以选择带一个符号，也可以选择嵌入空格。 可选的符号有 '+' 或 '-'；'+' 符号对所产生的值没有影响。 该参数还可以是一个代表 NaN (not-a-number) 或者正负无穷大的字符串。 更确切地说，在移除前导和尾随的空格之后，输入必须为符合以下语法的 floatvalue 产生规则：

sign:          "+" | "-"
infinity:      "Infinity" | "inf"
nan:           "nan"
digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart:     digit (["_"] digit)*
number:        [digitpart] "." digitpart | digitpart ["."]
exponent:      ("e" | "E") [sign] digitpart
floatnumber:   number [exponent]
absfloatvalue: floatnumber | infinity | nan
floatvalue:    [sign] absfloatvalue

大小写是无影响的，因此举例来说，"inf", "Inf", "INFINITY" 和 "iNfINity" 都是正无穷可接受的拼写形式。

另一方面，如果参数是整数或浮点数，则返回一个具有相同值（在 Python 浮点精度范围内）的浮点数。 如果参数超出了 Python 浮点数的取值范围，则会引发 OverflowError。

对于一个普通 Python 对象 x，float(x) 会委托给 x.__float__()。 如果 __float__() 未定义则将回退至 __index__()。

另请参见 float.from_number()，它只接受数字参数。

如果没有实参，则返回 0.0 。

数字类型 — int, float, complex 描述了浮点类型。

在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。

在 3.7 版本发生变更: 该形参现在为仅限位置形参。

在 3.8 版本发生变更: 如果 __float__() 未定义则回退至 __index__()。

3.str()

简介

将任意对象转换为字符串。

语法

str(object='')

示例

print(str(100))       # "100"（整数→字符串）
print(str([1, 2]))    # "[1, 2]"（列表→字符串）

Python语言参考手册

返回一个 str 版本的 object 。有关详细信息，请参阅 str() 。

str 是内置字符串 class 。更多关于字符串的信息查看 文本序列类型 — str。

4.bool()

简介

返回对象的布尔值（True 或 False）。

语法

bool(x=False)

示例

print(bool(1))        # True（非零数为True）
print(bool(""))       # False（空字符串为False）
print(bool([]))       # False（空列表为False）

Python语言参考手册

返回布尔值，即 True 或 False 中的一个。 其参数将使用标准的 真值测试过程 来转换。 如果该参数为假值或被省略，则返回 False；在其他情况下，将返回 True。 bool 类是 int 的子类 (参见 数字类型 — int, float, complex)。 它不能被继续子类化。 它只有 False 和 True 这两个实例 (参见 布尔类型 – bool)。

在 3.7 版本发生变更: 该形参现在为仅限位置形参。

5.list()

简介

将可迭代对象（如元组、字符串）转换为列表。

语法

list(iterable=())

示例

print(list("abc"))     # ['a', 'b', 'c']（字符串→列表）
print(list((1, 2)))    # [1, 2]（元组→列表）

Python语言参考手册

虽然被称为函数，list 实际上是一种可变序列类型，详情请参阅 列表 和 序列类型 — list, tuple, range。

6.tuple()

简介

将可迭代对象转换为元组。

语法

tuple(iterable=())

示例

print(tuple([1, 2]))   # (1, 2)（列表→元组）
print(tuple("abc"))    # ('a', 'b', 'c')（字符串→元组）

Python语言参考手册

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型，参见在 元组 与 序列类型 — list, tuple, range 中的文档说明。

7.set()

简介

将可迭代对象转换为集合（自动去重）。

语法

set(iterable=set())

示例

print(set([1, 1, 2]))  # {1, 2}（列表→集合，去重）
print(set("hello"))    # {'h', 'e', 'l', 'o'}（字符串→集合）

Python语言参考手册

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。 请查看 set 和 集合类型 — set, frozenset 获取关于这个类的文档。

有关其他容器请参看内置的 frozenset, list, tuple 和 dict 类，以及 collections 模块。

8.dict()

简介

创建字典或转换可迭代对象为字典。

语法

dict(**kwargs)  
dict(mapping, **kwargs)  
dict(iterable, **kwargs)

示例

print(dict(a=1, b=2))         # {'a': 1, 'b': 2}
print(dict([("a", 1), ("b", 2)]))  # {'a': 1, 'b': 2}
print(dict(zip(["a", "b"], [1, 2])))  # {'a': 1, 'b': 2}

Python语言参考手册

创建一个新的字典。dict 对象是一个字典类。参见 dict 和 映射类型 — dict 了解这个类。

其他容器类型，请参见内置的 list、set 和 tuple 类，以及 collections 模块。

（三）逻辑判断

1.isinstance()

简介

检查对象是否是指定类（或元组中任意类）的实例，常用于类型验证。

语法

isinstance(object, classinfo)

示例

print(isinstance(10, int))          # True
print(isinstance("hello", (str, list)))  # True（是str或list的实例）
print(isinstance([1, 2], float))     # False

Python语言参考手册

如果 object 参数是 classinfo 参数的实例，或者是其 (直接、间接或 虚拟) 子类的实例则返回 True。 如果 object 不是给定类型的对象，则该函数总是返回 False。 如果 classinfo 是由类型对象结成的元组 (或是由其他此类元组递归生成) 或者是多个类型的 union 类型，则如果 object 是其中任一类型的实例时将会返回 True。 如果 classinfo 不是一个类型或类型元组及此类元组，则会引发 TypeError 异常。 如果之前的检查成功执行则可以不会为无效的类型引发 TypeError。

在 3.10 版本发生变更: classinfo 可以是一个 union 类型。

2.callable()

简介

判断对象是否可调用（如函数、类、方法等）。

语法

callable(object)

示例

def foo(): pass
print(callable(foo))         # True（函数可调用）
print(callable("hello"))     # False（字符串不可调用）
print(callable(list))        # True（类可调用）

Python语言参考手册

如果 object 参数是可调用的则返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 肯定不会成功。 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 方法则它就是可调用的。

Added in version 3.2: 这个函数一开始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

3.all()

简介

检查可迭代对象中所有元素是否为真值（等价于逻辑与）。

语法

all(iterable)

示例

print(all([1, 2, 3]))        # True（无0/False/空元素）
print(all([1, 0, "a"]))      # False（包含0）
print(all([]))               # True（空迭代器默认返回True）

Python语言参考手册

如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。 等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator)

awaitable anext(async_iterator, default)

当进入 await 状态时，从给定 asynchronous iterator 返回下一数据项，迭代完毕则返回 default。

这是内置函数 next() 的异步版本，类似于：

调用 async_iterator 的 __anext__() 方法，返回一个 awaitable。等待返回迭代器的下一个值。若有给出 default，则在迭代完毕后会返回给出的值，否则会触发 StopAsyncIteration。

Added in version 3.10.

4.any()

简介

检查可迭代对象中是否有任意元素为真值（等价于逻辑或）。

语法

any(iterable)

示例

print(any([0, "", False]))   # False（全假值）
print(any([0, 1, None]))     # True（包含1）
print(any([]))               # False（空迭代器默认返回False）

Python语言参考手册

如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False。 等价于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

（四）数学运算

1.abs()

简介

返回数字的绝对值（整数、浮点数或复数）。

语法

abs(x)

示例

print(abs(-5))       # 5
print(abs(3.14))     # 3.14
print(abs(3+4j))     # 5.0（复数的模）

Python语言参考手册

返回一个数字的绝对值。 参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 如果参数是一个复数，则返回它的模。

2.sum()

简介

计算可迭代对象中所有元素的和（可指定初始值）。

语法

sum(iterable, start=0)

示例

print(sum([1, 2, 3]))        # 6
print(sum([1.5, 2.5], 10))   # 14.0（初始值10）

Python语言参考手册

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

对于某些用例，存在 sum() 的更好替代。 拼接字符串序列的更好、更快的方式是调用 ''.join(sequence)。 要以扩展的精度执行浮点数值的求和，请参阅 math.fsum()。 要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

在 3.8 版本发生变更: start 形参可用关键字参数形式来指定。

在 3.12 版本发生变更: 浮点数的求和已切换为一种可在大多数构建版本中给出更高精确度和更好适应性的算法。

在 3.14 版本发生变更: 添加了复数求和的特殊化，使用与浮点数求和相同的算法。

3.min()

简介

返回可迭代对象中的最小值或多个参数中的最小值。

语法

min(iterable, *[, key, default])  
min(arg1, arg2, *args[, key])

示例

print(min([3, 1, 2]))            # 1
print(min("apple", "banana", key=len))  # "apple"（按长度比较）
print(min([], default=0))        # 0（空列表返回默认值）

Python语言参考手册

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

在 3.4 版本发生变更: 增加了 default 仅限关键字形参。

在 3.8 版本发生变更: key 可以为 None。

4.max()

简介

返回可迭代对象中的最大值或多个参数中的最大值。

语法

max(iterable, *[, key, default])  
max(arg1, arg2, *args[, key])

示例

print(max([3, 1, 2]))            # 3
print(max("apple", "banana"))     # "banana"（按字母序）

Python语言参考手册

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

在 3.4 版本发生变更: 增加了 default 仅限关键字形参。

在 3.8 版本发生变更: key 可以为 None。

5.round()

简介

对浮点数四舍五入（可指定小数位数）。

语法

round(number, ndigits=None)

示例

print(round(3.14159, 2))   # 3.14
print(round(1234, -2))     # 1200（十位四舍五入）

Python语言参考手册

返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

对于支持 round() 方法的内置类型，结果值会舍入至最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数同样接近，则选用偶数。因此，round(0.5) 和 round(-0.5) 均得出 0 而 round(1.5) 则为 2。ndigits 可为任意整数值（正数、零或负数）。如果省略了 ndigits 或为 None ，则返回值将为整数。否则返回值与 number 的类型相同。

对于一般的 Python 对象 number, round 将委托给 number.__round__。

备注

对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅 浮点算术：争议和限制 了解更多信息。

6.pow()

简介

计算幂运算或模运算（等价于 x**y 或 x**y % z）。

语法

pow(base, exp[, mod])

示例

print(pow(2, 3))        # 8（等价于2**3）
print(pow(2, 3, 3))     # 2（计算2**3 % 3）

Python语言参考手册

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。

这些参数必须为数字类型。 对于混用的操作数类型，将应用二元算术运算的强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（转换之后）除非第二个参数为负值；在那种情况下，所有参数将被转换为浮点数并输出浮点数的结果。 例如，pow(10, 2) 返回 100，而 pow(10, -2) 返回 0.01。 对于 int 或 float 类型的基数为负值而幂为非整数的情况，将产生一个复数的结果。 例如，pow(-9, 0.5) 将返回一个接近 3j 的值。 最后，对于 int 或 float 类型的基数为负值而幂为整数的情况，将产生一个浮点数的结果。 例如，pow(-9, 2.0) 将返回 81.0。

对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。 在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。

下面的例子是 38 的倒数对 97 取余:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

在 3.8 版本发生变更: 对于 int 操作数，三参数形式的 pow 现在允许第二个参数为负值，即可以计算倒数的余数。

在 3.8 版本发生变更: 允许关键字参数。 之前只支持位置参数。

（五）迭代与函数式编程

1.enumerate()

简介

为可迭代对象添加计数器，返回包含索引和值的枚举对象（常用于循环）。

语法

enumerate(iterable, start=0)

示例

fruits = ['apple', 'banana', 'cherry']
for i, fruit in enumerate(fruits):
    print(f"Index {i}: {fruit}")

# 输出：
# Index 0: apple
# Index 1: banana
# Index 2: cherry

Python语言参考手册

返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。 enumerate() 返回的迭代器的 __next__() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等价于:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

2.zip()

简介

将多个可迭代对象"压缩"成元组迭代器（按最短长度截断）。

语法

zip(*iterables)

示例

names = ['Alice', 'Bob']
scores = [85, 92]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# 输出：
# Alice: 85
# Bob: 92

Python语言参考手册

在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。

示例:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

更正式的说法： zip() 返回元组的迭代器，其中第 i 个元组包含的是每个参数迭代器的第 i 个元素。

不妨换一种方式认识 zip() ：它会把行变成列，把列变成行。这类似于 矩阵转置 。

zip() 是延迟执行的：直至迭代时才会对元素进行处理，比如 for 循环或放入 list 中。

值得考虑的是，传给 zip() 的可迭代对象可能长度不同；有时是有意为之，有时是因为准备这些对象的代码存在错误。Python 提供了三种不同的处理方案：

>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]

>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]

>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1

极端例子是只有一个可迭代对象参数，zip() 会返回一个一元组的迭代器。如果未给出参数，则返回一个空的迭代器。

小技巧：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

在 3.10 版本发生变更: 增加了 strict 参数。

3.filter()

简介

用指定函数过滤可迭代对象，返回迭代器（保留使函数返回True的元素）。

语法

filter(function, iterable)

示例

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4]
print(list(filter(is_even, numbers)))  # [2, 4]
print(list(filter(None, [0, 1, False, True])))  # [1, True]

Python语言参考手册

使用 iterable 中 function 返回真值的元素构造一个迭代器。 iterable 可以是一个序列，一个支持迭代的容器或者一个迭代器。 如果 function 为 None，则会使用标识号函数，也就是说，iterable 中所有具有假值的元素都将被移除。

请注意， filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。

请参阅 itertools.filterfalse() 来了解返回 iterable 中 function 返回假值的元素的补充函数。

4.map()

简介

对可迭代对象的每个元素应用函数，返回结果迭代器。

语法

map(function, iterable, ...)

示例

def square(x):
    return x ** 2

numbers = [1, 2, 3]
print(list(map(square, numbers)))  # [1, 4, 9]

# 多参数示例
print(list(map(lambda x, y: x+y, [1,2], [3,4])))  # [4, 6]

Python语言参考手册

返回一个将 function 应用于的每个 iterable 项目的迭代器，返回每个结果。 如果传递了额外的 iterables 参数，则 function 必须使用相同数量的参数，并将并行应用于所有 iterables 中的项目。 在多个 iterables 的情况下， 迭代器会在最短的 iterable 用尽后停止。 如果 strict 是 True，且其中一个 iterables 在其他之前耗尽，则引发 ValueError 。对于 function 输入已排列成参数元组的情况，请参阅 itertools.starmap()。

在 3.14 版本发生变更: 增加了 strict 形参。

（六）字符串处理

1.format()

简介

执行字符串格式化操作，支持位置参数和关键字参数。

语法

str.format(*args, **kwargs)

示例

# 位置参数
print("{} {}".format("Hello", "World"))  # Hello World

# 关键字参数
print("{name} is {age} years old".format(name="Alice", age=25))

# 格式限定
print("{:.2f}".format(3.14159))  # 3.14（保留2位小数）

Python语言参考手册

将 value 转换为“格式化后”的形式，格式由 format_spec 进行控制。format_spec 的解释方式取决于 value 参数的类型；但大多数内置类型使用一种标准的格式化语法： 格式规格迷你语言。

默认的 format_spec 是一个空字符串，它通常给出与调用 str(value) 相同的结果。

对 format(value, format_spec) 的调用会转写为 type(value).__format__(value, format_spec)，这样在搜索值的 __format__() 方法时将绕过实例字典。 如果方法搜索到达 object 并且 format_spec 不为空，或者如果 format_spec 或返回值不为字符串则会引发 TypeError 异常。

在 3.4 版本发生变更: 当 format_spec 不是空字符串时， object().__format__(format_spec) 会触发 TypeError。

2.ord()

简介

返回单个Unicode字符的整数表示（ASCII码）。

语法

ord(c)

示例

print(ord("A"))  # 65
print(ord("中")) # 20013（中文字符的Unicode码点）

Python语言参考手册

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。例如 ord('a') 返回整数 97， ord('€') （欧元符号）返回 8364 。这是 chr() 的逆函数。

3.chr()

简介

返回整数对应的Unicode字符（ASCII字符）。

语法

chr(i)

示例

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

Python语言参考手册

返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

（七）文件操作

1.open()

简介

打开文件并返回文件对象，用于读写操作（需配合 with 语句使用以确保关闭）。

语法

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

示例

# 读取文件
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# 写入文件
with open("output.txt", "w") as f:
    f.write("Hello World")

Python语言参考手册

打开 file 并返回对应的 file object。 如果该文件不能被打开，则引发 OSError。 请参阅 读写文件 获取此函数的更多用法示例。

file 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者相对当前工作目录的路径），也可以是要封装文件对应的整数类型文件描述符。（如果给出的是文件描述符，则当返回的 I/O 对象关闭时它也会关闭，除非将 closefd 设为 False 。）

mode 是一个指明文件打开模式的可选字符串。 它默认为 'r' 表示以文本模式读取。 其他常见模式有表示写入的 'w' (若文件已存在则将其清空)，表示独占创建的 'x'，以及表示追加写入的 'a' (在 某些 Unix 系统上，这意味着无论当前查找位置在哪里 所有 写入操作都将追加到文件末尾)。 在文本模式下，如果未指定 encoding 则所使用的编码格式将依赖于具体平台: locale.getencoding() 会被调用以获取当前语言区域的编码格式。 (对于读取和写入原始字节数据请使用二进制模式并且不要指定 encoding。) 可用的模式有:

默认模式为 'r' （打开文件用于读取文本，与 'rt' 同义）。'w+' 和 'w+b' 模式将打开文件并清空内容。而 'r+' 和 'r+b' 模式将打开文件但不清空内容。

正如在 概述 中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 'b' ）返回的内容为 bytes 对象，不进行任何解码。在文本模式下（默认情况下，或者在 mode 参数中包含 't' ）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

备注

Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。

buffering 是一个可选的整数，用于设置缓冲策略。 传入 0 来关闭缓冲（仅在二进制模式下允许），传入 1 来选择行缓冲（仅在文本模式下写入时可用），传一个整数 > 1 来表示固定大小的块缓冲区的字节大小。 注意这样指定缓冲区的大小适用于二进制缓冲的 I/O,但 TextIOWrapper (即用 mode='r+' 打开的文件) 会有另一种缓冲。 要禁用 TextIOWrapper 中的缓冲，请考虑为 io.TextIOWrapper.reconfigure() 使用 write_through 旗标。 当没有给出 buffering 参数时，默认的缓冲策略规则如下:

encoding 是用于编码或编码文件的编码格式名称。 这应当只有文本模式下使用。 默认的编码格式依赖于具体平台 (即 locale.getencoding() 所返回的值)，但是任何 Python 支持的 text encoding 都可以被使用。 请参阅 codecs 模块获取受支持的编码格式列表。

errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误 – 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在 错误处理方案 ），但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。标准名称包括:

newline 决定如何解析来自流的换行符。 它可以为 None, '', '\n', '\r' 和 '\r\n'。 它的工作原理如下:

如果 closefd 为 False 且给出的不是文件名而是文件描述符，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出的是文件名，则 closefd 必须为 True （默认值），否则将触发错误。

可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

新创建的文件是 不可继承的。

下面的示例使用 os.open() 函数的 dir_fd 的形参，从给定的目录中用相对路径打开文件:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # 不要泄漏文件描述符

open() 函数所返回的 file object 类型取决于所用模式。 当使用 open() 以文本模式 ('w', 'r', 'wt', 'rt' 等) 打开文件时，它将返回 io.TextIOBase (具体为 io.TextIOWrapper) 的一个子类。 当使用缓冲以二进制模式打开文件时，返回的类是 io.BufferedIOBase 的一个子类。 具体的类会有多种：在只读的二进制模式下，它将返回 io.BufferedReader；在写入二进制和追加二进制模式下，它将返回 io.BufferedWriter，而在读/写模式下，它将返回 io.BufferedRandom。 当禁用缓冲时，则会返回原始流，即 io.RawIOBase 的一个子类 io.FileIO。

另请参阅文件操作模块，如 fileinput、io （声明了 open()）、os、os.path、tempfile 和 shutil。

引发一个 审计事件 open 并附带参数 path, mode, flags。

mode 与 flags 参数可以在原始调用的基础上被修改或传递。

在 3.3 版本发生变更:

在 3.4 版本发生变更:

在 3.5 版本发生变更:

在 3.6 版本发生变更:

在 3.11 版本发生变更: 'U' 模式已被移除。

2025.5.18更新

二、中频使用函数

（一）对象操作

1.id()

简介

返回对象的唯一标识符（内存地址），常用于对象身份比较。

语法

id(object)  

示例

x = [1, 2]  
y = x  
print(id(x) == id(y))  # True（x和y引用同一对象）  
print(id(100))         # 输出整数的内存地址（如140736538680336）  

Python语言参考手册

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

这是对象在内存中的地址。

引发一个 审计事件 builtins.id 并附带参数 id。

2.hash()

简介

返回对象的哈希值（用于字典键、集合元素等不可变类型）。

语法

hash(object)  

示例

print(hash("hello"))        # 输出哈希值（如-1267296259）  
print(hash((1, 2)))         # 元组的哈希值  
# print(hash([1, 2]))       # 报错！列表不可哈希  

Python语言参考手册

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

备注

对于具有自定义 __hash__() 方法的对象，请注意 hash() 会根据宿主机的字长来截断返回值。

3.vars()

简介

返回对象的 __dict__ 属性（模块、类、实例的命名空间字典）。

语法

vars([object])  

示例

class Person:  
    def __init__(self, name):  
        self.name = name  

p = Person("Alice")  
print(vars(p))          # {'name': 'Alice'}  
print(vars())           # 返回当前局部符号表（类似locals()）  

Python语言参考手册

返回模块、类、实例或任何其他具有 __dict__ 属性的对象的 __dict__ 属性。

模块和实例这样的对象具有可更新的 __dict__ 属性；但是，其他对象的 __dict__ 属性可能会设置写入限制（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。

不带参数时，vars() 的行为将类似于 locals()。

如果指定了一个对象但它没有 __dict__ 属性（例如，当它所属的类定义了 __slots__ 属性时）则会引发 TypeError 异常。

在 3.13 版本发生变更: 不带参数调用此函数的结果已被更新为与 locals() 内置函数的描述类似。

4.dir()

简介

返回对象的有效属性列表（或当前作用域的变量名）。

语法

dir([object])  

示例

print(dir(list))        # 输出列表的所有方法（如append, sort）  
print(dir())            # 输出当前作用域的变量名  

Python语言参考手册

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为 __dir__() 的方法，则该方法将被调用并且必须返回由属列组成的列表。 这允许实现自定义This allows objects that implement a custom __getattr__() 或 __getattribute__() 函数的对象能够定制 dir() 报告其属性的方式。

如果对象未提供 __dir__()，该函数会尽量从对象所定义的 __dict__ 属性和其类型对象中收集信息。 结果列表不一定是完整的，并且当对象具有自定义的 __getattr__() 时还可能是不准确的。

默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

返回的列表按字母表排序。例如：

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

备注

因为 dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

5.property()

简介

创建属性描述符，用于管理类属性的访问（getter/setter/deleter）。

语法

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:  
            self._radius = value  
        else:  
            raise ValueError("Radius must be positive")  

c = Circle(5)  
print(c.radius)        # 5（调用getter）  
c.radius = 10          # 调用setter  

Python语言参考手册

返回 property 属性。

fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。

一个典型的用法是定义一个托管属性 x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

如果 c 为 C 的实例，c.x 将调用 getter，c.x = value 将调用 setter， del c.x 将调用 deleter。

如果给出，doc 将成为该 property 属性的文档字符串。 否则该 property 将拷贝 fget 的文档字符串（如果存在）。 这令使用 property() 作为 decorator 来创建只读的特征属性可以很容易地实现:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性 "getter"，并将 voltage 的文档字符串设为 "Get the current voltage."

@getter

@setter

@deleter

特征属性对象具有 getter, setter 和 deleter 方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。 这最好是用一个例子来说明：

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

上述代码与第一个例子完全等价。 注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为 x。)

返回的特征属性对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。

在 3.5 版本发生变更: 特征属性对象的文档字符串现在是可写的。

__name__

保存特征属性名称的属性。 特性属性名称可在运行时被修改。

Added in version 3.13.

（二）类与元编程

1.staticmethod()

简介

将方法转换为静态方法（无需实例或类引用，相当于普通函数）。

语法

@staticmethod  
def method(args, ...):  
    ...  

示例

class MathUtils:  
    @staticmethod  
    def add(a, b):  
        return a + b  

# 无需实例化即可调用  
print(MathUtils.add(3, 5))  # 输出：8  

Python语言参考手册

将方法转换为静态方法。

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

@staticmethod 这样的形式称为函数的 decorator — 详情参阅 函数定义。

静态方式既可以在类上调用 (如 C.f())，也可以在实例上调用 (如 C().f())。 此外，静态方法 descriptor 也属于可调用对象，因而它们可以在类定义中使用 (如 f())。

Python 的静态方法与 Java 或 C++ 类似。另请参阅 classmethod() ，可用于创建另一种类构造函数。

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

想了解更多有关静态方法的信息，请参阅 标准类型层级结构 。

在 3.10 版本发生变更: 静态方法现在继承了方法的属性 (__module__, __name__, __qualname__, __doc__ 和 __annotations__)，并具有新的 __wrapped__ 属性，现在是属于与常规函数类似的可调用对象。

2.classmethod()

简介

将方法转换为类方法（第一个参数为类本身 cls）。

语法

@classmethod  
def method(cls, args, ...):  
    ...  

示例

class Person:  
    def __init__(self, name):  
        self.name = name  

    @classmethod  
    def from_json(cls, json_data):  
        return cls(json_data["name"])  # 调用构造函数  

# 通过类方法创建实例  
p = Person.from_json({"name": "Alice"})  
print(p.name)  # 输出：Alice  

Python语言参考手册

把一个方法封装成类方法。

类方法隐含的第一个参数就是类，就像实例方法接收实例作为参数一样。要声明一个类方法，按惯例请使用以下方案：

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

@classmethod 这样的形式称为函数的 decorator — 详情参阅 函数定义。

类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

类方法与 C++ 或 Java 中的静态方法不同。 如果你需要后者，请参阅本节中的 staticmethod()。 有关类方法的更多信息，请参阅 标准类型层级结构。

在 3.9 版本发生变更: 类方法现在可以包装其他 描述器 例如 property()。

在 3.10 版本发生变更: 类方法现在继承了方法的属性 (__module__, __name__, __qualname__, __doc__ 和 __annotations__) 并具有新的 __wrapped__ 属性。

Deprecated since version 3.11, removed in version 3.13: 类方法不再可以包装其他 descriptors 例如 property()。

3.super()

简介

调用父类（超类）的方法，用于继承场景。

语法

super([type[, object-or-type]])  

示例

class Parent:  
    def show(self):  
        print("Parent method")  

class Child(Parent):  
    def show(self):  
        super().show()  # 调用父类的show()  
        print("Child method")  

Child().show()  
# 输出：  
# Parent method  
# Child method  

Python语言参考手册

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重写的继承方法很有用。

object_or_type 确定要用于搜索的 method resolution order。 搜索会从 type 之后的类开始。

举例来说，如果 object_or_type 的 __mro__ 为 D -> B -> C -> A -> object 并且 type 的值为 B，则 super() 将会搜索 C -> A -> object。

对应于 object_or_type 的类的 __mro__ 属性列出了 getattr() 和 super() 所共同使用的方法解析搜索顺序。 该属性是动态的并可在任何继承层级结构更新时被改变。

如果省略第二个参数，则返回的超类对象是未绑定的。 如果第二个参数为一个对象，则 isinstance(obj, type) 必须为真值。 如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值（这适用于类方法）。

当在普通方法或类中直接调用时，这两个参数均可被省略 (即 "零参数 super()")。 在此情况下，type 将为其外层的类，而 obj 将为其所在函数的第一个参数 (通常为 self)。 (这意味着零参数 super() 在嵌套的函数内的行为将不会如预期那样，这也包括生成器表达式，因为它会隐式地创建嵌套的函数。)

super 有两个典型用例。 在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。 这种用法与其他编程语言中 super 的用法非常相似。

第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独有而不存在于静态编码语言或仅支持单继承的语言当中。 这使用实现“菱形图”成为可能，即有多个基类实现相同的方法。 好的设计强制要求这样的方法在每个情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，也因为这个顺序要适应类层级结构的更改，还因为这个顺序可能包括在运行时之前未知的兄弟类）。

对于以上两个用例，典型的超类调用看起来是这样的:

class C(B):
    def method(self, arg):
        super().method(arg)    # 它的作用像：
                               # super(C, self).method(arg)

除了方法查找之外，super() 也可用于属性查找。 一个可能的应用场合是在上级或同级类中调用 描述器。

请注意 super() 被实现为为显式的带点号属性查找的绑定过程的组成部分，例如 super().__getitem__(name)。 它做到这一点是通过实现自己的 __getattribute__() 方法以便能够按支持协作多重继承的可预测的顺序来搜索类。 相应地，super() 在像 super()[name] 这样使用语句或运算符进行隐式查找时则是未定义的。

还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。

对于有关如何使用 super() 来如何设计协作类的实用建议，请参阅 使用 super() 的指南。

在 3.14 版本发生变更: super 对象现在是 pickleable 和 copyable 。

4.issubclass()

简介

检查类是否是另一个类的子类（或自身）。

语法

issubclass(class, classinfo)  

示例

class Parent: pass  
class Child(Parent): pass  

print(issubclass(Child, Parent))  # True  
print(issubclass(int, object))    # True（所有类都是object的子类）  

Python语言参考手册

如果 class 是 classinfo 的子类（直接、间接或 虚的 ），则返回 True。类将视为自己的子类。classinfo 可为类对象的元组（或递归地，其他这样的元组）或 union 类型，这时如果 class 是 classinfo 中任何条目的子类，则返回 True 。任何其他情况都会触发 TypeError 异常。

在 3.10 版本发生变更: classinfo 可以是一个 union 类型。

（三）进制转换

1.bin()

简介

将整数转换为以 0b 开头的二进制字符串。

语法

bin(x)

示例

print(bin(10))    # 输出：'0b1010'  
print(bin(-5))    # 输出：'-0b101'  

Python语言参考手册

将一个整数转换为带前缀 "0b" 的二进制数字符串。 结果是一个合法的 Python 表达式。 如果 x 不是一个 Python int 对象，则它必须定义返回一个整数的 __index__() 方法。 下面是一些例子:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

若要控制是否显示前缀“0b”，可以采用以下两种方案：

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

2.oct()

简介

将整数转换为以 0o 开头的八进制字符串。

语法

oct(x)

示例

print(oct(8))     # 输出：'0o10'  
print(oct(-20))   # 输出：'-0o24'  

Python语言参考手册

将整数转换为带前缀 "0o" 的八进制数字符串。 结果是一个合法的 Python 表达式。 如果 x 不是一个 Python int 对象，则它必须定义返回一个整数的 __index__() 方法。 例如:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

若要将整数转换为八进制字符串，并可选择是否带有“0o”前缀，可采用如下方法：

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

3.hex()

简介

将整数转换为以 0x 开头的十六进制字符串（小写字母）。

语法

hex(x)

示例

print(hex(255))   # 输出：'0xff'  
print(hex(-42))   # 输出：'-0x2a'  

Python语言参考手册

将整数转换为带前缀 "0x" 前缀的小写十六进制数字符串。 如果 x 不是一个 Python int 对象，则它必须定义返回一个整数的 __index__() 方法。 下面是一些例子:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，则可以使用如下方法：

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

（四）高级操作

1.iter()

简介

返回对象的迭代器，用于支持迭代协议。

语法

iter(object[, sentinel])

示例

# 基本用法
numbers = [1, 2, 3]
num_iter = iter(numbers)
print(next(num_iter))  # 1

# 带sentinel参数（文件读取到空行停止）
with open("data.txt") as f:
    for line in iter(f.readline, ""):
        print(line)

Python语言参考手册

返回一个 iterator 对象。 根据是否存在第二个参数，对第一个参数的解读会有很大的不同。 如果没有第二个参数，object 必须是一个支持 iterable 协议 (有 __iter__() 方法) 的多项集对象，或者必须支持序列协议 (有 __getitem__() 方法并使用从 0 开始的整数参数)。 如果它不支持这些协议，则会引发 TypeError。 如果给出了第二个参数 sentinel，则 object 必须是一个可调用对象。 在这种情况下创建的迭代器将针对每次调用其 __next__() 方法不带参数地调用 object；如果返回的值等于 sentinel，则会引发 StopIteration，否则将返回该值。

另请参阅 迭代器类型。

适合 iter() 的第二种形式的应用之一是构建块读取器。 例如，从二进制数据库文件中读取固定宽度的块，直至到达文件的末尾:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

2.next()

简介

从迭代器中检索下一项，可设置默认值防止StopIteration异常。

语法

next(iterator[, default])

示例

numbers = iter([1, 2])
print(next(numbers))  # 1
print(next(numbers))  # 2
print(next(numbers, "End"))  # "End"（不报错）

Python语言参考手册

通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

3.reversed()

简介

返回序列的反向迭代器。

语法

reversed(sequence)

示例

# 列表反向
for i in reversed([1, 2, 3]):
    print(i)  # 输出：3, 2, 1

# 字符串反向
print("".join(reversed("hello")))  # "olleh"

Python语言参考手册

返回一个反向的 iterator。 seq 必须是一个具有 __reversed__() 方法或是支持序列协议（具有 __len__() 方法和从 0 开始的整数参数的 __getitem__() 方法）的对象。

4.sorted()

简介

返回排序后的新列表（不改变原序列）。

语法

sorted(iterable, *, key=None, reverse=False)

示例

# 基本排序
print(sorted([3, 1, 2]))  # [1, 2, 3]

# 复杂排序
students = [{"name": "Alice", "age": 20}, {"name": "Bob", "age": 18}]
print(sorted(students, key=lambda x: x["age"]))
# 输出：[{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}]

Python语言参考手册

根据 iterable 中的项返回一个新的已排序列表。

具有两个可选参数，它们都必须指定为关键字参数。

key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

使用 functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。

内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 — 这有利于进行多重排序（例如先按部门、再按薪级排序）。

排序算法只使用 < 在项目之间比较。 虽然定义一个 __lt__() 方法就足以进行排序，但 PEP 8 建议实现所有六个 富比较 。 这将有助于避免在与其他排序工具（如 max() ）使用相同的数据时出现错误，这些工具依赖于不同的底层方法。实现所有六个比较也有助于避免混合类型比较的混乱，因为混合类型比较可以调用反射到 __gt__() 的方法。

有关排序示例和简要排序教程，请参阅 排序的技术 。

作者：视默