Python内置函数大全：68个built-in函数速查与示例

一颗松果

发布时间：2026-11-12| 12人浏览过

原创

系统梳理 Python 官方标准库 68 个内置函数（built-in functions），按照数学计算、类型容器、迭代遍历、作用域反射、面向对象、输入输出等模块分类，提供完整函数签名、核心用途、代码示例与进阶避坑指南。

Python内置函数大全：68个built-in函数速查与示例 — 图 0：Python 3 内置函数生态全景概览

Python 解释器启动时会自动加载 builtins 模块，其中的所有函数与类型无需任何 import 声明即可在任意作用域直接调用。根据官方规范，Python 基础环境定义了标准的 68 个内置函数。它们由底层 C 语言深度优化实现，具备执行速度快、内存开销低和语义精简的特点。本文按实际开发场景将 68 个内置函数划分为 9 个逻辑分类，提供准确签名、功能精讲、实操示例与核心避坑提醒。

内置函数体系架构全景

为了避免在开发中陷入“死记硬背”，理解内置函数的分类脉络至关重要。内置函数的设计并非零散分布，而是紧密围绕 Python 语言的核心运行机制构建，包含数值计算、数据容器、惰性迭代、动态反射、面向对象以及系统交互。

一、数学运算与极值函数（6个）

此类函数负责基础数值运算、极值筛选及舍入处理。在数据清洗和统计运算中，内置的数值函数大幅优于自定义循环逻辑。

1. abs(x) 数值运算

返回数字的绝对值。若实参是复数，则返回其模（即平方和的平方根）。

# 整数与浮点数求绝对值
print(abs(-15.8))    # 输出示例: 15.8

# 复数求模
print(abs(3 + 4j))   # 输出示例: 5.0

2. divmod(a, b) 数值运算

