Python 内置函数大全

Python 内置函数大全：名称、作用与使用方法

Python 内置函数（Built-in Functions）是 Python 自带的一组函数，不需要导入任何模块，就可以直接使用。它们用于数据类型转换、数学运算、字符串处理、集合操作、文件读写、对象检查等场景。

例如：

print("Hello Python")   # 输出内容
len([10, 20, 30])       # 获取列表长度，结果为 3
type(123)               # 查看数据类型，结果为 <class 'int'>
str(123)                # 转换为字符串，结果为 "123"

Python 内置函数和你自己定义的函数不同：内置函数由 Python 提供，而自定义函数通常通过 def 定义。

下面按照实际开发中的用途，系统整理各个内置函数，并提供用法和示例。

官方文档按照字母顺序列出了 Python 内置函数。需要注意，int()、str()、list() 等同时也是内置类型的构造器，因此日常所说的"内置函数"通常也会把它们一起学习。

image

Python 3.15.0 documentation

+1

一、先认识最常用的内置函数

下面这 20 个建议优先掌握，它们在日常 Python 开发中非常常见。

函数	作用	示例	返回结果
print()	输出内容	print("Hello")	输出 Hello
len()	获取长度	len("Python")	6
type()	查看类型	type(123)	int 类型
isinstance()	判断类型	isinstance(123, int)	True
int()	转整数	int("123")	123
float()	转浮点数	float("3.14")	3.14
str()	转字符串	str(123)	"123"
bool()	转布尔值	bool(0)	False
list()	转列表	list("abc")	['a', 'b', 'c']
dict()	创建字典	dict(a=1)	{'a': 1}
set()	创建集合、去重	set([1, 1, 2])	{1, 2}
range()	生成整数序列	list(range(3))	[0, 1, 2]
enumerate()	同时获取索引和值	list(enumerate(["a", "b"]))	[(0, 'a'), (1, 'b')]
zip()	配对多个序列	list(zip([1, 2], ["a", "b"]))	[(1, 'a'), (2, 'b')]
sorted()	排序	sorted([3, 1, 2])	[1, 2, 3]
sum()	求和	sum([1, 2, 3])	6
max()	求最大值	max([1, 5, 3])	5
min()	求最小值	min([1, 5, 3])	1
abs()	求绝对值	abs(-10)	10
open()	打开文件	open("a.txt", "r")	文件对象

其中，open() 涉及文件资源管理，后面会专门介绍更安全的 with open(...) 写法。

二、全部内置函数分类详解

以下按照功能分类，覆盖 Python 常见版本中的内置函数，以及常用的内置类型构造器。不同 Python 版本可能存在少量差异。

1. 输出、输入与调试

① print() --- 输出内容

print("Hello")
print("姓名：", "张三")
print(1, 2, 3, sep="-", end="!")
# 输出：1-2-3!

sep 设置多个值之间的分隔符，end 设置输出结尾，默认是换行。

② input() --- 获取用户输入

name = input("请输入姓名：")
print(name)

注意：input() 返回的始终是字符串。需要数字时，应根据情况使用 int() 或 float() 转换。

③ breakpoint() --- 设置调试断点

x = 10breakpoint()
print(x)

程序执行到这里会进入调试器，便于检查变量和执行状态。

④ help() --- 查看帮助

help(len)
help(str)

用于查询函数、类型或对象的说明。

2. 数据类型转换与创建

函数	用途	示例
bool(x)	转布尔值	bool("") → False
int(x)	转整数	int("12") → 12
float(x)	转浮点数	float("2.5") → 2.5
complex(x)	创建复数	complex(2, 3) → (2+3j)
str(x)	转字符串	str(123) → "123"
bytes(x)	创建不可变字节序列	bytes([65, 66]) → b'AB'
bytearray(x)	创建可变字节序列	bytearray([65, 66])
list(x)	创建列表	list("ab") → ['a', 'b']
tuple(x)	创建元组	tuple([1, 2]) → (1, 2)
dict(x)	创建字典	dict([("a", 1)]) → {'a': 1}
set(x)	创建集合	set([1, 1, 2]) → {1, 2}
frozenset(x)	创建不可变集合	frozenset([1, 2])
range(...)	创建整数范围对象	list(range(1, 4)) → [1, 2, 3]
slice(...)	创建切片对象	slice(1, 5, 2)
object()	创建基础对象	obj = object()
memoryview(x)	创建内存视图	memoryview(b"abc")

