Python 内置函数是语言原生提供的核心工具函数，无需导入任何模块即可直接调用，覆盖类型转换、序列操作、逻辑判断、输入输出、数学运算等全场景需求。这些函数经过底层优化，执行效率高，是 Python 编程的基础核心。截至 Python 3.12 版本，共有 69 个内置函数，下文按功能分类逐一解析，结合实例说明用法与细节，助力高效运用。

一、类型转换函数（14个）

此类函数用于不同数据类型间的转换，部分函数同时支持创建对应类型的空对象或从可迭代对象生成新对象，是数据处理的基础工具。

1. int(x, base=10)：将对象 x 转换为整数，base 指定进制（默认十进制，范围 2-36），无参数时返回 0。print(int("123")) # 十进制转换，输出：123 print(int("1010", 2)) # 二进制转整数，输出：10 print(int()) # 无参数，输出：0

2. float(x)：将对象 x 转换为浮点数，无参数时返回 0.0，支持整数、字符串形式的数值转换。 print(float(123)) # 整数转浮点数，输出：123.0 print(float("3.14")) # 字符串转浮点数，输出：3.14 print(float()) # 无参数，输出：0.0

3. str(object=”)：将对象转换为字符串，无参数时返回空字符串，支持自定义编码与格式化。 print(str(123)) # 整数转字符串，输出：'123' print(str([1,2,3])) # 列表转字符串，输出：'[1, 2, 3]' print(str()) # 无参数，输出：''

4. bool(x)：将对象 x 转换为布尔值，遵循“空即 False，非空即 True”规则（0、”、[]、None 等返回 False）。 print(bool(0)) # 输出：False print(bool([1])) # 输出：True print(bool()) # 无参数，输出：False

5. list([iterable])：创建列表，可从可迭代对象（字符串、元组等）生成，无参数时返回空列表。 print(list("Python")) # 字符串转列表，输出：['P','y','t','h','o','n'] print(list((1,2,3))) # 元组转列表，输出：[1,2,3] print(list()) # 无参数，输出：[]

6. tuple([iterable])：创建元组（不可变序列），用法与 list 一致，无参数时返回空元组。 print(tuple([1,2,3])) # 列表转元组，输出：(1,2,3) print(tuple()) # 无参数，输出：()

7. dict( kwargs) / dict(mapping, kwargs) / dict(iterable, kwargs)**：创建字典，支持三种初始化方式，无参数时返回空字典。 print(dict(name="Alice", age=18)) # 关键字参数创建，输出：{'name':'Alice','age':18} print(dict([('name','Bob'), ('age',20)])) # 可迭代对象创建，输出：{'name':'Bob','age':20} print(dict()) # 无参数，输出：{}

8. set([iterable])：创建集合（无序、无重复元素），可去重，无参数时返回空集合。 print(set([1,2,2,3])) # 列表转集合（去重），输出：{1,2,3} print(set()) # 无参数，输出：set()

9. frozenset([iterable])：创建不可变集合，无法添加/删除元素，支持集合运算，无参数时返回空不可变集合。 fs = frozenset([1,2,3]) print(fs) # 输出：frozenset({1,2,3})

10. bytes([source[, encoding[, errors]]])：创建字节对象，可从字符串（需指定编码）或可迭代对象生成，无参数时返回空字节串。print(bytes("Python", encoding="utf-8")) # 字符串转字节，输出：b'Python' print(bytes()) # 无参数，输出：b''

11. bytearray([source[, encoding[, errors]]])：创建可变字节数组，用法与 bytes 类似，支持修改元素。 ba = bytearray("abc", encoding="utf-8") ba[0] = 97 # 修改第一个元素（ASCII码97对应'a'） print(ba) # 输出：bytearray(b'abc')

12. complex(real=0, imag=0)：创建复数，real 为实部，imag 为虚部，支持从字符串转换。 print(complex(3, 4)) # 输出：(3+4j) print(complex("3+4j")) # 字符串转复数，输出：(3+4j)