接收两个非复数数值，返回包含商和余数的二元元组 (a // b, a % b)。在分页计算、时间换算场景中非常高效。

# 计算 125 秒折算为分和秒
minutes, seconds = divmod(125, 60)
print(f"{minutes}分 {seconds}秒")  # 输出示例: 2分 5秒

3. max(iterable, *[, key, default]) / max(arg1, arg2, *args[, key]) 极值筛选

返回可迭代对象中的最大元素，或两个及以上参数中的最大值。支持 key 权重转换函数和 default 空值回退。

users = [{"name": "Alice", "score": 88}, {"name": "Bob", "score": 95}]
top_user = max(users, key=lambda u: u["score"])
print(top_user["name"])  # 输出示例: Bob

# 处理可能为空的列表，防止引发 ValueError
print(max([], default=0))  # 输出示例: 0

4. min(iterable, *[, key, default]) / min(arg1, arg2, *args[, key]) 极值筛选

返回可迭代对象中的最小元素或参数中的最小值。语法规则与 max() 完全一致。

prices = [199.0, 49.9, 89.0]
print(min(prices))  # 输出示例: 49.9

5. pow(base, exp[, mod]) 数值运算

返回 base 的 exp 次幂。当传入可选参数 mod 时，计算 pow(base, exp) % mod，底层采用模幂算法，速度显著快于直接求幂再取模。

# 基础求幂 2 的 10 次方
print(pow(2, 10))        # 输出示例: 1024

# 高效大数模幂计算 (3^7 mod 5)
print(pow(3, 7, 5))      # 输出示例: 2 (相当于 2187 % 5)

6. round(number[, ndigits]) 数值运算

将数值四舍五入到 ndigits 位小数。注意 Python 采用“四舍六入五成双”（Round half to even）标准，且受浮点数底层二进制精度限制。

print(round(2.5))    # 输出示例: 2 (向偶数舍入)
print(round(3.5))    # 输出示例: 4 (向偶数舍入)
print(round(3.14159, 2))  # 输出示例: 3.14

二、数据类型转换与容器构建（15个）

Python 中的标量类型与容器类型本身即可作为构造函数使用。这一组 15 个内置函数构成了 Python 强类型系统的基石。

7. bool([x]) 标量构造

将参数转换为布尔值 True 或 False。数字 0、空容器（""、[]、{}）和 None 均被转为 False。

print(bool(0), bool(42))      # 输出示例: False True
print(bool([]), bool(["data"])) # 输出示例: False True

8. int([x]) / int(x, base=10) 标量构造

将数值或符合格式的字符串转为整型。支持通过 base 解析 2 至 36 进制字符串。

print(int("100"))       # 输出示例: 100
print(int("1010", 2))   # 输出示例: 10 (二进制解析)
print(int("FF", 16))    # 输出示例: 255 (十六进制解析)

9. float([x]) 标量构造

将整数或字符串转换为双精度浮点数，支持科学计数法字符串。

print(float("3.1415"))  # 输出示例: 3.1415
print(float("1e-3"))    # 输出示例: 0.001

10. complex([real[, imag]]) 标量构造

构建复数 real + imag*1j，或将包含虚数的字符串直接转换。

c = complex(4, -2)
print(c, c.real, c.imag)  # 输出示例: (4-2j) 4.0 -2.0

11. str(object='') 文本构建

返回对象的非正式或易读的字符串表现形式。对于绝大多数对象，会优先调用其 __str__() 魔法方法。

print(str(1024))          # 输出示例: '1024'
print(str([1, 2, 3]))     # 输出示例: '[1, 2, 3]'

12. bytes([source[, encoding[, errors]]]) 二进制序列

构建不可变的二进制字节序列。字符串转换时必须指定编码格式（如 utf-8）。

b = bytes("Python", encoding="utf-8")
print(b, len(b))  # 输出示例: b'Python' 6

13. bytearray([source[, encoding[, errors]]]) 二进制序列

与 bytes 对应，构建可变的字节数组，支持原地修改、追加和切片赋值。

ba = bytearray(b"Hello")
ba[0] = ord("h")
print(ba)  # 输出示例: bytearray(b'hello')

14. memoryview(obj) 缓冲机制

创建引用支持缓冲区协议的对象（如 bytes、bytearray）的内存视图，支持零内存拷贝的切片操作。

data = bytearray(b"abcdefgh")
mv = memoryview(data)
sub = mv[2:6]
print(bytes(sub))  # 输出示例: b'cdef'

15. list([iterable]) 序列容器

构建动态可变列表，常用于立即物化生成器、迭代器或复制可迭代对象。

nums = list(range(1, 5))
print(nums)  # 输出示例: [1, 2, 3, 4]

16. tuple([iterable]) 序列容器

构建不可变元组。元组内存开销更小，可作为字典键或 set 的元素。

t = tuple([10, 20, 30])
print(t)  # 输出示例: (10, 20, 30)

17. range(stop) / range(start, stop[, step]) 序列容器

生成代表不可变整数序列的范围对象。具备惰性特征，无论序列多大仅占用固定的小额内存。

r = range(0, 10, 2)
print(list(r))  # 输出示例: [0, 2, 4, 6, 8]

18. set([iterable]) 集合容器

构建无序且元素唯一的可变集合。常用于数组去重与求交集、并集运算。

raw = [1, 2, 2, 3, 3, 4]
unique = set(raw)
print(unique)  # 输出示例: {1, 2, 3, 4}

19. frozenset([iterable]) 集合容器

构建不可变集合。由于具备可哈希特性，frozenset 可以作为字典的 key 或放入其他 set 中。

fs = frozenset([1, 2, 3])
d = {fs: "group_a"}
print(d[fs])  # 输出示例: group_a

20. dict(**kwarg) / dict(mapping, **kwarg) / dict(iterable, **kwarg) 映射容器

构建键值对哈希字典。支持键值二元对列表直接转换为字典映射。

pairs = [("id", 101), ("status", "active")]
user_dict = dict(pairs)
print(user_dict)  # 输出示例: {'id': 101, 'status': 'active'}

21. slice(stop) / slice(start, stop[, step]) 切片对象

创建切片对象，在自定义类重载 __getitem__ 或定义通用数据截取模板时使用。

s = slice(1, 5, 2)
data = ["a", "b", "c", "d", "e", "f"]
print(data[s])  # 输出示例: ['b', 'd']

三、序列遍历与数据流处理流程（8个）

在实际生产开发中，高阶迭代函数常串联成一条完整的数据管道：从数据提取，到清洗、映射、配对和稳定排序。下图展示了内置函数在此类场景中的标准流转顺序。

22. len(s) 序列操作

返回对象的长度（元素个数）。对于 Python 原生容器，len() 直接读取 C 结构体中的 ob_size 字段，时间复杂度恒定为 O(1)。

print(len("Python3"))  # 输出示例: 7
print(len([1, 2, 3]))  # 输出示例: 3

23. sorted(iterable, *, key=None, reverse=False) 序列操作

对任意可迭代对象排序，并返回全新的排序列。采用自适应稳定的 Timsort 算法，原列表不受任何修改。

words = ["apple", "banana", "fig", "pear"]
# 按单词长度降序排列
print(sorted(words, key=len, reverse=True))  # 输出示例: ['banana', 'apple', 'pear', 'fig']

24. reversed(seq) 序列操作

返回一个反向迭代器。序列必须实现 __reversed__() 或支持序列协议（包含 __len__() 和按整数下标访问的 __getitem__()）。

letters = ["A", "B", "C"]
print(list(reversed(letters)))  # 输出示例: ['C', 'B', 'A']

25. enumerate(iterable, start=0) 迭代增强

返回枚举迭代器，每个产出项为 (index, item) 元组。彻底杜绝手动维护递增下标的冗余写法。

fruits = ["apple", "orange", "pear"]
for i, item in enumerate(fruits, start=1):
    print(f"{i}: {item}")
# 输出示例:
# 1: apple
# 2: orange
# 3: pear

26. zip(*iterables, strict=False) 迭代增强

并行拉链聚合多个可迭代对象。在 Python 3.10+ 中推荐指定 strict=True，当输入长度不一致时会抛出 ValueError，有效预防静默丢弃长列表尾部元素。

names = ["Alice", "Bob"]
ages = [25, 30]
print(dict(zip(names, ages)))  # 输出示例: {'Alice': 25, 'Bob': 30}

27. filter(function, iterable) 高阶函数

使用 function 测试 iterable 的每个元素，仅保留返回真值的项。若 function 传入 None，则直接保留所有真值元素。

raw = [0, 15, False, "data", ""]
print(list(filter(None, raw)))  # 输出示例: [15, 'data']

28. map(function, iterable, ...) 高阶函数

将 function 应用于输入序列的每个元素，返回惰性计算的映射迭代器。

str_nums = ["1", "2", "3"]
ints = list(map(int, str_nums))
print(ints)  # 输出示例: [1, 2, 3]

29. iter(object[, sentinel]) 与 30. next(iterator[, default]) 迭代器核心协议

iter() 获取迭代器；双参数形态持续调用可调用对象直到返回哨兵值 sentinel。next() 获取下一个值，提供 default 可避免迭代耗尽引发 StopIteration。

it = iter([10, 20])
print(next(it))           # 输出示例: 10
print(next(it))           # 输出示例: 20
print(next(it, "EOF"))    # 输出示例: EOF

四、真值判断与聚合统计（3个）

用于对集合数据做快速聚合与全量/存在性短路逻辑校验。

31. all(iterable) 逻辑判断

如果 iterable 的所有元素均为真值（或该可迭代对象为空），则返回 True。具有短路特性，一旦遇到 False 立即中断返回。

scores = [85, 92, 78, 90]
print(all(s >= 60 for s in scores))  # 输出示例: True (全员及格)

32. any(iterable) 逻辑判断

如果 iterable 中存在任一真值元素，返回 True；若全部为假或为空，返回 False。遇到首个 True 立即短路。

alerts = [False, False, True, False]
print(any(alerts))  # 输出示例: True (存在报警)

33. sum(iterable, /, start=0) 聚合统计

从 start 开始对 iterable 从左到右求和累加。注意拼接字符串必须使用 "".join(seq)，sum() 会主动拒绝字符串序列拼接。

print(sum([10, 20, 30]))        # 输出示例: 60
print(sum([10, 20], start=100)) # 输出示例: 130

五、作用域检查与动态反射机制（11个）

Python 解释器在运行时通过 LEGB（Local -> Enclosing -> Global -> Built-in）规则解析标识符。同时，Python 提供了强大的动态反射工具，允许程序在不知道对象内部结构的前提下安全探索与操纵其属性。

34. globals() 与 35. locals() 作用域内省

globals() 返回当前模块的全局命名空间字典；locals() 返回当前函数局部作用域的快照字典（函数内修改 locals 字典不会同步到真实局部变量）。

def demo():
    val = 42
    print("val" in locals())  # 输出示例: True

demo()
print("__name__" in globals())  # 输出示例: True

36. vars([object]) 反射机制

返回模块、类、实例或任何具有 __dict__ 属性对象的字典映射。若无参数，等价于调用 locals()。

class Config:
    def __init__(self):
        self.host = "localhost"
        self.port = 8080

c = Config()
print(vars(c))  # 输出示例: {'host': 'localhost', 'port': 8080}

37. dir([object]) 反射机制

返回对象的有效属性名称列表。无参调用时返回当前本地作用域中的名称。

print(dir([])[:3])  # 输出示例: ['__add__', '__class__', '__class_getitem__']

38. hasattr / 39. getattr / 40. setattr / 41. delattr 属性四大件

动态检查、提取、设置与删除对象属性的四组核心反射函数。getattr() 提供 default 参数是实现容错编程的推荐手段。

class Service:
    pass

srv = Service()
setattr(srv, "timeout", 30)
print(hasattr(srv, "timeout"))              # 输出示例: True
print(getattr(srv, "timeout", 10))          # 输出示例: 30
print(getattr(srv, "not_exist_key", 500))   # 输出示例: 500 (默认回退)
delattr(srv, "timeout")
print(hasattr(srv, "timeout"))              # 输出示例: False

42. callable(object) 反射机制

检查对象是否可以被调用（如函数、类、定义了 __call__() 方法的实例）。

print(callable(len))    # 输出示例: True
print(callable(1024))   # 输出示例: False

43. id(object) 内存地址

返回对象的唯一整数身份标识。在 CPython 实现中，该整数直接对应对象在内存中的虚拟地址。用于快速判断两个变量是否引用同一个对象（即 is 运算的基础）。

x = [1, 2]
y = x
print(id(x) == id(y))  # 输出示例: True

44. hash(object) 哈希计算

返回对象的哈希值（整数）。只有不可变对象（如 int, str, tuple, frozenset）才是可哈希的；用于字典键和集合快速寻址。

print(hash("admin"))  # 输出示例: 整数哈希值 (如 7389201847120)

六、面向对象与类型内省（8个）

负责类定义、继承关系判别以及高级元编程。

45. type(object) 与 type(name, bases, dict) 类型与元类

单参数时返回对象所属的类型；三参数时用于动态元编程构造全新的类对象。

# 单参数: 获取类型
print(type(42))  # 输出示例: <class 'int'>

# 三参数: 动态创建名为 Person 的类
Person = type("Person", (), {"greeting": "hello"})
p = Person()
print(p.greeting)  # 输出示例: hello

46. isinstance(object, classinfo) 与 47. issubclass(class, classinfo) 继承关系检测

isinstance 检查对象是否为指定类或其子类的实例，第二个参数支持类型元组；issubclass 校验两个类之间的派生关系。相比 type(x) == T，它们完全遵循多态继承原则。

class Animal: pass
class Dog(Animal): pass

d = Dog()
print(isinstance(d, Animal))          # 输出示例: True (支持父类判定)
print(issubclass(Dog, Animal))        # 输出示例: True
print(isinstance("hello", (int, str)))# 输出示例: True (多类型元组匹配)

48. super([type[, object-or-type]]) 继承与 MRO

返回代理对象，将方法调用委托给父类或兄弟类。遵循方法解析顺序（MRO），彻底解决多继承菱形问题。

class Base:
    def greet(self):
        return "Base"

class Child(Base):
    def greet(self):
        return super().greet() + " -> Child"

print(Child().greet())  # 输出示例: Base -> Child

49. object() 基类构建

返回一个没有特性功能的最简对象。object 是 Python 中所有新式类的终极基类。常用作独一无二的哨兵值（Sentinel）。

SENTINEL = object()

def get_value(d, key):
    val = d.get(key, SENTINEL)
    if val is SENTINEL:
        return "Key not found"
    return val

50. property(fget=None, fset=None, fdel=None, doc=None) 描述符

创建托管属性的描述符对象。通常以 @property 装饰器语法修饰方法，实现对私有字段的访问拦截与合法性校验。

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

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

    @radius.setter
    def radius(self, val):
        if val <= 0:
            raise ValueError("半径必须大于零")
        self._radius = val

c = Circle(5)
print(c.radius)  # 输出示例: 5

51. classmethod(function) 与 52. staticmethod(function) 方法装饰

classmethod 将方法绑定为类方法，首参数接收类本身 cls，常用于备选工厂构造器；staticmethod 将方法转换为无隐含首参数的静态普通函数。

class DateUtils:
    @classmethod
    def from_string(cls, date_str):
        year, month, day = map(int, date_str.split("-"))
        return cls()

    @staticmethod
    def is_valid_year(year):
        return 1900 <= year <= 2100

print(DateUtils.is_valid_year(2026))  # 输出示例: True

七、输入输出与字符串表示（8个）

终端交互、文本输入、文件持久化及字符串编码转换。

53. print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False) 标准输出