注意：range(1, 4) 表示从 1 开始，到 4 之前结束；它本身不是列表。

3. 数学计算与数字处理

函数	用途	示例
abs(x)	绝对值	abs(-5) → 5
round(x, n)	四舍五入规则下的舍入	round(3.14159, 2) → 3.14
pow(x, y)	幂运算	pow(2, 3) → 8
divmod(a, b)	同时求商和余数	divmod(10, 3) → (3, 1)
sum(x)	求和	sum([1, 2, 3]) → 6
max(x)	最大值	max(1, 8, 3) → 8
min(x)	最小值	min(1, 8, 3) → 1

pow() 还支持三个参数：

pow(2, 3, 5)  
# 2 的 3 次方再对 5 取余，结果为 3

4. 类型判断与对象检查

函数	用途	示例
type(x)	查看对象的类型	type("abc")
isinstance(x, T)	判断对象是否属于某类型	isinstance(1, int)
issubclass(A, B)	判断类 A 是否为类 B 的子类	issubclass(bool, int) → True
callable(x)	判断对象是否可调用	callable(print) → True
id(x)	获取对象身份标识	id(obj)
hash(x)	获取哈希值	hash("abc")
dir(x)	查看对象的属性和方法	dir("abc")
vars(x)	获取对象的 __dict__	vars(obj)
repr(x)	获取面向开发者的表示形式	repr("a\nb")
ascii(x)	将非 ASCII 字符转义表示	ascii("中文")
format(x, spec)	按指定格式生成字符串	format(3.14, ".1f") → "3.1"
chr(n)	Unicode 编码转字符	chr(65) → 'A'
ord(c)	字符转 Unicode 编码	ord("A") → 65

type() 和 isinstance() 的区别尤其重要：

class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

print(type(dog) == Animal)  # False
print(isinstance(dog, Animal))  # True

当需要判断继承关系时，通常优先考虑 isinstance()。

5. 列表、集合与迭代器操作

函数	用途	示例
len(x)	获取元素数量	len([1, 2, 3]) → 3
sorted(x)	返回排序后的新列表	sorted([3, 1, 2])
reversed(x)	获取反向迭代器	list(reversed([1, 2, 3]))
enumerate(x)	遍历时获取索引和值	list(enumerate(["a", "b"]))
zip(a, b)	将多个可迭代对象配对	list(zip([1, 2], ["a", "b"]))
iter(x)	获取迭代器	it = iter([1, 2])
next(it)	获取下一个元素	next(it)
map(f, x)	将函数应用到每个元素	list(map(str, [1, 2]))
filter(f, x)	筛选符合条件的元素	list(filter(lambda n: n > 2, [1, 3]))
all(x)	判断所有元素是否为真	all([True, True]) → True
any(x)	判断是否存在真值元素	any([False, True]) → True

其中 map() 和 filter() 在数据处理时比较有用：

numbers = [1, 2, 3, 4, 5]

# 每个数字乘以 2
result = list(map(lambda x: x * 2, numbers))
# [2, 4, 6, 8, 10]

# 只保留偶数
result = list(filter(lambda x: x % 2 == 0, numbers))
# [2, 4]

在很多场景下，也可以使用列表推导式，代码往往更容易阅读：

[x * 2 for x in numbers]
[x for x in numbers if x % 2 == 0]

6. 字符串格式化与进制转换

函数	用途	示例
bin(x)	整数转二进制字符串	bin(10) → '0b1010'
oct(x)	整数转八进制字符串	oct(10) → '0o12'
hex(x)	整数转十六进制字符串	hex(255) → '0xff'
format(x, spec)	格式化值	format(12.345, ".2f") → '12.35'
ascii(x)	生成 ASCII 转义表示	ascii("中")
repr(x)	获取对象表示字符串	repr([1, 2]) → '[1, 2]'