13. memoryview(obj)：创建内存视图对象，用于直接访问对象的内存缓冲区（无需复制数据），仅支持可缓冲对象（如 bytes、bytearray）。mv = memoryview(bytes("abc", "utf-8")) print(mv[0]) # 访问第一个字节的ASCII码，输出：97

14. range(stop) / range(start, stop[, step])：创建range对象（整数序列生成器），step 默认为1，不包含 stop 值，常用于循环。print(list(range(5))) # 输出：[0,1,2,3,4] print(list(range(2, 10, 2))) # 步长为2，输出：[2,4,6,8]

二、序列与集合操作函数（12个）

此类函数用于对序列（列表、字符串、元组）、集合、字典等可迭代对象进行统计、排序、遍历、拼接等操作，是数据处理的核心工具。

1. len(s)：返回对象 s 的长度（元素个数），支持序列、集合、字典、字符串等可迭代对象及字节对象。 print(len([1,2,3])) # 列表长度，输出：3 print(len({"name":"Alice", "age":18})) # 字典长度（键值对个数），输出：2

2. max(iterable, [, key, default]) / max(arg1, arg2, args[, key])：返回可迭代对象的最大值或多个参数中的最大值，key 指定排序函数，default 为可迭代对象为空时的默认值。 print(max([1,3,2])) # 列表最大值，输出：3 print(max("abc", key=ord)) # 按ASCII码取最大值，输出：'c' print(max([], default=0)) # 空列表默认值，输出：0

3. min(iterable, [, key, default]) / min(arg1, arg2, args[, key])：与 max 对应，返回最小值。 print(min((5,1,3))) # 元组最小值，输出：1 print(min("xyz", key=ord)) # 输出：'x'

4. sum(iterable, start=0)：计算可迭代对象中所有元素的和，start 为初始值（默认 0），仅支持数值类型元素。 print(sum([1,2,3])) # 输出：6 print(sum([1,2,3], start=10)) # 初始值10，输出：16

5. *sorted(iterable, , key=None, reverse=False)**：对可迭代对象排序，返回新列表（不修改原对象），key 指定排序依据，reverse 控制升序/降序（默认升序）。 print(sorted([3,1,2])) # 升序排序，输出：[1,2,3] print(sorted([(2,"b"),(1,"a")], key=lambda x:x[0])) # 按第一个元素排序，输出：[(1,'a'),(2,'b')]

6. reversed(seq)：返回可迭代对象的反向迭代器，需转换为列表/元组查看结果，不修改原对象。 print(list(reversed([1,2,3]))) # 输出：[3,2,1] print(tuple(reversed("Python"))) # 输出：('n','o','h','t','y','P')

7. enumerate(iterable, start=0)：返回枚举迭代器，每个元素为 (索引, 元素) 元组，start 指定起始索引（默认 0）。 for idx, val in enumerate(["a","b","c"], start=1): print(idx, val) # 输出：1 a 2 b 3 c

8. *zip(iterables)**：将多个可迭代对象打包为元组迭代器，长度与最短的可迭代对象一致，Python 3 中返回迭代器。 print(list(zip([1,2], ["a","b"]))) # 输出：[(1,'a'),(2,'b')] print(list(zip([1,2,3], ["a","b"]))) # 按最短对象打包，输出：[(1,'a'),(2,'b')]

9. all(iterable)：判断可迭代对象中所有元素是否为 True，空可迭代对象返回 True。 print(all([True, 1, "a"])) # 输出：True print(all([True, 0])) # 存在False元素，输出：False print(all([])) # 空对象，输出：True

10. any(iterable)：判断可迭代对象中是否存在至少一个 True 元素，空可迭代对象返回 False。 print(any([False, 0, ""])) # 无True元素，输出：False print(any([False, 1])) # 存在True元素，输出：True print(any([])) # 空对象，输出：False

11. filter(function, iterable)：用 function 过滤可迭代对象，返回包含所有使 function 返回 True 的元素的迭代器，function 为 None 时过滤 False 元素。 def is_even(x): return x % 2 == 0 print(list(filter(is_even, [1,2,3,4]))) # 过滤偶数，输出：[2,4] print(list(filter(None, [0,1,"",True]))) # 过滤False元素，输出：[1,True]