将对象以字符串形式输出到流文件。支持自定义元素间隔符 sep、结尾符 end 及强制即时刷盘 flush=True。

print("2026", "10", "31", sep="-")  # 输出示例: 2026-10-31
print("Loading...", end="", flush=True)

54. input([prompt]) 标准输入

从标准输入读取一行文本，自动剥除行尾换行符并以字符串形式返回。如果读取到 EOF 则抛出 EOFError。

# 交互读取示例
# name = input("请输入用户名: ")
# print(f"欢迎, {name}!")

55. open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 文件操作

打开文件并返回对应的文件流对象。务必搭配 with 上下文管理器使用，并明确显式指定 encoding="utf-8"。

# 推荐的标准读取范式
# with open("data.txt", "r", encoding="utf-8") as f:
#     content = f.read()

56. format(value[, format_spec]) 格式化

根据格式化规范说明符转换格式。支持数字填充对齐、千分位分隔符及定点精度呈现。

print(format(1234567, ","))    # 输出示例: 1,234,567
print(format(0.856, ".1%"))    # 输出示例: 85.6%
print(format(42, "06d"))       # 输出示例: 000042

57. repr(object) 与 58. ascii(object) 字符串表征

repr() 生成面向开发者的解释器可重现字符串；ascii() 则在 repr() 基础上进一步将所有非 ASCII 字符转义为 \uXXXX 编码。

