整体说明

  • Python 中，内置函数是可以直接使用的（无需额外导入任何模块）
  • Python 的内置函数完整列表可参考官方文档：Built-in Functions — Python 3.9.16 documentation
  • 本文内容总结自非官方分类，部分内容非规范写法

基础数据类型相关

  • int() ：转换为整数
  • float() ：转换为浮点数
  • str() ：转换为字符串
  • bool() ：转换为布尔值（True 或 False）
  • list() ：创建或转换为列表
  • tuple() ：创建或转换为元组
  • dict() ：创建字典
  • set() ：创建集合
  • complex() ：转换为复数

数学运算相关

  • abs(x) ：返回绝对值
  • round(x, n) ：四舍五入到指定小数位数
  • pow(x, y) ：返回 x 的 y 次幂（等价于 x**y）
  • sum(iterable) ：计算可迭代对象中所有元素的和
  • min(iterable) 和 max(iterable) ：返回最小值/最大值

类型检查与帮助相关

  • type(obj) ：返回对象的类型
  • isinstance(obj, class) ：检查对象是否是某个类的实例
  • help(obj) ：显示对象的帮助文档
  • dir(obj) ：返回对象的所有属性和方法

输入输出相关

  • print(*objects) ：打印对象到标准输出
  • input(prompt) ：从标准输入读取用户输入
  • open(file, mode) ：打开文件并返回文件对象

迭代与序列处理相关

  • len(obj) ：返回对象的长度（元素个数）
  • range(start, stop, step) ：生成不可变的整数序列
  • sorted(iterable) ：返回新的已排序列表
  • reversed(seq) ：返回反向迭代器
  • enumerate(iterable) ：返回索引-值对的枚举对象
  • zip(*iterables) ：将多个可迭代对象的元素打包成元组

函数与对象操作相关

  • map(func, iterable) ：对可迭代对象的每个元素应用函数
  • filter(func, iterable) ：过滤可迭代对象中的元素
  • reduce(func, iterable) ：（需从 functools 导入）累积计算可迭代对象的元素
  • lambda args: expression ：创建匿名函数
  • getattr(obj, name) 和 setattr(obj, name, value) ：获取/设置对象的属性

一些其他常用函数

  • id(obj) ：返回对象的唯一标识符（内存地址）
  • hash(obj) ：返回对象的哈希值（如果可哈希）
  • chr(i) ：将整数转换为对应的 Unicode 字符
  • ord(c) ：返回字符的 Unicode 码点
  • bin(x)**、oct(x)、hex(x)** ：转换为二进制、八进制、十六进制字符串
  • eval(expression) ：执行字符串表达式并返回结果
  • exec(code) ：执行字符串形式的 Python 代码