12. *map(function, iterables)*：用 function 对可迭代对象的每个元素处理，返回迭代器，多个可迭代对象需保证长度一致。 `print(list(map(lambda x:x2, [1,2,3]))) # 元素翻倍，输出：[2,4,6] print(list(map(lambda x,y:x+y, [1,2], [3,4]))) # 两列表元素相加，输出：[4,6]`

三、输入输出与格式化函数（4个）

此类函数用于程序与用户、文件的交互，实现输入获取、结果输出及字符串格式化，是交互类程序的基础。

1. *print(objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)**：输出对象到指定流（默认控制台），sep 控制元素分隔符，end 控制结尾字符，flush 强制刷新缓冲区。 print("Hello", "Python", sep="-") # 分隔符为'-'，输出：Hello-Python print("End", end="!") # 结尾为'!'，输出：End!

2. input([prompt])：获取用户控制台输入，返回字符串类型，prompt 为输入提示语。 name = input("请输入姓名：") # 接收用户输入 print(f"你好，{name}") # 输出用户输入的姓名

3. format(value, format_spec=”)：格式化字符串，支持位置参数、关键字参数及复杂格式控制（数值精度、日期格式等）。 print(format(3.14159, ".2f")) # 保留2位小数，输出：3.14 print(format("Python", ">10")) # 右对齐，占10位，输出：' Python'

4. repr(object)：返回对象的官方字符串表示（可用于重建对象），区别于 str（面向用户的友好表示）。 print(repr("Python")) # 输出：'Python'（带引号） print(str("Python")) # 输出：Python（无引号）

四、数学运算函数（10个）

此类函数提供基础数学运算功能，覆盖绝对值、取整、幂运算、进制转换等，无需导入 math 模块即可使用。

1. abs(x)：返回数字 x 的绝对值，支持整数、浮点数、复数（返回模）。 print(abs(-5)) # 整数绝对值，输出：5 print(abs(3.14-5)) # 浮点数绝对值，输出：1.86 print(abs(3+4j)) # 复数模，输出：5.0

2. round(number, ndigits=None)：对数字四舍五入，ndigits 指定保留小数位数（默认 None，返回整数）。 print(round(3.14159)) # 无小数位，输出：3 print(round(3.14159, 2)) # 保留2位小数，输出：3.14

3. pow(base, exp, mod=None)：计算 base^exp（底数的指数次幂），mod 存在时计算 (base^exp) % mod，效率高于 base**exp % mod。 print(pow(2, 3)) # 2^3，输出：8 print(pow(2, 3, 5)) # (8) %5，输出：3