s = "你好"
print(repr(s))   # 输出示例: '你好'
print(ascii(s))  # 输出示例: '\u4f60\u597d'

59. ord(c) 与 60. chr(i) 字符与码点

ord() 接收单字符返回其对应的 Unicode 整数码点；chr() 接收 Unicode 码点整数返回对应的单字符，两者构成互逆操作。

code = ord("A")
print(code)       # 输出示例: 65
print(chr(65))    # 输出示例: A
print(chr(20013)) # 输出示例: 中

八、进制转换与交互辅助（4个）

用于底层二进制/八进制/十六进制字符串表示，以及交互式控制台环境帮助文档查询。

61. bin(x) / 62. oct(x) / 63. hex(x) 进制转换

将整数转换为对应进制的前缀字符串：0b（二进制）、0o（八进制）、0x（十六进制）。

n = 42
print(bin(n))  # 输出示例: 0b101010
print(oct(n))  # 输出示例: 0o52
print(hex(n))  # 输出示例: 0x2a

64. help([object]) 交互帮助

启动内置帮助系统或直接打印指定对象的 docstring 帮助说明。无实参调用时在 REPL 进入交互式帮助系统。

# 打印字符串方法的帮助文档
# help(str.split)

九、代码编译、动态执行与导入（4个）

用于动态生成字节码、执行字符串脚本以及底层模块导入。

