Python常用内置函数速查：50个高频用法与示例

Python 解释器自带了一批无需显式导入（import）即可直接调用的内置函数（Built-in Functions）。在日常工程开发与算法编写中，掌握这些函数的执行语义、边界机制与性能特征，能够大幅减少样板代码，提高运行效率与代码可读性。本文精选生产场景中最高频的 50 个内置函数，分为数值计算、类型转换、序列迭代、对象反射、输入输出及作用域执行六大核心模块，逐一给出典型用法、注意事项与执行示例。

一、数值与数学运算类（7个）

该分类下的函数主要用于标量数值处理、极值统计与算术运算。由于全部由底层 C 语言直接实现，执行性能远优于手写循环。

1. abs(x)

返回数值的绝对值。若参数为复数，则返回该复数的模（模长）。

print(abs(-15.6))       # 示例输出：15.6
print(abs(3 + 4j))       # 示例输出：5.0（复数模长计算）

2. round(number[, ndigits])

返回浮点数的四舍五入值。在 Python 3 中采用“银行家舍入法”（偶数舍入规则，Round half to even），即当保留小数后恰好处于中间的 5 时，向最近的偶数舍入，避免统计正向偏差。

print(round(2.5))        # 示例输出：2（向最近偶数舍入）
print(round(3.5))        # 示例输出：4
print(round(3.14159, 2)) # 示例输出：3.14

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

返回可迭代对象中的最小值或传入参数中的最小值。通过 key 参数可指定自定义权重规则；通过 default 规避序列为空时的 ValueError。

users = [{"name": "Alice", "score": 85}, {"name": "Bob", "score": 92}]
lowest = min(users, key=lambda x: x["score"])
print(lowest["name"])    # 示例输出：Alice
print(min([], default=0))# 示例输出：0（避免抛出异常）

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

返回序列中的最大元素或参数中的最大值，支持与 min() 相同的 key 和 default 参数机制。

words = ["python", "go", "typescript", "c"]
print(max(words, key=len)) # 示例输出：typescript（按字符串长度取最长项）

5. sum(iterable, /, start=0)

对可迭代对象中的数值进行累加求和。可选参数 start 允许指定累加的初始基数。

scores = [88, 92, 79, 95]
print(sum(scores))           # 示例输出：354
print(sum(scores, start=10)) # 示例输出：364（加上初始基数10）

6. pow(base, exp[, mod])

计算底数的指数幂。当传入第三个参数 mod 时，采用蒙哥马利快速幂算法计算 (base ** exp) % mod，在大数密码学运算中速度极快。

print(pow(2, 10))        # 示例输出：1024
print(pow(3, 3, 5))      # 示例输出：2（相当于 (3**3) % 5 = 27 % 5）

7. divmod(a, b)