4. divmod(a, b)：返回元组 (a // b, a % b)，即商和余数的组合，适用于整数、浮点数。 print(divmod(10, 3)) # 10//3=3，10%3=1，输出：(3,1) print(divmod(10.5, 3)) # 浮点数运算，输出：(3.0, 1.5)

5. hex(x)：将整数 x 转换为十六进制字符串，前缀为 ‘0x’。 print(hex(10)) # 输出：'0xa' print(hex(255)) # 输出：'0xff'

6. oct(x)：将整数 x 转换为八进制字符串，前缀为 ‘0o’。 print(oct(8)) # 输出：'0o10' print(oct(7)) # 输出：'0o7'

7. bin(x)：将整数 x 转换为二进制字符串，前缀为 ‘0b’。 print(bin(2)) # 输出：'0b10' print(bin(5)) # 输出：'0b101'

8. chr(i)：将整数 i（ASCII 码，范围 0-1114111）转换为对应的字符。 print(chr(65)) # ASCII码65对应'A'，输出：'A' print(chr(128512)) # 表情符号，输出：'😀'

9. ord(c)：与 chr 对应，返回字符 c 的 ASCII 码或 Unicode 编码值。 print(ord('A')) # 输出：65 print(ord('😀')) # 输出：128512

10. ascii(object)：返回对象的 ASCII 字符串表示，非 ASCII 字符用转义序列表示。 print(ascii('😀')) # 输出：'\U0001f600' print(ascii('Python你好')) # 输出：'Python\u4f60\u597d'

五、对象与属性操作函数（11个）

此类函数用于获取对象信息、操作对象属性、判断对象类型，是面向对象编程及调试的重要工具。

1. id(object)：返回对象的唯一标识符（内存地址的整数表示），同一对象在生命周期内 id 不变。 a = [1,2,3] print(id(a)) # 输出对象a的内存地址（整数）

2. type(object) / type(name, bases, dict)：返回对象的类型，或动态创建类（name 类名，bases 父类元组，dict 属性字典）。 `print(type(123)) # 输出：

3. 动态创建类 MyClass = type(“MyClass”, (object,), {“name”:”test”}) print(MyClass.name) # 输出：test`

4. dir([object])：返回对象的属性和方法列表，无参数时返回当前作用域的变量、函数列表。 print(dir(list)) # 输出列表类的所有属性和方法 print(dir()) # 输出当前作用域的变量列表

5. getattr(object, name[, default])：获取对象的属性值，name 为属性名（字符串），属性不存在时返回 default（无 default 则报错）。 class Person: name = "Alice" p = Person() print(getattr(p, "name")) # 输出：'Alice' print(getattr(p, "age", 18)) # 不存在age属性，返回默认值18

6. setattr(object, name, value)：设置对象的属性值，name 为属性名，value 为属性值，属性不存在则新增。 setattr(p, "age", 18) print(p.age) # 输出：18

7. delattr(object, name)：删除对象的属性，属性不存在则报错。 `delattr(p, “age”)

8. print(p.age) # 报错：AttributeError`

9. hasattr(object, name)：判断对象是否存在指定属性（name 为字符串），返回布尔值。 print(hasattr(p, "name")) # 存在name属性，输出：True print(hasattr(p, "age")) # 不存在age属性，输出：False

10. isinstance(object, classinfo)：判断对象是否为指定类（或类元组）的实例，支持继承关系。 print(isinstance(123, int)) # 输出：True print(isinstance([1,2,3], (list, tuple))) # 属于列表或元组，输出：True

11. issubclass(class, classinfo)：判断类是否为指定类（或类元组）的子类，支持多层继承。 class Animal: pass class Dog(Animal): pass print(issubclass(Dog, Animal)) # 输出：True

12. vars([object])：返回对象的属性字典（dict），无参数时返回当前作用域的局部变量字典。 print(vars(p)) # 输出p的属性字典：{'name':'Alice'} print(vars()) # 输出当前局部变量字典

13. help([object])：调用 Python 帮助系统，输出对象的帮助信息（文档字符串、用法等），无参数时进入交互帮助界面。 help(list) # 输出列表类的帮助信息 help(p.name) # 输出p.name的帮助信息

六、迭代器与生成器函数（2个）

此类函数用于创建或操作迭代器，是 Python 迭代编程的核心，支持惰性计算（按需生成元素）。

1. iter(object[, sentinel])：创建迭代器，object 为可迭代对象时直接返回迭代器；sentinel 存在时，object 需为可调用对象，迭代至返回值等于 sentinel 时停止。 `it = iter([1,2,3]) print(next(it)) # 输出：1

2. 带sentinel的用法 import sys it = iter(sys.stdin.readline, ”) # 读取输入至空行停止`

3. next(iterator[, default])：获取迭代器的下一个元素，迭代结束时返回 default（无 default 则报错 StopIteration）。 print(next(it)) # 输出：2 print(next(it)) # 输出：3 print(next(it, "迭代结束")) # 迭代结束，返回默认值：'迭代结束'

七、异常处理与执行函数（4个）

此类函数用于执行动态代码、处理异常、终止程序，适用于脚本执行、调试及异常捕获场景。

1. compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)：将源代码编译为字节码对象，可用于 exec 或 eval 执行，filename 为代码来源文件名，mode 为执行模式（’exec’ 语句块、’eval’ 表达式、’single’ 单条语句）。 code = compile("print('Hello Python')", "", "exec") exec(code) # 输出：Hello Python

2. eval(expression, globals=None, locals=None)：执行字符串表达式，返回表达式结果，仅支持单个表达式（不支持语句块）。 result = eval("1+2*3") print(result) # 输出：7