例如，格式化金额、百分比和日期显示时经常会使用 format()：

price = 12.5

print(format(price, ".2f"))  # 12.50
print(format(0.25, ".0%"))   # 25%

7. 文件与数据读取

函数	用途	示例
open()	打开文件	open("data.txt", "r", encoding="utf-8")

open() 虽然只有一个函数，但有多种模式：

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

# 写入文本，会覆盖原有内容
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("Hello")

常见模式：

• r：读取。
• w：写入并覆盖原内容。
• a：追加内容。
• x：仅在文件不存在时创建。
• b：二进制模式，例如 rb 读取 PDF 或其他二进制文件。

读取大文件时，不建议直接调用 f.read() 一次性读取全部内容，可以使用 for line in f 或分块读取。

8. 属性、变量与命名空间操作

这组函数在面向对象编程、框架开发和动态访问属性时很常见。

函数	用途	示例
getattr(obj, name)	获取对象属性	getattr(obj, "name")
setattr(obj, name, value)	设置对象属性	setattr(obj, "name", "张三")
hasattr(obj, name)	检查属性是否存在	hasattr(obj, "name")
delattr(obj, name)	删除对象属性	delattr(obj, "name")
globals()	获取全局命名空间字典	globals()
locals()	获取当前局部命名空间	locals()

例如：

class User:
    pass

user = User()

setattr(user, "name", "张三")

print(getattr(user, "name"))       # 张三
print(hasattr(user, "name"))       # True

delattr(user, "name")

print(hasattr(user, "name"))       # False

getattr() 的第三个参数可以设置默认值，避免属性不存在时报错：

name = getattr(user, "name", "未知用户")
print(name)  # 未知用户

9. 类、继承与面向对象编程

函数	用途	示例或说明
property()	将方法包装成属性访问接口	property(getter, setter)
classmethod()	将方法声明为类方法的底层构造器	@classmethod
staticmethod()	将方法声明为静态方法的底层构造器	@staticmethod
super()	访问父类的实现	super().__init__()
type()	查看类型，也可动态创建类	type("User", (), {})
object()	创建最基础的对象	obj = object()

你之前问过的 @staticmethod 就属于这一类。实际开发中通常使用装饰器语法：

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

print(Calculator.add(1, 2))  # 3

property() 也可以用于属性封装：

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

    @property
    def name(self):
        return self._name

user = User("张三")
print(user.name)  # 张三

10. 字符串与代码的动态执行

函数	用途	示例
compile()	将源代码编译为代码对象	compile("1 + 2", "<string>", "eval")
eval()	执行 Python 表达式并返回结果	eval("1 + 2") → 3
exec()	执行 Python 语句	exec("x = 10")
__import__()	底层导入模块的机制	__import__("math")

重要安全提醒：不要对不可信的用户输入使用 eval() 或 exec()。 它们可能执行任意 Python 代码，造成数据泄露、文件被修改或其他安全问题。__import__() 一般也不需要直接调用，常规情况下使用 import 语句即可。

image

Python 3.15.0 documentation

11. 其他常用的内置函数

函数	用途	示例
iter(callable, sentinel)	持续调用函数，直到返回指定终止值	iter(read_chunk, b"")
aiter()	获取异步迭代器	aiter(async_iterable)
anext()	获取异步迭代器的下一个元素	await anext(iterator)
__import__()	执行底层模块导入	__import__("json")
hash()	获取对象哈希值	hash(123)
id()	获取对象身份标识	id(obj)

aiter() 和 anext() 用于异步编程，常见于异步网络请求、异步数据流等场景。

三、容易混淆的几个函数

map()、filter() 和 zip() 有什么区别？

map()：转换数据

list(map(str, [1, 2, 3]))# ['1', '2', '3']

将函数应用到每个元素。

filter()：筛选数据

list(filter(lambda x: x > 2, [1, 2, 3, 4]))# [3, 4]

保留符合条件的元素。

zip()：组合数据

list(zip(["张三", "李四"], [18, 20]))# [('张三', 18), ('李四', 20)]