以二元元组的形式同时返回商和余数 (a // b, a % b)，在分页计算、时间换算场景下省去两次除法运算。

total_seconds = 3665
minutes, seconds = divmod(total_seconds, 60)
hours, minutes = divmod(minutes, 60)
print(f"{hours}小时 {minutes}分钟 {seconds}秒") # 示例输出：1小时 1分钟 5秒

二、类型转换与基础数据构造（9个）

这类函数实际上是 Python 内置核心类型的构造器（Type Constructors），用于将外部数据转化为指定的运行时数据模型。

8. int(x, base=10)

将数值或字符串转换为整数，支持指定转换进制基数（如二进制、十六进制）。

print(int("1010", base=2))  # 示例输出：10
print(int("FF", base=16))   # 示例输出：255
print(int(3.99))            # 示例输出：3（直接截断小数部分）

9. float(x)

将整数或符合浮点格式的字符串转换为双精度浮点数，同时支持解析特殊的科学计数法与 "inf"、"-inf"、"nan"。

print(float("3.1415"))  # 示例输出：3.1415
print(float("1e-3"))    # 示例输出：0.001
print(float("inf"))     # 示例输出：inf（正无穷大）

10. str(object='')

将任意 Python 对象转换为面向人类易读的字符串形式，内部触发对象的 __str__() 协议方法。

data = {"id": 101, "active": True}
print(str(data))        # 示例输出："{'id': 101, 'active': True}"

11. bool(x)

评估对象的布尔真值。在 Python 中，数值 0、None、空容器（[]、{}、""、()）均被判定为 False，其余通常为 True。

print(bool([]))         # 示例输出：False
print(bool([0]))        # 示例输出：True（非空列表）
print(bool("text"))     # 示例输出：True

12. list([iterable])

创建新列表。若传入可迭代对象，则将该迭代器立即展开求值为独立列表，常用于深拷贝一层列表或固化生成器。

gen = (x * 2 for x in range(4))
lst = list(gen)
print(lst)              # 示例输出：[0, 2, 4, 6]

13. tuple([iterable])

创建不可变元组对象。元组可作为字典的键（若元素均可哈希）并具备更高的内存存储效率。

tup = tuple([1, 2, 3])
print(tup)              # 示例输出：(1, 2, 3)

14. set([iterable])

创建无序且不重复的集合对象，常用于高效去重与集合关系运算（并集、交集、差集）。

raw_ids = [101, 102, 101, 103, 102]
unique_ids = set(raw_ids)
print(unique_ids)       # 示例输出：{101, 102, 103}

15. dict(**kwargs) / dict(mapping, **kwargs) / dict(iterable, **kwargs)

创建键值对字典。支持通过关键字参数、二元元组序列或映射关系构造。

pairs = [("host", "127.0.0.1"), ("port", 8080)]
config = dict(pairs)
print(config)           # 示例输出：{'host': '127.0.0.1', 'port': 8080}

16. bytes([source[, encoding[, errors]]])

创建不可变的二进制字节序列，常用于网络通信封包与二进制文件解析。

raw_bytes = bytes("你好", encoding="utf-8")
print(raw_bytes)        # 示例输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'

三、序列与迭代流处理（12个）

Python 编程范式的精髓在于迭代器协议。以下 12 个函数构成了数据流管道处理的核心工具集。

17. len(s)

返回对象中元素的个数。对于列表、字典、元组等内置容器，Python 直接从其底层 C 结构体头部读取 ob_size 字段，时间复杂度为 O(1)。

items = [10, 20, 30]
print(len(items))       # 示例输出：3

18. range(stop) / range(start, stop[, step])

生成不可变连续整数序列。它是一个不可变序列类型，而非一次性生成全部数组，内存占用恒定为 O(1)。

for i in range(1, 10, 3):
    print(i, end=" ")   # 示例输出：1 4 7 

19. enumerate(iterable, start=0)

将一个可遍历的数据对象组合为一个索引序列，同时返回数据下标和数据内容，杜绝手动维护递增下标变量。

fruits = ["apple", "banana", "cherry"]
for idx, fruit in enumerate(fruits, start=1):
    print(f"{idx}: {fruit}")
# 示例输出：
# 1: apple
# 2: banana
# 3: cherry

20. zip(*iterables, strict=False)

将多个可迭代对象对应位置的元素打包成一个个元组。在 Python 3.10+ 中新增 strict=True 参数，当输入序列长度不一致时主动抛出 ValueError，极大降低数据截断隐患。

names = ["Alice", "Bob"]
scores = [95, 88]
mapping = dict(zip(names, scores))
print(mapping)          # 示例输出：{'Alice': 95, 'Bob': 88}

21. reversed(seq)

返回一个反向迭代器。要求传入的对象实现了 __reversed__() 方法或支持序列协议（包含 __len__() 和按整数下标访问的 __getitem__()）。

digits = [1, 3, 5]
for d in reversed(digits):
    print(d, end=" ")   # 示例输出：5 3 1 

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

对所有可迭代对象进行排序，并返回全新的排好序的列表（非原地修改）。底层采用稳定的 Timsort 算法。

words = ["banana", "pie", "apple"]
sorted_words = sorted(words, key=len, reverse=True)
print(sorted_words)     # 示例输出：['banana', 'apple', 'pie']

23. filter(function, iterable)

过滤序列中不满足条件的元素。若 function 传入 None，则自动剔除所有假值元素（如 0、空字符串、None 等）。

raw = [0, 1, False, 2, "", 3, None]
valid = list(filter(None, raw))
print(valid)            # 示例输出：[1, 2, 3]

24. map(function, *iterables)

将指定的变换函数作用于可迭代对象的每个元素，返回惰性迭代器。若传入多个序列，则每次从各序列按相同索引取值传给函数。

nums = ["10", "20", "30"]
integers = list(map(int, nums))
print(integers)         # 示例输出：[10, 20, 30]

25. any(iterable)

只要可迭代对象中存在一个元素为真，即返回 True；全部为假或序列为空时返回 False。具备短路特性。

status = [False, False, True, False]
print(any(status))      # 示例输出：True

26. all(iterable)

仅当可迭代对象中所有元素均为真时返回 True；若存在任何一个假值立即短路返回 False。序列为空时返回 True。

scores = [85, 90, 78, 92]
is_all_pass = all(s >= 60 for s in scores)
print(is_all_pass)      # 示例输出：True

27. iter(object[, sentinel])

获取对象的迭代器。双参数形式下，重复调用 object() 直到其返回值等于 sentinel 哨兵值为止，在读取定长二进制块或循环网络数据时极其优雅。

# 示例：通过哨兵迭代器逐块读取文件
with open("sample.txt", "w") as f:
    f.write("Line1\nLine2\nSTOP\nLine3\n")

with open("sample.txt", "r") as f:
    # 遇到 "STOP\n" 时自动终止迭代
    for line in iter(f.readline, "STOP\n"):
        print(line.strip())
# 示例输出：
# Line1
# Line2

28. next(iterator[, default])

从迭代器中检索下一项。当迭代器耗尽时，若未提供 default 会抛出 StopIteration；提供 default 则返回该默认值。

it = iter([10, 20])
print(next(it))                  # 示例输出：10
print(next(it))                  # 示例输出：20
print(next(it, "已耗尽"))        # 示例输出：已耗尽

四、对象内省与属性反射（11个）

Python 是一门动态语言，反射机制允许开发者在运行时检测对象的类型、属性、方法以及进行安全的动态解耦调用。

29. type(object) / type(name, bases, dict)

单参数时返回对象的确切类型；三参数时为元类动态构造全新类对象。

x = 42
print(type(x))                  # 示例输出：<class 'int'>

# 动态元编程创建类
DynamicUser = type("DynamicUser", (object,), {"role": "admin"})
u = DynamicUser()
print(u.role)                   # 示例输出：admin

30. isinstance(object, classinfo)

检查对象是否是指定类或其子类的实例。参数 classinfo 支持传入类型元组进行多条件匹配。相比 type() == Cls，isinstance 正确尊重面向对象的继承多态。

class Animal: pass
class Dog(Animal): pass

d = Dog()
print(isinstance(d, Dog))       # 示例输出：True
print(isinstance(d, Animal))    # 示例输出：True（识别父类）
print(isinstance("hi", (int, str))) # 示例输出：True（匹配联合类型）

31. issubclass(class, classinfo)

检查一个类是否是另一个类的子类（一个类被视为自身的子类）。

print(issubclass(Dog, Animal))  # 示例输出：True
print(issubclass(Dog, object))  # 示例输出：True

32. id(object)

返回对象的“唯一身份标识”（在 CPython 实现中，该整数值即为对象在内存中的虚拟地址）。常用于判定两个变量是否引用同一内存实体（a is b 实质即比较 id(a) == id(b)）。

a = [1, 2]
b = a
print(id(a) == id(b))           # 示例输出：True

33. hasattr(object, name)

判断对象是否拥有指定名称的属性或方法（内部实现为尝试调用 getattr(object, name) 并捕获 AttributeError）。

class Worker:
    def work(self): pass

w = Worker()
print(hasattr(w, "work"))       # 示例输出：True
print(hasattr(w, "salary"))     # 示例输出：False

34. getattr(object, name[, default])

获取对象的属性值。若属性不存在且提供了 default 参数，则返回默认值而不抛出 AttributeError。

class Config:
    timeout = 30

cfg = Config()
print(getattr(cfg, "timeout", 10)) # 示例输出：30
print(getattr(cfg, "retry", 3))    # 示例输出：3（属性缺失返回默认值）

35. setattr(object, name, value)

动态设置对象的属性值。等价于 object.name = value，但允许属性名称以字符串变量的形式动态传入。

class Context: pass

ctx = Context()
setattr(ctx, "trace_id", "REQ-9981")
print(ctx.trace_id)             # 示例输出：REQ-9981

36. delattr(object, name)

动态删除对象的属性，等价于 del object.name。

class TempData:
    cache = "hot"

t = TempData()
delattr(TempData, "cache")
print(hasattr(TempData, "cache")) # 示例输出：False

37. dir([object])

无参数时返回当前局部作用域的变量名列表；传入对象时，返回该对象的所有有效属性与方法名称列表（包含魔术方法）。

num = 10
# 查看包含的核心方法
methods = [m for m in dir(num) if not m.startswith("__")]
print(methods[:3])              # 示例输出：['as_integer_ratio', 'bit_count', 'bit_length']

38. vars([object])

返回对象对应的 __dict__ 属性字典。若无参数，则返回当前局部作用域字典（等价于 locals()）。

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

u = User("Bob")
print(vars(u))                  # 示例输出：{'name': 'Bob'}

39. callable(object)

检查对象是否可被调用（例如函数、类、Lambda 表达式或实现了 __call__() 方法的实例对象）。

def func(): pass
val = 100
print(callable(func))           # 示例输出：True
print(callable(val))            # 示例输出：False

五、输入输出与字符编码类（8个）

这组函数处理程序与外界（控制台、终端、文件磁盘）的数据交互，并负责字符码位与底层字节间的映射。

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

将对象打印输出到指定的文件流或标准输出。通过 sep 控制分隔符，end 控制结束字符，flush=True 强制立即刷新输出缓冲区。

# 实时刷新进度条示例
import time
print("Loading", end="", flush=True)
print("...Done")                # 示例输出：Loading...Done

41. input([prompt])

从标准输入读取一行文本，自动剥离末尾换行符并作为字符串返回。

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

42. open(file, mode='r', encoding=None, errors=None)

打开文件并返回对应的文件对象。在处理文本文件时，务必显式声明 encoding="utf-8"，避免因操作系统默认编码（如 Windows 上的 GBK）不同产生乱码。

with open("example.log", "w", encoding="utf-8") as f:
    f.write("System Ready\n")

43. format(value[, format_spec])

将值转换为按照格式规格字符串说明的“格式化”表示形式，常用于千分位分隔、百分比格式化与进制排版。

print(format(1234567, ","))     # 示例输出：1,234,567
print(format(0.856, ".1%"))     # 示例输出：85.6%
print(format(255, "08b"))       # 示例输出：11111111（8位前导零二进制）

44. repr(object)

返回对象的官方字符串表示形式。通常满足 eval(repr(obj)) == obj 的目标，主要用于调试与日志追踪（能够区分字符串与数字引号）。

s = "hello\nworld"
print(str(s))                   # 会换行输出两行
print(repr(s))                  # 示例输出：'hello\\nworld'（精确保留转义符）

45. ascii(object)

与 repr() 类似，但会对所有非 ASCII 字符通过 \x、\u 或 \U 进行转义，确保生成的内容可在纯 ASCII 环境中安全输出。

print(ascii("Python编程"))      # 示例输出：'Python\\u7f16\\u7a0b'

46. chr(i)

返回 Unicode 码位为整数 i 的对应字符（有效范围为 0 到 0x10FFFF）。

print(chr(65))                  # 示例输出：A
print(chr(8364))                # 示例输出：€

47. ord(c)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码位的整数。与 chr() 互为逆操作。

print(ord('A'))                 # 示例输出：65
print(ord('€'))                 # 示例输出：8364

六、作用域与动态求值类（3个）

这类函数直接访问 Python 虚拟机的符号表（Symbol Table）与执行栈帧，用于动态上下文检索与配置注入。

48. globals()

返回实现当前模块命名空间的字典。在模块级别，这就是全局变量字典。修改该字典会直接影响全局变量。

APP_VERSION = "2.4.0"
g = globals()
print(g["APP_VERSION"])         # 示例输出：2.4.0

49. locals()

更新并返回表示当前局部符号表的字典。在函数代码块中，locals() 提取当前局部变量。在模块级别，locals() 与 globals() 指向同一字典。

def calculate(x, y):
    total = x + y
    scope = locals()
    return scope

res = calculate(10, 20)
print(res)                      # 示例输出：{'x': 10, 'y': 20, 'total': 30}

50. eval(expression[, globals[, locals]])

解析并执行字符串形式的单个 Python 表达式，并返回执行结果。

expr = "10 + 20 * 2"
print(eval(expr))               # 示例输出：50

七、总结与高频使用建议

掌握这 50 个高频内置函数的关键在于建立对 “惰性求值” 与 “类型协议” 的认知模型：

• 流式优先：能用 enumerate()、zip()、filter() 和生成器表达式解决的问题，尽量避免显式创建中间临时大列表，以降低瞬时内存峰值。
• 防守严谨：在反射访问属性时，始终优先使用 getattr(obj, "attr", default) 代替 hasattr + 属性直接点号调用的双重寻址，既提升性能又规避并发多线程下的竞争异常。
• 尊重继承：在进行参数类型验证时，始终选择 isinstance(obj, (TypeA, TypeB))，避免使用 type(obj) == TypeA 破坏面向对象的扩展契约。

将上述内置函数融会贯通，便能写出兼顾执行性能与优雅可读性的惯用 Python（Pythonic）代码。