3. exec(object, globals=None, locals=None)：执行动态代码（语句块、函数定义等），无返回值，支持复杂代码逻辑。 exec(""" def add(a, b): return a + b print(add(2,3)) """) # 输出：5

4. exit([code]) / quit([code])：终止 Python 解释器，code 为退出状态码（0 表示正常退出，非 0 表示异常退出），仅在交互模式下常用。 exit() # 退出Python交互环境

八、其他常用内置函数（12个）

此类函数覆盖垃圾回收、资源管理、空值判断等特殊场景，虽使用频率不及上述类别，但在特定场景下不可或缺。

1. None：空值对象（非函数，属于内置常量），表示“无”，是所有对象的共同基类 NoneType 的唯一实例，判断时用 is None。 x = None print(x is None) # 输出：True

2. import(name, globals=None, locals=None, fromlist=(), level=0)：动态导入模块，等价于 import 语句，常用于动态加载模块场景。 math = __import__("math") print(math.pi) # 输出：3.141592653589793

3. open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：打开文件并返回文件对象，用于文件读写，需注意关闭文件（建议用 with 语句自动关闭）。 with open("test.txt", "w", encoding="utf-8") as f: f.write("Hello Python") with open("test.txt", "r", encoding="utf-8") as f: print(f.read()) # 输出：Hello Python

4. copyright()：输出 Python 的版权信息，仅在交互模式下有效。 copyright() # 输出Python版权信息

5. credits()：输出 Python 贡献者信息，仅在交互模式下有效。

6. license()：输出 Python 的许可证信息，仅在交互模式下有效。

7. gc：垃圾回收模块（非函数，属于内置模块），提供手动控制垃圾回收的接口，如 gc.collect() 强制回收垃圾。 import gc gc.collect() # 强制执行垃圾回收

8. quit()：与 exit() 功能一致，终止 Python 解释器，交互模式专用。

9. staticmethod：装饰器，将类方法定义为静态方法（无需实例化即可调用，无 self 参数）。 class Math: @staticmethod def add(a, b): return a + b print(Math.add(2,3)) # 输出：5

10. classmethod：装饰器，将类方法定义为类方法（第一个参数为 cls，代表类本身，可通过类或实例调用）。 class Person: name = "Human" @classmethod def get_name(cls): return cls.name print(Person.get_name()) # 输出：Human

11. property：装饰器，将类方法转换为属性，支持属性的读取、设置、删除控制。 class Person: def __init__(self, age): self._age = age @property def age(self): return self._age p = Person(18) print(p.age) # 输出：18（像属性一样访问方法）

12. super([type[, object-or-type]])：调用父类的方法，用于继承场景中扩展父类功能，避免硬编码父类名。 class Animal: def speak(self): print("Animal speaks") class Dog(Animal): def speak(self): super().speak() # 调用父类方法 print("Dog barks") d = Dog() d.speak() # 输出：Animal speaks Dog barks

九、内置函数使用注意事项

• 避免覆盖内置函数：内置函数名不可用作变量名、函数名或类名（如len = 10 会覆盖 len 函数，导致后续无法正常使用）。

• 版本兼容性：部分函数在 Python 3.x 中有调整（如 zip、map、filter 在 Python 3 中返回迭代器，Python 2 中返回列表），需注意环境适配。

• 安全风险：eval、exec 函数可执行动态代码，若接收用户输入的代码，可能导致代码注入攻击，生产环境需谨慎使用。

• 迭代器特性：Python 3 中多数内置函数（如 zip、map）返回迭代器，需转换为列表/元组才能直接查看所有元素，且迭代器只能遍历一次。

• 效率优先：内置函数由 C 语言实现，执行效率远高于自定义函数，同等功能优先使用内置函数（如求和用 sum 而非循环累加）。

Python 内置函数覆盖了编程全流程的核心需求，熟练掌握各类函数的用法与场景，能大幅简化代码、提升效率。实际开发中，需结合业务场景灵活选择，同时规避使用误区，让内置函数成为编程效率的“助推器”。