65. eval(expression[, globals[, locals]]) 动态求值

解析并执行单个 Python 表达式，并返回计算结果。注意：严禁将其直接用于处理不可信的客户端输入，防止任意代码执行注入攻击。

res = eval("3 * x + 1", {"x": 10})
print(res)  # 输出示例: 31

66. exec(object[, globals[, locals]]) 动态执行

动态执行多行 Python 代码块、语句与复杂脚本，返回值恒为 None。

code = """
for i in range(3):
    total += i
"""
scope = {"total": 0}
exec(code, scope)
print(scope["total"])  # 输出示例: 3

67. compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 字节码预编译

将源码字符串编译为代码对象（Code Object），供 eval() 或 exec() 反复执行。对高频动态代码可大幅消除重复编译开销。

# 预编译为表达式字节码
code_obj = compile("x ** 2 + y ** 2", "<string>", "eval")
print(eval(code_obj, {"x": 3, "y": 4}))  # 输出示例: 25

68. __import__(name, globals=None, locals=None, fromlist=(), level=0) 底层导入

由 import 语句调用的底层函数。日常开发中进行动态加载模块时，推荐使用标准库封装更好的 importlib.import_module()。

# 动态加载 math 模块
m = __import__("math")
print(m.sqrt(16))  # 输出示例: 4.0