按对应位置组合多个可迭代对象。

sorted() 和 reversed() 有什么区别？

numbers = [3, 1, 2]print(sorted(numbers))                 # [1, 2, 3]print(list(reversed(numbers)))         # [2, 1, 3]print(numbers)                         # [3, 1, 2]

• sorted()：按排序规则重新排列。
• reversed()：反转原有顺序，不负责排序。
• 两者都不会直接修改上面的原列表。

all() 和 any() 有什么区别？

print(all([True, True, False]))  # Falseprint(any([True, True, False]))  # True

• all()：所有元素都为真才返回 True。
• any()：至少一个元素为真就返回 True。

注意，Python 中的 0、None、""、[] 等通常属于假值，而非空字符串 "False" 仍然是真值。

四、进阶内置函数补充

下面补充一些不那么常用、但完整学习时值得认识的函数。

函数	用法与示例	说明
next()	next(iter([10, 20])) → 10	获取迭代器下一个值
slice()	s = slice(1, 4); [1,2,3,4,5][s] → [2,3,4]	创建切片规则
vars()	vars(obj)	查看对象的实例属性字典（如果有）
staticmethod()	通常写作 @staticmethod	声明静态方法
classmethod()	通常写作 @classmethod	声明类方法
property()	通常写作 @property	将方法作为属性访问
super()	super().__init__()	调用父类实现
compile()	compile("1+2", "", "eval")	编译表达式或代码
memoryview()	memoryview(b"abc")	创建零拷贝内存视图（适用于支持缓冲区协议的对象）
bytearray()	bytearray(b"abc")	创建可修改的字节序列
frozenset()	frozenset([1, 2, 2])	创建不可变集合
callable()	callable(len) → True	检查对象是否可调用
chr()	chr(65) → 'A'	编码转字符
ord()	ord('A') → 65	字符转编码
hex()	hex(255) → '0xff'	转十六进制字符串
oct()	oct(8) → '0o10'	转八进制字符串
bin()	bin(5) → '0b101'	转二进制字符串
hash()	hash(123)	获取哈希值
id()	id(obj)	获取对象身份标识
ascii()	ascii("你好")	返回带非 ASCII 字符转义的表示
repr()	repr("hello") → "'hello'"	获取对象的表示字符串

另外，aiter() 和 anext() 是异步迭代专用函数，适用于异步生成器等对象。eval()、exec() 和 __import__() 属于较高级的动态执行或导入机制，初学时了解即可。

image

Python 3.15.0 documentation

+1

五、如何查看你当前 Python 版本支持的内置函数？

Python 可以直接使用 dir() 和 __builtins__ 查看当前环境。

import builtins# 查看所有内置名称print(dir(builtins))# 只筛选可调用的内置对象names = [    name    for name in dir(builtins)    if callable(getattr(builtins, name))]print(names)print("数量：", len(names))

注意，这会同时列出函数、类型和异常类等可调用对象，并不等于纯粹的内置函数数量。

官方参考文档：

• Python 内置函数官方文档（英文）
• Python 内置类型官方文档（英文）

六、建议按照什么顺序学习？

考虑到你正在系统学习 Python 语法，我建议按下面的顺序掌握，不必一次记住所有函数。

第一阶段：基础语法

print()、input()、type()、len()、int()、float()、str()、bool()、isinstance()

目标：熟悉输入输出、数据类型与类型转换。

第二阶段：数据处理

list()、dict()、set()、range()、enumerate()、zip()、sorted()、sum()、max()、min()

目标：熟练处理列表、字典、集合和循环。

第三阶段：实际开发

open()、getattr()、hasattr()、map()、filter()、all()、any()、next()、iter()

目标：读写文件、处理数据、理解对象与迭代器。

第四阶段：进阶开发

property()、classmethod()、staticmethod()、super()、globals()、locals()、compile()

目标：掌握面向对象、命名空间与动态机制。

最重要的建议： 不需要背诵所有内置函数。先掌握基础类型转换、容器操作、循环和文件读写；当实际代码遇到陌生函数时，再查官方文档并练习使用。这样比一次记忆全部名称更有效。