整体说明

  • Python 本身不支持传统意义上的函数重载（overload）（即同名函数根据参数个数/类型自动匹配调用）
    • 因为 Python 是动态类型语言，函数定义时不指定参数类型，且同名函数会直接覆盖前一个定义
  • 虽然 Python 无原生函数重载，但可通过“参数判断”“singledispatch”“multipledispatch”模拟效果
    • 简单场景用“手动判断参数”，按类型重载用 singledispatch，复杂多参数重载用 multipledispatch
  • Python 不允许同名函数并存（后定义的会覆盖前一个），因此“模拟重载”的本质是：
    • 在同一个函数中，通过判断参数个数（*args/**kwargs） 或参数类型 ，分支执行不同逻辑

Python 不支持原生重载的原因

  • 动态类型 ：Python 变量无类型声明，函数参数类型由运行时传入的值决定，无法在定义时区分“同名不同类型”的函数
  • 命名空间机制 ：函数定义后会存入当前命名空间，同名函数会直接覆盖前一个（后定义的函数地址覆盖前一个）
  • 例如，以下代码中，后定义的 foo 会覆盖前一个，调用时只会执行第二个： 
    1
    2
    3
    4
    5
    6
    7
    def foo(a):
        print(f"1个参数：{a}")

    def foo(a, b):
        print(f"2个参数：{a}, {b}")

    foo(1)    # 报错：foo() missing 1 required positional argument: 'b'（第一个 foo 已被覆盖）

方式 1：手动判断参数个数/类型

  • 通过 *args 接收可变参数，再根据参数长度/类型分支执行 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    def calculate(a, b=None, c=None):
        """根据参数个数，实现加法/乘法/幂运算的重载效果"""
        # 1. 传入 1 个参数：计算 a 的平方（a^2）
        if b is None and c is None:
            return a **2
        # 2. 传入 2 个参数：计算 a + b
        elif c is None:
            return a + b
        # 3. 传入 3 个参数：计算 a * b * c
        else:
            return a * b * c

    # 测试不同参数调用
    print(calculate(5))      # 1 个参数：5^2 = 25
    print(calculate(2, 3))   # 2 个参数：2+3 = 5
    print(calculate(2, 3, 4))# 3 个参数：2*3*4 = 24

方式 2：使用 functools.singledispatch（按参数类型重载）

  • Python 3.4+ 提供的 functools.singledispatch 装饰器，可实现“基于第一个参数的类型”的重载（单分派重载） 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    from functools import singledispatch

    # 基函数（默认实现）
    @singledispatch
    def process_data(data):
        """处理任意类型数据（默认逻辑）"""
        return f"未知类型数据：{data}"

    # 重载 1：处理 int 类型
    @process_data.register(int)
    def _(data):
        return f"整数类型：{data}，平方为 {data**2}"

    # 重载 2：处理 str 类型
    @process_data.register(str)
    def _(data):
        return f"字符串类型：{data}，长度为 {len(data)}"

    # 重载 3：处理 list 类型
    @process_data.register(list)
    def _(data):
        return f"列表类型：{data}，元素和为 {sum(data)}"

    # 测试不同类型参数
    print(process_data(10))          # 整数类型：10，平方为 100
    print(process_data("hello"))     # 字符串类型：hello，长度为 5
    print(process_data([1,2,3,4]))   # 列表类型：[1,2,3,4]，元素和为 10
    print(process_data(3.14))        # 未知类型数据：3.14（触发默认实现）

方式 3：使用第三方库 multipledispatch（支持多参数类型/个数重载）

  • 第三方库 multipledispatch 支持更灵活的重载（如根据多个参数的类型、个数匹配）
    • multipledispatch 是第三方库，需先安装 pip install multipledispatch
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      from multipledispatch import dispatch

      # 两个 int 类型参数：加法
      @dispatch(int, int)
      def add(a, b):
          return f"int + int = {a + b}"

      # 一个 int + 一个 str 类型：拼接
      @dispatch(int, str)
      def add(a, b):
          return f"int + str = {str(a) + b}"

      # 三个 int 类型参数：求和
      @dispatch(int, int, int)
      def add(a, b, c):
          return f"int + int + int = {a + b + c}"

      # 两个 list 类型参数：合并
      @dispatch(list, list)
      def add(a, b):
          return f"list + list = {a + b}"

      # 测试不同参数组合
      print(add(2, 3))                # int + int = 5
      print(add(2, "苹果"))           # int + str = 2苹果
      print(add(1, 2, 3))             # int + int + int = 6
      print(add([1,2], [3,4]))        # list + list = [1,2,3,4]

附录：@overload 装饰器

  • Python 中使用 @overload 装饰器的类型提示重载，但不是真正的运行时重载，而是 静态类型提示重载
    • 仅用于给类型检查工具（如 mypy）、IDE（如 PyCharm）提供类型信息，帮助开发者避免类型错误，运行时仍需一个 实际实现函数 来处理所有参数情况
  • Python 3.5+ 引入的 typing.overload 装饰器，作用是：
    • 为同一个函数的不同参数组合（类型/个数/关键字参数要求） 提供明确的类型注解
    • 不影响运行时逻辑（运行时会忽略 @overload 装饰的函数体，只执行最后一个 实际实现函数）
    • 解决 动态类型语言的类型模糊问题 ，让 IDE 能精准提示参数类型，类型检查工具能发现类型错误