💡 补充版本演进说明： 在 Python 3.7+ 中新增了内置函数 breakpoint(*args, **kws) 用于快速唤起 pdb 调试器；在 Python 3.10+ 中新增了 aiter() 与 anext() 用于支持异步可迭代对象（Async Iterator）协议。本文梳理的 68 个内置函数是跨越 Python 3 全系最为纯粹稳固的标准基石。

十、日常开发选型与决策避坑指南

了解了全部内置函数之后，日常编写代码时的核心原则是“按需选型、避免反模式”。下图总结了 5 类高频业务开发场景下的函数选型决策标准。

核心避坑与最佳实践总结

严禁覆盖内置函数标识符： 切勿定义名为 list = [1, 2]、dict = {} 或 str = "text" 的局部变量，这会导致当前作用域后续无法调用同名内置构造函数。
类型判断首选 isinstance： 始终使用 isinstance(obj, (A, B)) 替代 type(obj) == A，以保证面向对象多态与继承关系的正常派生。
避免使用 eval 解析结构化数据： 针对 JSON、字典或数值字符串的解析，优先使用 json.loads() 或 ast.literal_eval()，从源头消灭任意代码执行的安全漏洞。
优先利用惰性迭代器： 对于百万级批量数据转换，使用 map() 与 filter() 搭配生成器表达式，比直接生成巨大全量列表节省 90% 以上的临时内存消耗。