【内置函数】84个Python内置函数全整理

Python 内置函数全集（完整分类 + 参数详解 + 示例）

🔗 官方文档：https://docs.python.org/3/library/functions.html

本文完整覆盖 Python 所有内置函数（截至 Python 3.12，共 84 个），每个函数都按分类分层讲解，涵盖：

• 函数签名与参数说明
• 精确功能描述
• 使用示例代码（标准 Python 风格）
• 标注版本限制（若有）

一、数值与数学函数

abs(x)

返回数值的绝对值。可用于整数、浮点数或复数。

abs(-3)       # 3
abs(-3.5)     # 3.5
abs(3 + 4j)   # 5.0

divmod(a, b)

返回一个 (商, 余数) 的元组，等价于 (a // b, a % b)。

divmod(9, 4)     # (2, 1)
divmod(8.5, 2)   # (4.0, 0.5)

pow(x, y, mod=None)

返回 x ** y。如果给出 mod，返回 x**y % mod。

pow(2, 3)         # 8
pow(2, 3, 5)      # 3

round(number[, ndigits])

返回 number 四舍五入的值。可选 ndigits 指定保留几位小数。

round(3.14159, 2)   # 3.14
round(3.5)          # 4

sum(iterable, /, start=0)

对 iterable 中所有元素求和，并加上 start 初始值（默认是 0）。

sum([1, 2, 3])            # 6
sum((1.5, 2.5), 1.0)      # 5.0

hash(obj)

返回对象的哈希值，常用于哈希表、集合等。

hash("abc")     # 整数，值视实现平台不同而不同
hash((1, 2, 3)) # 元组可哈希

二、类型转换函数（构造器）

int(x=0, base=10)

将 x 转换为整数。如果是字符串，可提供 base（如 2, 16）。

int("100", 2)     # 4
int(3.9)          # 3

float(x)

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

float("3.14")     # 3.14
float(10)         # 10.0

complex(real, imag=0)

构造复数，实部为 real，虚部为 imag。

complex(2, 3)     # (2+3j)

str(obj)

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

str(123)          # '123'
str([1, 2])       # '[1, 2]'

bool(x)

将对象转换为布尔值，遵循 Python 真值判断规则。

bool(0)           # False
bool("hello")     # True

bytes(source, encoding) / bytes(length)

返回一个 bytes 对象。

bytes("hi", "utf-8")       # b'hi'
bytes(3)                   # b'\x00\x00\x00'

三、迭代与函数式编程工具

all(iterable)

只要 iterable 中所有元素为真（或为空），返回 True。

all([1, 2, 3])        # True
all([0, 1, 2])        # False

any(iterable)

只要 iterable 中有一个元素为真，返回 True。

any([0, 0, 1])        # True
any([])               # False

aiter(async_iterable)

🔹 Python 3.10+
返回异步迭代器（用于 async for 语句）。

# 用于异步生成器场景中

anext(async_iterator[, default])

🔹 Python 3.10+
获取异步迭代器的下一个元素。

# 通常用于 async 上下文中

enumerate(iterable, start=0)

返回带索引的迭代器，元素为 (index, item)。

for i, ch in enumerate("abc"):
    print(i, ch)
# 0 a
# 1 b
# 2 c

filter(function, iterable)

筛选 iterable 中使 function(item) 为 True 的元素。

list(filter(lambda x: x % 2 == 0, range(5)))  # [0, 2, 4]

map(function, iterable, …)

将 function 应用于 iterable 的每个元素。

list(map(str.upper, ['a', 'b']))   # ['A', 'B']

zip(*iterables)

并行组合多个可迭代对象为元组序列。

list(zip([1, 2], ['a', 'b']))      # [(1, 'a'), (2, 'b')]

iter(obj[, sentinel])

获取对象的迭代器；或创建带哨兵值的调用器迭代器。

it = iter([10, 20])
next(it)     # 10

# 特例：可从函数创建终止控制的迭代器

next(iterator[, default])

从迭代器中取下一个值，若耗尽则返回 default（若提供）。

next(iter("abc"))        # 'a'

reversed(seq)

返回反向迭代器，仅适用于序列类型（如 list、str）。

list(reversed("abc"))    # ['c', 'b', 'a']

继续添加中…

四、字符串与字符处理函数

ascii(obj)

返回对象的 ASCII 表示（转义非 ASCII 字符）。

ascii("你好")       # '\u4f60\u597d'

bin(x)

返回整数的二进制字符串。

bin(10)            # '0b1010'

chr(i)

返回 Unicode 编码为 i 的字符。

chr(97)            # 'a'

format(value, format_spec=‘’)

返回格式化字符串（等价于 format() 方法）。

format(255, 'x')   # 'ff'

hex(x)

返回整数的十六进制表示。

hex(255)           # '0xff'

oct(x)

返回整数的八进制表示。

oct(8)             # '0o10'

ord©

返回字符的 Unicode 编码值。

ord('a')           # 97

repr(obj)

返回对象的“官方字符串表示”，通常可被 eval() 执行。

repr("abc")        # "'abc'"

五、输入输出与执行控制

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

标准输出函数，可指定分隔符、结尾等。

print("Hello", "World", sep=", ", end="!")   # Hello, World!

input(prompt=None)

接收用户输入，返回字符串。

name = input("Your name: ")

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

计算字符串表达式的值。

eval("2 + 2")      # 4

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

执行任意 Python 代码字符串或代码对象。

exec("x = 5")
print(x)           # 5

compile(source, filename, mode)

将字符串编译为代码对象，用于 eval() 或 exec()。

code = compile("3+4", "<string>", "eval")
eval(code)         # 7

六、对象检查与反射

callable(obj)

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

callable(len)      # True

getattr(obj, name[, default])

获取对象属性（字符串形式指定）。

getattr("abc", "upper")()    # 'ABC'

hasattr(obj, name)

判断对象是否有某属性。

hasattr(str, "split")        # True

setattr(obj, name, value)

为对象设置属性值。

class A: pass
setattr(A, "x", 42)
A.x                        # 42

delattr(obj, name)

删除对象属性。

class B:
    y = 10
delattr(B, "y")

id(obj)

返回对象的“身份标识”（地址）。

id("abc")                  # 返回一个整数（唯一 ID）

type(obj) / type(name, bases, dict)

返回对象类型，或动态创建新类型。

type(123)                  # <class 'int'>

isinstance(obj, classinfo)

判断对象是否属于某类或其子类。

isinstance(3.5, float)     # True

issubclass(cls, classinfo)

判断类是否为另一个类的子类。

issubclass(bool, int)      # True

七、类与方法控制函数

classmethod(function)

将函数包装为类方法，第一个参数是类本身。

class A:
    @classmethod
    def hello(cls):
        return cls.__name__

A.hello()        # 'A'

staticmethod(function)

将函数包装为静态方法，无需传递实例或类。

class A:
    @staticmethod
    def greet():
        return "Hi!"

A.greet()        # 'Hi!'

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

将方法定义为属性（可读/写/删）。

class Circle:
    def __init__(self, r):
        self._r = r

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

c = Circle(5)
c.radius        # 5

super([type[, obj]])

用于调用父类方法。

class A:
    def greet(self): return "Hello"

class B(A):
    def greet(self): return super().greet() + " from B"

B().greet()      # "Hello from B"

八、容器构造函数

list([iterable])

构建列表。

list("abc")         # ['a', 'b', 'c']

tuple([iterable])

构建元组。

tuple([1, 2])       # (1, 2)

dict([mapping or iterable])

构建字典。

dict(a=1, b=2)      # {'a': 1, 'b': 2}

set([iterable])

构建集合。

set([1, 2, 2])      # {1, 2}

frozenset([iterable])

构建不可变集合。

frozenset("abca")   # frozenset({'a', 'b', 'c'})

九、作用域与变量访问

globals()

返回当前全局作用域的字典。

globals()["x"] = 42
x              # 42

locals()

返回当前局部作用域的变量字典。

def f(): a = 1; return locals()

vars([object])

返回对象的 __dict__，或当前本地变量。

class A:
    def __init__(self): self.x = 1
vars(A())         # {'x': 1}

十、内存与字节工具

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

构造不可变字节对象。

bytes("hi", "utf-8")    # b'hi'

bytearray([source[, encoding[, errors]]])

构造可变字节数组。

bytearray("hi", "utf-8")  # bytearray(b'hi')

memoryview(obj)

返回给定对象的内存视图。

memoryview(b"abc")[1]    # 98

十一、其他函数

object()

返回一个最基本的对象实例。

object()         # <object object at ...>

help([object])

调用内置帮助系统。

help(str)

open(file, mode=‘r’, …)

打开文件。

f = open("file.txt", "r")

ord(char)

返回字符的整数 Unicode 编码。

ord('A')         # 65

slice(start, stop[, step])

创建切片对象。

s = slice(1, 4)
"hello"[s]       # 'ell'

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

返回排序后的新列表。

sorted([3, 1, 2])        # [1, 2, 3]

len(s)

返回容器长度。

len("hello")             # 5

breakpoint()

🔹 Python 3.7+
触发调试器（默认调用 pdb.set_trace()）。

breakpoint()

import(name, globals=None, locals=None, fromlist=(), level=0)

底层的 import 实现函数。

math = __import__("math")
math.sqrt(16)            # 4.0

总结与建议

• 内置函数是 Python 最精华的“基础工具库”，不容忽视！
• 掌握它们，不仅能减少代码量、提升效率，还能避免命名错误和轮子重造。
• 配合 help() 和实际练习理解其行为细节。