本文是 2025-10-08 Python 标准库 1——内置函数（1）-CSDN博客的续篇。

参考文档：内置函数 — Python 3.13.7 文档

1. 数值计算与比较

处理数值运算（pow()、sum()）、数值比较（max()、min()）、绝对值 / 四舍五入（abs()、round()）等。

1.1. abs()

• 函数定义：abs(number, /)

• 功能说明：返回一个数字的绝对值。参数可以是整数、浮点数或任何实现了 __abs__() 的对象；如果参数是复数，则返回它的模。

• 使用示例：

  print(abs(-10))       # 输出：10（整数绝对值）
  print(abs(3.14159))   # 输出：3.14159（浮点数绝对值）
  print(abs(3 + 4j))    # 输出：5.0（复数的模，计算方式为√(3²+4²)）
  

1.2. divmod()

• 函数定义：divmod(a, b, /)

• 功能说明：接受两个非复数数字，返回“整数除法的商 + 余数”组成的元组。

  • 整数：结果与 (a // b, a % b) 完全一致。
  • 浮点数：结果为 (q, a % b)，其中 q 通常为 math.floor(a / b)（可能小 1），且满足 q * b + a % b ≈ a，a % b 与 b 同号，0 ≤ abs(a % b) < abs(b)。

• 使用示例：

  # 整数示例
  print(divmod(7, 3))      # 输出：(2, 1)（7//3=2，7%3=1）
  print(divmod(-7, 3))     # 输出：(-3, 2)（-7//3=-3，-7%3=2）
  
  # 浮点数示例
  print(divmod(7.5, 2.5))  # 输出：(3.0, 0.0)
  print(divmod(7.5, 2))    # 输出：(3.0, 1.5)（3.0*2 +1.5=7.5）
  

1.3. max()

• 函数定义：

  max(iterable, /, *, key=None)

  max(iterable, /, *, default, key=None)

  max(arg1, arg2, /, *args, key=None)

• 功能说明：返回可迭代对象中的最大元素，或多个独立参数中的最大值：

  • 单位置参数（iterable）：iterable 需为非空可迭代对象（如列表、元组、字符串），返回其中最大元素；若 iterable 为空，需提供 default 参数（否则引发 ValueError）。
  • 多位置参数（arg1, arg2, *args）：返回多个参数中的最大值（如 max(1, 3, 2) 返回 3）。
  • 关键字参数：
    1. key：指定带单个参数的函数，用于从每个元素中提取“排序键”（如 key=str.lower 忽略大小写比较字符串），默认 None（直接比较元素）；
    2. default：仅当 iterable 为空时生效，返回默认值（仅支持关键字传递）。
  • 特殊规则：若存在多个最大元素，返回第一个找到的元素（与 sorted(iterable, key=key, reverse=True)[0] 行为一致）。

• 版本变更：

  • Python 3.4：新增 default 仅限关键字形参；
  • Python 3.8：key 参数支持设为 None（等价于直接比较）。

• 使用示例：

  # 示例1：可迭代对象（列表），无key
  print(max([3, 1, 4, 1, 5]))  # 输出：5（列表中的最大值）
  
  # 示例2：可迭代对象（字符串），带key（按字符串长度比较）
  words = ['apple', 'banana', 'cherry', 'date']
  print(max(words, key=len))  # 输出：'banana'（长度最长的字符串）
  
  # 示例3：可迭代对象为空，带default
  empty_list = []
  print(max(empty_list, default='No elements'))  # 输出：'No elements'（避免报错）
  
  # 示例4：多个独立参数
  print(max(10, 20, 5, 30))  # 输出：30（多个参数中的最大值）
  
  # 示例5：多个最大元素，返回第一个
  nums = [5, 2, 5, 1]
  print(max(nums))  # 输出：5（第一个出现的最大值）
  

1.4. min()

• 函数定义：

  min(iterable, /, *, key=None)

  min(iterable, /, *, default, key=None)

  min(arg1, arg2, /, *args, key=None)

• 功能说明：返回可迭代对象中的最小元素，或多个独立参数中的最小值，行为与 max() 对称：

  • 单位置参数（iterable）：iterable 需为可迭代对象，返回其中最小元素；若为空，需提供 default（否则引发 ValueError）。
  • 多位置参数（arg1, arg2, *args）：返回多个参数中的最小值。
  • 关键字参数：
    1. key：自定义排序键函数（如 key=lambda x: x[1] 按元组第二个元素比较）；
    2. default：空可迭代对象的默认返回值（仅关键字传递）。
  • 特殊规则：若存在多个最小元素，返回第一个找到的元素（与 sorted(iterable, key=key)[0] 行为一致）。

• 版本变更：

  • Python 3.4：新增 default 仅限关键字形参；
  • Python 3.8：key 参数支持设为 None。

• 使用示例：

  # 示例1：可迭代对象（元组），无key
  print(min((9, 7, 3, 8, 2)))  # 输出：2（元组中的最小值）
  
  # 示例2：可迭代对象（字典项），带key（按字典值比较）
  student_scores = {'Alice': 85, 'Bob': 78, 'Charlie': 92}
  # 转换为键值对元组迭代对象，按值（x[1]）找最小值
  print(min(student_scores.items(), key=lambda x: x[1]))  # 输出：('Bob', 78)
  
  # 示例3：可迭代对象为空，带default
  empty_tuple = ()
  print(min(empty_tuple, default=0))  # 输出：0（避免报错）
  
  # 示例4：多个独立参数，带key（按绝对值比较）
  print(min(-5, -3, 2, key=abs))  # 输出：2（绝对值最小的是2，abs(2)=2）
  
  # 示例5：多个最小元素，返回第一个
  fruits = ['orange', 'apple', 'apple', 'banana']
  print(min(fruits))  # 输出：'apple'（第一个出现的最小值，按字母序）
  

1.5. pow()

• 函数定义：pow(base, exp, mod=None)

• 功能说明：返回 base 的 exp 次幂；若 mod 存在，返回 (base^exp) % mod（比 pow(base, exp) % mod 更高效）。

  • 两参数形式（pow(base, exp)）等价于 base ** exp。
  • 三参数形式（pow(base, exp, mod)）：base 和 exp 为 int 时，mod 需为非零 int；若 exp 为负，base 需与 mod 互质，结果为 pow(inv_base, -exp, mod)（inv_base 是 base 对 mod 的逆元）。

• 版本变更：

  • Python 3.8：三参数形式支持 exp 为负（仅 int 操作数）；支持关键字参数。

• 使用示例：

  # 两参数：基本幂运算
  print(pow(2, 3))      # 输出：8（2^3=8）
  print(pow(10, -2))    # 输出：0.01（10^-2=1/100）
  
  # 三参数：幂运算+取余（高效）
  print(pow(2, 5, 3))   # 输出：2（32 % 3 = 2）
  # 负指数（求逆元）：38对97的逆元是23（23*38 %97=1）
  print(pow(38, -1, mod=97))  # 输出：23
  

1.6. round()

• 函数定义：round(number, ndigits=None)

• 功能说明：返回 number 舍入到小数点后 ndigits 位精度的值。

  • 若 ndigits 省略/为 None：返回最接近输入值的整数。
  • 若 ndigits 为整数（正/负/零）：舍入到 10^(-ndigits) 的倍数；若与两个倍数距离相等，选用偶数（如 round(0.5)=0、round(1.5)=2）。
  • 普通对象：委托给 __round__() 方法。

• 备注：浮点数舍入可能存在精度问题（如 round(2.675, 2) 返回 2.67 而非 2.68），因多数十进制小数无法用浮点数精确表示，详见“浮点算术：争议和限制”。

• 使用示例：

  print(round(2.675, 2))  # 输出：2.67（浮点数精度导致）
  print(round(0.5))       # 输出：0（距离相等时选偶数）
  print(round(1.5))       # 输出：2（距离相等时选偶数）
  print(round(123.456, 1))# 输出：123.5（保留1位小数）
  print(round(1234, -2))  # 输出：1200（保留到百位，ndigits=-2）
  

1.7. sum()

• 函数定义：sum(iterable, /, start=0)

• 功能说明：从 start 开始，自左向右对 iterable 的项求和并返回总计值。iterable 项通常为数字，start 不允许为字符串。

• 替代方案：

  • 拼接字符串用 ''.join(sequence)（比 sum() 更快）。
  • 高精度浮点求和用 math.fsum()。
  • 拼接可迭代对象用 itertools.chain()。

• 版本变更：

  • Python 3.8：start 形参支持关键字参数形式（如 sum([1,2,3], start=10)）。
  • Python 3.12：浮点数求和切换为更高精度、更好适应性的算法（多数构建版本）。

• 使用示例：

  print(sum([1, 2, 3]))          # 输出：6（默认 start=0）
  print(sum((1, 2, 3), start=10))# 输出：16（start=10，10+1+2+3=16）
  print(sum([0.1, 0.2, 0.3]))    # 输出：0.6（浮点数求和，Python 3.12+ 精度更优）
  

2. 序列/集合/映射操作

对容器（列表、集合、字典等）进行长度计算（len()）、排序（sorted()）、过滤（filter()）、映射（map()）、打包（zip()）等操作。

2.1. len()

• 函数定义：len(object, /)

• 功能说明：返回对象的长度（元素个数）。支持的对象包括：

  • 序列：字符串、bytes、tuple、list、range 等；
  • 集合：dictionary、set、frozenset 等。

• 注意事项：若对象长度大于 sys.maxsize（系统最大整数），会引发 OverflowError。

• 使用示例：

  print(len('hello'))          # 输出：5（字符串长度）
  print(len([1, 2, 3, 4]))     # 输出：4（列表长度）
  print(len({'name': 'Alice', 'age': 20}))  # 输出：2（字典键值对数量）
  print(len(range(100)))       # 输出：100（range序列长度）
  

2.2. sorted()

• 函数定义：sorted(iterable, /, *, key=None, reverse=False)

• 功能说明：根据 iterable 中的项，返回一个新的已排序列表（不修改原 iterable）。

  • 可选关键字参数：
    1. key：指定带单个参数的函数，用于从每个元素中提取“排序键”（如 key=str.lower 忽略大小写排序），默认 None（直接比较元素）；
    2. reverse：布尔值，若为 True，则按反向顺序排序，默认 False。

• 核心特性：sorted() 是稳定排序（比较结果相等的元素，相对顺序保持不变），支持多重排序（如先按部门排序，再按薪资排序）。

• 补充说明：若需使用老式比较函数（cmp 函数），可通过 functools.cmp_to_key() 转换为 key 函数。

• 使用示例：

  # 示例1：基础排序
  print(sorted([3, 1, 2]))  # 输出：[1, 2, 3]
  
  # 示例2：按key排序（按字符串长度）
  print(sorted(['apple', 'banana', 'cherry', 'date'], key=len))  # 输出：['date', 'apple', 'banana', 'cherry']
  
  # 示例3：反向排序
  print(sorted([5, 2, 9, 1], reverse=True))  # 输出：[9, 5, 2, 1]
  
  # 示例4：稳定排序（先按年龄排序，再按姓名排序）
  people = [('Alice', 25), ('Bob', 20), ('Charlie', 25), ('David', 20)]
  # 先按年龄排序（稳定）
  sorted_by_age = sorted(people, key=lambda x: x[1])
  # 再按姓名排序（年龄相同的人，姓名顺序保持稳定）
  sorted_by_age_name = sorted(sorted_by_age, key=lambda x: x[0])
  print(sorted_by_age_name)  # 输出：[('Alice', 25), ('Bob', 20), ('Charlie', 25), ('David', 20)]
  

2.3. reversed()

• 函数定义：reversed(object, /)

• 功能说明：返回一个反向迭代器，对 object 进行反向遍历。

  • object 需满足以下任一条件：
    1. 支持“反向迭代协议”（实现 __reversed__() 方法）；
    2. 支持“序列协议”（实现 __len__() 和 __getitem__() 方法，__getitem__() 需接受从 0 开始的整数参数）。

• 使用示例：

  # 反向列表
  print(list(reversed([1, 2, 3, 4])))  # 输出：[4, 3, 2, 1]
  
  # 反向字符串
  print(list(reversed('hello')))       # 输出：['o', 'l', 'l', 'e', 'h']
  
  # 反向元组
  print(tuple(reversed((10, 20, 30)))) # 输出：(30, 20, 10)
  

2.4. filter()

• 函数定义：filter(function, iterable, /)

• 功能说明：返回一个迭代器，包含 iterable 中使 function 返回真值的元素。

  • 若 function 为 None：使用“标识函数”，即移除 iterable 中所有假值（如 0、''、None、False）。
  • 等价于生成器表达式：(item for item in iterable if function(item))（function 非 None 时），或 (item for item in iterable if item)（function 为 None 时）。

• 补充说明：若需保留 function 返回假值的元素，可使用 itertools.filterfalse()。

• 使用示例：

  # 示例1：过滤偶数（function为自定义函数）
  def is_odd(n):
      return n % 2 == 1
  print(list(filter(is_odd, [1, 2, 3, 4, 5])))  # 输出：[1, 3, 5]
  
  # 示例2：移除假值（function为None）
  print(list(filter(None, [0, 1, '', 'hello', None, True, False])))  # 输出：[1, 'hello', True]
  

2.5. map()

• 函数定义：map(function, iterable, *iterables)

• 功能说明：返回一个迭代器，将 function 应用于 iterable 的每一项并产生结果。

  • 若传入多个 iterables（如 map(f, a, b)）：function 需接受对应数量的参数，且会并行从每个 iterable 取元素；迭代会在最短的 iterable 耗尽时停止。

• 补充说明：若 function 的输入已为参数元组（如 [(1,2), (3,4)]），可使用 itertools.starmap() 替代。

• 使用示例：

  # 示例1：单可迭代对象（将列表元素转为字符串）
  print(list(map(str, [1, 2, 3])))  # 输出：['1', '2', '3']
  
  # 示例2：多可迭代对象（计算两列表对应元素之和，按最短列表停止）
  def add(a, b):
      return a + b
  print(list(map(add, [1, 2, 3], [4, 5])))  # 输出：[5, 7]（第三个元素因短列表耗尽被忽略）
  

2.6. enumerate()

• 函数定义：enumerate(iterable, start=0)

• 功能说明：返回一个枚举对象。iterable 需为序列、迭代器或支持迭代的对象；枚举对象的 __next__() 方法会返回元组 (计数值, 迭代值)，计数值从 start（默认 0）开始递增。

• 使用示例（文档示例）：

  seasons = ['Spring', 'Summer', 'Fall', 'Winter']
  # 默认 start=0
  print(list(enumerate(seasons)))  # 输出：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
  # 自定义 start=1
  print(list(enumerate(seasons, start=1)))  # 输出：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  
  # 等价实现（帮助理解）
  def enumerate(iterable, start=0):
      n = start
      for elem in iterable:
          yield n, elem
          n += 1
  

2.7. zip()

• 函数定义：zip(*iterables, strict=False)

• 功能说明：返回一个元组迭代器，并行迭代多个 iterables，第 i 个元组包含每个 iterable 的第 i 个元素（类似“矩阵转置”）。

  • 迭代停止规则：默认情况下，当最短的 iterable 耗尽时，迭代停止，较长 iterable 的剩余元素被忽略；
  • strict 参数（Python 3.10+）：若为 True，当 iterables 长度不同时，会引发 ValueError（推荐在确认 iterables 等长时使用，避免隐式错误）；
  • 若需填充短 iterable 至最长长度，可使用 itertools.zip_longest()。

• 使用示例（含文档示例）：

  # 示例1：基础并行迭代（按最短iterable停止）
  numbers = [1, 2, 3]
  fruits = ['apple', 'banana']
  print(list(zip(numbers, fruits)))  # 输出：[(1, 'apple'), (2, 'banana')]（3被忽略）
  
  # 示例2：strict=True（长度不同时报错）
  try:
      for item in zip(numbers, fruits, strict=True):
          print(item)
  except ValueError as e:
      print(e)  # 输出：zip() argument 1 is longer than argument 2
  
  # 示例3：拆解列表（文档示例）
  x = [1, 2, 3]
  y = [4, 5, 6]
  zipped = zip(x, y)
  x2, y2 = zip(*zipped)  # 拆解为原列表结构
  print(x == list(x2) and y == list(y2))  # 输出：True
  
  # 示例4：单iterable（返回一元组迭代器）
  print(list(zip([1, 2, 3])))  # 输出：[(1,), (2,), (3,)]
  
  # 示例5：空iterable（返回空迭代器）
  print(list(zip()))  # 输出：[]
  

3. 迭代与循环辅助

辅助迭代过程，如创建迭代器（iter()、aiter()）、获取下一个迭代元素（next()、anext()）、判断迭代元素真值（all()、any()）。

3.1. iter()

• 函数定义：

  iter(iterable, /)

  iter(callable, sentinel, /)

• 功能说明：返回一个迭代器对象，行为根据参数数量不同而差异：

  1. 单参数（iterable）：
     • iterable 需支持“可迭代协议”（实现 __iter__() 方法）或“序列协议”（实现 __getitem__() 方法，参数为从 0 开始的整数）；否则引发 TypeError。
  2. 双参数（callable, sentinel）：
     • callable 需为可调用对象（无参数）；每次调用迭代器的 __next__() 时，会调用 callable，若返回值等于 sentinel，则引发 StopIteration，否则返回该值。

• 使用示例（含文档示例）：

  # 示例1：单参数（迭代列表）
  it = iter([1, 2, 3])
  print(next(it))  # 输出：1
  print(next(it))  # 输出：2
  
  # 示例2：双参数（读取固定宽度文件块，文档示例）
  from functools import partial
  with open('mydata.db', 'rb') as f:
      # 每次读取64字节，直到返回空字节串（sentinel=b''）
      for block in iter(partial(f.read, 64), b''):
          print(f"读取块长度：{len(block)}")  # 输出每次读取的块长度，直至文件结束
  

3.2. aiter()

• 函数定义：aiter(async_iterable, /)

• 功能说明：返回异步可迭代对象（asynchronous iterable） 对应的异步迭代器（asynchronous iterator），等价于调用 async_iterable.__aiter__()。

  • 与同步迭代的 iter() 不同：aiter() 仅支持单参数形式，无两参数版本（无法指定 sentinel）。

• 版本变更：Python 3.10 新增。

• 使用示例（需在异步函数中执行）：

  import asyncio
  
  # 定义一个异步可迭代对象（实现__aiter__和__anext__）
  class AsyncIterable:
      def __init__(self, max_num):
          self.max_num = max_num
          self.current = 0
  
      # 返回自身作为异步迭代器（实现__aiter__）
      def __aiter__(self):
          return self
  
      # 异步获取下一个元素（实现__anext__）
      async def __anext__(self):
          if self.current >= self.max_num:
              raise StopAsyncIteration  # 迭代结束标志
          await asyncio.sleep(0.1)  # 模拟异步操作（如IO等待）
          self.current += 1
          return self.current
  
  # 异步函数中使用aiter()
  async def main():
      async_iter = AsyncIterable(3)
      # 获取异步迭代器（等价于async_iter.__aiter__()）
      async_iterator = aiter(async_iter)
      
      # 异步遍历迭代器
      async for num in async_iterator:
          print(num)  # 输出：1 → 2 → 3（间隔0.1秒）
  
  # 运行异步函数
  asyncio.run(main())
  

3.3. next()

• 函数定义：

  next(iterator, /)

  next(iterator, default, /)

• 功能说明：通过调用迭代器的 __next__() 方法，获取迭代器的下一个元素。

  • 若迭代器耗尽：若提供 default，则返回 default；否则引发 StopIteration 异常。

• 使用示例：

  # 创建迭代器
  it = iter([1, 2, 3])
  
  # 无default：获取元素，耗尽后报错
  print(next(it))  # 输出：1
  print(next(it))  # 输出：2
  print(next(it))  # 输出：3
  # print(next(it))  # 未传default，迭代耗尽，引发 StopIteration
  
  # 有default：迭代耗尽后返回default
  it2 = iter([1, 2])
  print(next(it2, 'end'))  # 输出：1
  print(next(it2, 'end'))  # 输出：2
  print(next(it2, 'end'))  # 输出：'end'（迭代耗尽，返回default）
  

3.4. anext()

• 函数定义：

  awaitable anext(async_iterator, /)

  awaitable anext(async_iterator, default, /)

• 功能说明：异步获取异步迭代器的下一个元素，是同步函数 next() 的异步版本，调用时需加 await：

  1. 无 default 参数：调用 async_iterator.__anext__()，等待获取下一个值；若迭代耗尽，引发 StopAsyncIteration。
  2. 有 default 参数：迭代耗尽时返回 default，不引发异常。

• 版本变更：Python 3.10 新增。

• 使用示例（需在异步函数中执行）：

  import asyncio
  
  # 复用4.1中的AsyncIterable类（异步可迭代对象）
  class AsyncIterable:
      def __init__(self, max_num):
          self.max_num = max_num
          self.current = 0
  
      def __aiter__(self):
          return self
  
      async def __anext__(self):
          if self.current >= self.max_num:
              raise StopAsyncIteration
          await asyncio.sleep(0.1)
          self.current += 1
          return self.current
  
  # 异步函数中使用anext()
  async def main():
      async_iter = AsyncIterable(2)
      async_iterator = aiter(async_iter)
  
      # 1. 无default：获取元素，耗尽后引发异常
      print(await anext(async_iterator))  # 输出：1
      print(await anext(async_iterator))  # 输出：2
      # print(await anext(async_iterator))  # 迭代耗尽，引发 StopAsyncIteration
  
      # 2. 有default：耗尽后返回default
      async_iterator2 = aiter(AsyncIterable(1))
      print(await anext(async_iterator2))        # 输出：1
      print(await anext(async_iterator2, 'end')) # 输出：'end'（迭代耗尽，无异常）
  
  asyncio.run(main())
  

3.5. all()

• 函数定义：all(iterable, /)

• 功能说明：判断可迭代对象 iterable 的所有元素是否均为真值（或 iterable 为空），返回 True 或 False。

  • 真值定义：满足 Python 标准真值测试（如非 0、非空字符串/列表、非 None、非 False 等）；

  • 等价实现（文档提供）：

    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True
    

• 使用示例：

  # 所有元素为真值 → True
  print(all([1, 'hello', True, [2,3]]))  # 输出：True
  
  # 存在假值（0）→ False
  print(all([1, 0, True]))  # 输出：False
  
  # 空可迭代对象 → True（特殊规则）
  print(all([]))  # 输出：True
  print(all(()))  # 输出：True
  

3.6. any()

• 函数定义：any(iterable, /)

• 功能说明：判断可迭代对象 iterable 的任一元素是否为真值，返回 True 或 False；若 iterable 为空，返回 False。

  • 等价实现（文档提供）：

    def any(iterable):
        for element in iterable:
            if element:
                return True
        return False
    

• 使用示例：

  # 存在真值（'hello'）→ True
  print(any([0, '', 'hello', None]))  # 输出：True
  
  # 所有元素为假值 → False
  print(any([0, '', None, False]))  # 输出：False
  
  # 空可迭代对象 → False（特殊规则）
  print(any([]))  # 输出：False
  print(any(()))  # 输出：False
  

4. 代码执行与调试

执行动态代码（eval()、exec()）、编译代码（compile()）、设置调试断点（breakpoint()）、导入模块（__import__()）。

4.1. eval()

• 函数定义：eval(source, /, globals=None, locals=None)

• 功能说明：动态执行 source 中的 Python 表达式，并返回表达式的求值结果，是动态计算表达式的工具。

  • 参数解释：
    1. source：需执行的内容，可为字符串或 compile() 生成的代码对象（若为代码对象且编译模式为 'exec'，eval() 返回 None）；
    2. globals：全局命名空间（字典类型，默认 None）：
       • 若为 None，使用调用 eval() 时的全局命名空间；
       • 若存在且不含 __builtins__ 键，会自动插入 __builtins__ 指向内置模块 builtins 的字典（可自定义 __builtins__ 控制可用内置对象）；
    3. locals：局部命名空间（任意映射类型，默认 None）：
       • 若为 None，默认与 globals 相同；
       • 若与 globals 不同，代码执行时类似嵌套在类定义中（顶层变量视为类变量，函数/类无法访问）。
  • 安全警告：此函数可执行任意代码，若 source 来自用户输入，可能导致安全漏洞（推荐用 ast.literal_eval() 执行仅含文字的表达式）。
  • 备注：source 为字符串时，前后的空格和制表符会被自动剔除。

• 版本变更：

  • Python 3.13：globals 和 locals 支持作为关键字参数传入；默认 locals 命名空间语义与 locals() 函数描述一致。

• 审计事件：引发 exec 审计事件，附带参数为编译后的代码对象（代码编译事件也可能触发）。

• 使用示例（文档示例）：

  # 示例1：基础表达式求值
  x = 1
  print(eval('x + 1'))  # 输出：2（使用当前作用域的x）
  
  # 示例2：指定globals（限制可用变量和内置对象）
  globals_dict = {'x': 10, '__builtins__': {'print': print, 'int': int}}  # 仅开放print和int
  print(eval('x * 3', globals=globals_dict))  # 输出：30（使用globals_dict中的x）
  # eval('import os', globals=globals_dict)  # 报错：__builtins__中无import，无法导入模块
  
  # 示例3：指定globals和locals（局部变量覆盖全局）
  globals_dict = {'a': 100}
  locals_dict = {'a': 200}
  print(eval('a', globals=globals_dict, locals=locals_dict))  # 输出：200（优先使用locals）
  
  # 示例4：执行compile()生成的代码对象（mode='eval'）
  code = compile('2 ** 8', filename='<eval>', mode='eval')
  print(eval(code))  # 输出：256
  

4.2. exec()

• 函数定义：exec(source, /, globals=None, locals=None, *, closure=None)

• 功能说明：动态执行 source 中的 Python 代码（语句块、函数定义等），无返回值（返回 None），是动态执行多语句的工具。

  • 参数解释：
    1. source：需执行的内容，可为字符串或 compile() 生成的代码对象（字符串会被解析为文件输入格式的语句）；
    2. globals/locals：与 eval() 规则一致（globals 为 None 时使用当前全局命名空间，locals 为 None 时默认与 globals 相同）；
    3. closure（Python 3.11+）：闭包元组（单元变量的元组），仅当 source 是含自由变量的代码对象时有效，元组长度需与代码对象的 co_freevars 属性长度完全匹配。
  • 安全警告：此函数可执行任意代码，若 source 来自用户输入，可能导致安全漏洞。
  • 备注：
    1. 执行代码中不可使用 nonlocal、yield、return（除非在函数定义内部）；
    2. 若 globals 和 locals 不同，代码执行类似嵌套在类定义中（顶层变量无法被内部函数访问）。

• 版本变更：

  • Python 3.11：新增 closure 参数；
  • Python 3.13：globals 和 locals 支持作为关键字参数传入；默认 locals 命名空间语义与 locals() 函数描述一致。

• 审计事件：引发 exec 审计事件，附带参数为编译后的代码对象（代码编译事件也可能触发）。

• 使用示例：

  # 示例1：执行字符串形式的多语句
  exec("""
  def multiply(a, b):
      return a * b
  
  result = multiply(4, 5)
  print(f"4 * 5 = {result}")  # 输出：4 * 5 = 20
  """)
  
  # 示例2：指定globals（隔离执行环境）
  globals_env = {'__builtins__': {'print': print}}  # 仅开放print
  exec("""
  message = "Hello from exec!"
  print(message)  # 输出：Hello from exec!
  # print(os.getcwd())  # 报错：globals_env中无os模块
  """, globals=globals_env)
  
  # 示例3：执行compile()生成的代码对象（mode='exec'）
  code = compile("""
  numbers = [1, 2, 3]
  squared = [x**2 for x in numbers]
  print(squared)  # 输出：[1, 4, 9]
  """, filename='<exec>', mode='exec')
  exec(code)
  
  # 示例4：使用closure参数（Python 3.11+，含自由变量的代码）
  # 定义含自由变量的代码对象
  code_closure = compile("""
  def inner():
      return free_var  # free_var是自由变量，需通过closure传入
  """, filename='<closure>', mode='exec')
  # 准备闭包元组（单元变量，需用ctypes或手动构造，此处简化示例）
  import ctypes
  class Cell:
      def __init__(self, value):
          self.value = value
  free_var_cell = Cell(100)
  closure = (ctypes.py_object(free_var_cell),)
  # 执行代码并调用inner()
  exec(code_closure, closure=closure)
  print(inner())  # 输出：100（自由变量值来自closure）
  

4.3. compile()

• 函数定义：compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

• 功能说明：将 source 编译为代码对象（code object） 或 AST 对象，编译后的对象可被 exec() 或 eval() 执行。

  • 参数解释：
    1. source：需编译的内容，可为字符串、字节字符串或 AST 对象（AST 对象需结合 ast 模块使用）；
    2. filename：代码来源的文件名（若代码非来自文件，常用 <string> 标识）；
    3. mode：编译模式，必选且仅支持三种值：
       • 'exec'：编译语句序列（如多行代码、函数定义）；
       • 'eval'：编译单个表达式（结果可被 eval() 获取）；
       • 'single'：编译单个交互式语句（执行后若结果非 None 会打印）；
    4. flags：控制编译器选项和 future 特性的比特位（可通过 ast 模块的 PyCF_* 常量或 __future__ 模块的 compiler_flag 获取）；
    5. dont_inherit：布尔值，若为 True，仅使用 flags 指定的选项，忽略外围代码的编译器选项；若为 False，则叠加外围选项；
    6. optimize：优化级别（0：无优化，__debug__ 为 True；1：删除断言，__debug__ 为 False；2：删除断言和文档字符串；默认 -1：跟随解释器 -O 选项）。
  • 异常情况：源码不合法引发 SyntaxError；源码含 null 字节引发 ValueError。
  • 备注：
    1. 编译 'single' 或 'eval' 模式的多行字符串时，输入需以至少一个换行符结尾（便于 code 模块检测语句完整性）；
    2. 编译复杂字符串为 AST 对象时，可能因 Python AST 编译器栈深度限制崩溃。

• 版本变更：

  • Python 3.2：支持 Windows 和 Mac 换行符；'exec' 模式输入无需以换行符结尾；新增 optimize 参数；
  • Python 3.5：source 含 null 字节时，原引发 TypeError，现改为 ValueError；
  • Python 3.8：ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 可传入 flags，支持顶层 await、async for、async with。

• 审计事件：引发 compile 审计事件，附带参数 source 和 filename（隐式编译也会触发）。

• 使用示例：

  import ast
  
  # 示例1：mode='exec'（编译语句序列，用exec()执行）
  code_exec = compile("""
  def add(a, b):
      return a + b
  result = add(2, 3)
  print(result)
  """, filename='<exec_mode>', mode='exec')
  exec(code_exec)  # 执行编译后的代码，输出：5
  
  # 示例2：mode='eval'（编译单个表达式，用eval()执行）
  code_eval = compile("10 * 2 + 5", filename='<eval_mode>', mode='eval')
  print(eval(code_eval))  # 执行表达式，输出：25
  
  # 示例3：mode='single'（编译单个交互式语句）
  code_single = compile("x = 10; print(x + 5)", filename='<single_mode>', mode='single')
  exec(code_single)  # 执行交互式语句，输出：15
  
  # 示例4：编译AST对象（需结合ast模块）
  ast_tree = ast.parse("print('Hello from AST!')", mode='exec')
  code_ast = compile(ast_tree, filename='<ast_mode>', mode='exec')
  exec(code_ast)  # 输出：Hello from AST!
  

4.4. breakpoint()

• 函数定义：breakpoint(*args, **kws)

• 功能说明：在调用位置进入Python调试器，本质是调用 sys.breakpointhook() 并传递 args 和 kws 参数：

  • 默认行为：sys.breakpointhook() 无参数调用 pdb.set_trace()（进入 pdb 调试器）；
  • 自定义调试器：可通过修改 sys.breakpointhook() 函数，或设置 PYTHONBREAKPOINT 环境变量（如 PYTHONBREAKPOINT=mydebugger.set_trace），指定自定义调试器；
  • 异常情况：若 sys.breakpointhook() 不可用，引发 RuntimeError。

• 版本变更：Python 3.7 新增。

• 审计事件：引发 builtins.breakpoint 审计事件，附带参数 breakpointhook（当前使用的断点钩子函数）。

• 使用示例：

  # 示例：在代码中插入断点，运行时进入pdb调试器
  def calculate(a, b):
      result = a + b
      breakpoint()  # 此处插入断点，执行到此时进入调试器
      print(f"Result: {result}")
      return result
  
  # 运行函数，执行到breakpoint()时会暂停并进入pdb交互界面
  calculate(3, 5)
  
  # 调试器交互示例（运行后会出现类似如下提示）：
  # > <stdin>(4)calculate()
  # (Pdb) print(a)  # 可查看变量a的值（输出3）
  # (Pdb) print(result)  # 查看result的值（输出8）
  # (Pdb) c  # 输入c继续执行，打印Result: 8
  

4.5. __import__()

• 函数定义：__import__(name, globals=None, locals=None, fromlist=(), level=0)

• 功能说明：动态导入模块，是Python中 import 语句的底层实现；日常编程中不推荐直接使用，建议用 importlib.import_module()（更直观、功能更完善）。

  • 核心参数解释：
    1. name：要导入的模块名称（字符串，如 'math'、'os.path'）；
    2. globals/locals：用于确定导入的包上下文（locals 未被标准实现使用，globals 用于确定当前包）；
    3. fromlist：指定从模块中导入的子模块或对象名称（非空时返回 name 指定的模块，否则返回顶层模块）；
    4. level：指定导入类型（0：仅绝对导入，默认；>0：相对导入，数值表示相对于当前模块的父目录层数）。
  • 关键行为：
    • 若 name 为包.模块形式（如 'a.b'），默认返回顶层包（a），除非 fromlist 非空（此时返回 a.b）；
    • 若 globals 不含 __builtins__ 键，会自动插入 __builtins__ 指向内置模块 builtins。

• 版本变更：

  • Python 3.3：level 不再支持负数，默认值改为 0；
  • Python 3.9：使用 -E 或 -I 命令行参数时，忽略环境变量 PYTHONCASEOK。

• 备注：可通过修改 builtins.__import__ 替换默认导入逻辑，但强烈不推荐（建议用导入钩子，见 PEP 302）。

• 使用示例（文档示例）：

  # 示例1：等价于import spam（导入顶层模块）
  spam = __import__('spam', globals(), locals(), [], 0)
  # 此时spam是顶层模块spam
  
  # 示例2：等价于import spam.ham（导入子模块，但返回顶层模块spam）
  spam = __import__('spam.ham', globals(), locals(), [], 0)
  # 此时spam是顶层模块spam，子模块需通过spam.ham访问
  print(spam.ham)  # 访问子模块ham
  
  # 示例3：等价于from spam.ham import eggs, sausage as saus（返回子模块spam.ham）
  _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
  eggs = _temp.eggs  # 提取对象eggs
  saus = _temp.sausage  # 提取对象sausage（重命名）
  
  # 示例4：相对导入（level=1，相对于当前模块的父目录）
  # 假设当前模块在"a.b"包下，导入"a.c"模块（相对路径：../c）
  c_module = __import__('c', globals(), locals(), [], level=1)
  
  # 示例5：推荐用法：用importlib.import_module()替代__import__()
  import importlib
  # 导入spam模块
  spam_module = importlib.import_module('spam')
  # 导入spam.ham模块
  ham_module = importlib.import_module('spam.ham')
  # 从spam.ham导入eggs对象
  eggs = importlib.import_module('spam.ham').eggs
  

5. 输入输出

处理用户输入（input()）、控制台输出（print()）、获取帮助信息（help()）。

5.1. input()

• 函数定义：

  input()

  input(prompt, /)

• 功能说明：从标准输入（通常是键盘）读取一行输入，转换为字符串（自动去除末尾的换行符）并返回，是获取用户输入的基础函数。

  • 参数 prompt：可选字符串，用于在读取输入前打印提示信息（末尾无换行符）；
  • 异常情况：若读取到EOF（如Linux下按 Ctrl+D，Windows下按 Ctrl+Z），引发 EOFError；
  • 扩展功能：若加载 readline 模块，input() 支持复杂的行编辑（如光标移动、历史记录）。

• 审计事件：

  • 读取输入前：引发 builtins.input 审计事件，附带参数 prompt；
  • 成功读取输入后：引发 builtins.input/result 审计事件，附带参数为读取的结果。

• 使用示例（文档示例）：

  # 示例1：无prompt（直接读取输入）
  print("请输入内容：")
  s1 = input()
  print(f"你输入的是：{s1}")
  # 运行流程：
  # 1. 打印"请输入内容："
  # 2. 等待用户输入（如输入"hello"并按回车）
  # 3. 输出"你输入的是：hello"
  
  # 示例2：带prompt（打印提示后读取输入）
  s2 = input('请输入你的名字：')
  print(f"欢迎你，{s2}！")
  # 运行流程：
  # 1. 打印"请输入你的名字："（无换行符）
  # 2. 等待用户输入（如输入"Alice"并按回车）
  # 3. 输出"欢迎你，Alice！"
  
  # 示例3：读取输入并转换类型（input()返回字符串，需手动转换）
  age_str = input('请输入你的年龄：')
  age = int(age_str)  # 转换为整数
  print(f"你明年将满 {age + 1} 岁")
  # 运行流程：
  # 1. 输入"25" → 转换为int 25
  # 2. 输出"你明年将满 26 岁"
  
  # 示例4：处理EOFError（捕获EOF异常）
  try:
      s = input('请输入内容（按Ctrl+D结束）：')
  except EOFError:
      print("\n已检测到EOF，程序结束")
  else:
      print(f"你输入的是：{s}")
  

5.2. print()

• 函数定义：print(*objects, sep=' ', end='\n', file=None, flush=False)

• 功能说明：将 objects 中的内容打印到指定的文本流（默认是控制台 sys.stdout），支持自定义分隔符、结束符和输出目标，无返回值。

  • 参数解释：
    1. *objects：可变参数，需打印的对象（可多个），会自动转换为字符串（等价于 str(object)）；
    2. sep：可选关键字参数，用于分隔多个 objects 的字符串，默认是空格 ' '；
    3. end：可选关键字参数，打印结束后追加的字符串，默认是换行符 '\n'（控制是否换行）；
    4. file：可选关键字参数，指定输出流（需是具有 write(string) 方法的对象，如文件对象），默认是 sys.stdout（控制台）；
    5. flush：可选关键字参数，布尔值，若为 True，强制刷新输出流（忽略缓冲），默认是 False（依赖流的缓冲策略）。
  • 关键特性：
    • 多个对象会用 sep 连接，最终字符串末尾追加 end；
    • 二进制模式的文件对象不支持 print()（需用 file.write() 直接写入 bytes）。

• 版本变更：Python 3.3 新增 flush 关键字参数。

• 使用示例：

  # 示例1：基础用法（打印单个/多个对象，默认 sep 和 end）
  print("Hello, Python!")  # 单个对象，默认 end='\n'（换行）
  # 输出：Hello, Python!（换行）
  
  print(10, 20, 30)        # 多个对象，默认 sep=' '（空格分隔）
  # 输出：10 20 30（换行）
  
  # 示例2：自定义 sep（分隔符）
  print(1, 2, 3, sep='-')  # 用 '-' 分隔多个对象
  # 输出：1-2-3（换行）
  
  print('a', 'b', 'c', sep='')  # 无分隔符
  # 输出：abc（换行）
  
  # 示例3：自定义 end（结束符，控制是否换行）
  print("First line", end=' ')  # 结束符为空格（不换行）
  print("Second line")          # 后续打印接在同一行
  # 输出：First line Second line（换行）
  
  print("No newline", end='')   # 无结束符（不换行）
  print(" → Continued")
  # 输出：No newline → Continued（换行）
  
  # 示例4：输出到文件（指定 file 参数）
  with open('output.txt', 'w', encoding='utf-8') as f:
      print("This line goes to file.", file=f)  # 打印到文件
      print("Another line.", sep='|', file=f)   # 带自定义 sep
  
  # 示例5：强制刷新缓冲（flush=True）
  import time
  print("Loading...", end='', flush=True)  # 强制刷新，立即显示
  time.sleep(2)  # 模拟耗时操作（若不 flush，"Loading..." 可能延迟显示）
  print(" Done!")
  # 输出：Loading... Done!（"Loading..." 会立即显示，2秒后追加 " Done!"）
  
  # 示例6：打印空对象（无输出，仅追加 end）
  print()  # 仅打印 end（默认 '\n'，即空行）
  print(end='---')  # 无 objects，仅打印 end='---'
  # 输出：
  # （空行）
  # ---
  

5.3. help()

• 函数定义：

  help()

  help(request)

• 功能说明：启动Python的内置帮助系统，主要用于在交互式环境中查看对象的文档信息（模块、函数、类、方法、关键字等）。

  • 无参数：在交互式控制台启动交互式帮助系统（可输入对象名查看帮助，输入 quit 退出）；
  • 有参数 request：
    1. 若 request 为字符串：搜索该字符串对应的模块、函数、类等，并在控制台打印帮助信息；
    2. 若 request 为任意对象：生成该对象的帮助页（包含对象的文档字符串、属性、方法等）。
  • 特殊说明：若帮助信息中方法的形参列表含斜杠（/），表示斜杠前的参数为仅限位置参数（无法用关键字传递）。

• 版本变更：Python 3.4 中，pydoc 和 inspect 模块的更新使可调用对象的签名信息更全面一致。

• 使用示例：

  # 示例1：无参数（交互式帮助系统，需在Python交互式控制台运行）
  # help()  # 运行后进入交互式帮助，提示："help> "，可输入如"print"查看print函数帮助
  
  # 示例2：request为字符串（查看指定对象的帮助）
  # 查看内置函数print的帮助
  help('print')
  # 输出内容包含：print()的函数定义、参数说明、示例等
  
  # 查看模块math的帮助
  import math
  help('math')
  # 输出内容包含：math模块的功能、包含的函数（如sin、cos）等
  
  # 示例3：request为对象（查看对象的帮助）
  # 查看列表对象的帮助
  help([1,2,3])
  # 输出内容包含：list类的方法（如append、sort）、属性等
  
  # 查看自定义函数的帮助（需有文档字符串）
  def add(a, b):
      """计算两个数的和。
      
      参数：
          a: 第一个数
          b: 第二个数
      
      返回：
          a + b 的结果
      """
      return a + b
  help(add)
  # 输出内容包含：add函数的文档字符串、参数列表等
  
  # 示例4：查看关键字的帮助
  help('if')
  # 输出内容包含：if关键字的语法、用法说明等
  

6. 其他工具函数

提供哈希计算（hash()）、对象唯一标识（id()）、命名空间获取（globals()）、可调用性检查（callable()）等通用工具功能。

6.1. hash()

• 函数定义：hash(object, /)

• 功能说明：返回对象的哈希值（整数），用于字典查找时快速比较键的唯一性：

  • 哈希值特性：相同大小的数字变量（即使类型不同，如 1 和 1.0）具有相同的哈希值；
  • 适用对象：仅支持可哈希对象（如整数、字符串、元组、frozenset，不可哈希对象如列表、字典、set 无法调用 hash()）。

• 备注：对于自定义 __hash__() 方法的对象，hash() 会根据宿主机的字长截断返回值。

• 使用示例：

  # 可哈希对象的哈希值
  print(hash(1))          # 输出：1（整数的哈希值通常为自身）
  print(hash(1.0))        # 输出：1（与整数1的哈希值相同）
  print(hash('hello'))    # 输出：-2016767868060910468（字符串的哈希值，因环境而异）
  print(hash((1, 2, 3)))  # 输出：529344067295497451（元组的哈希值，因环境而异）
  print(hash(frozenset([1,2])))  # 输出：-7621889944720856478（frozenset的哈希值，因环境而异）
  
  # 不可哈希对象（调用hash()引发TypeError）
  # print(hash([1,2,3]))  # 引发 TypeError: unhashable type: 'list'
  # print(hash({1:2}))    # 引发 TypeError: unhashable type: 'dict'
  

6.2. id()

• 函数定义：id(object, /)

• 功能说明：返回对象的标识值（整数），该值在对象的生命周期内唯一且恒定：

  • 标识值本质：对象在内存中的地址；
  • 特殊情况：两个生命周期不重叠的对象可能具有相同的 id() 值。

• 审计事件：调用时引发 builtins.id 审计事件，附带参数 id（对象的标识值）。

• 使用示例：

  # 不同对象的id（不同内存地址）
  a = 10
  b = 20
  print(id(a))  # 输出：140708434567248（示例值，因环境而异）
  print(id(b))  # 输出：140708434567568（示例值，与a不同）
  
  # 同一对象的id（相同内存地址）
  c = a
  print(id(c))  # 输出：140708434567248（与a相同，c引用a的对象）
  
  # 短整数缓存（Python对-5~256的整数缓存，相同值指向同一对象）
  d = 256
  e = 256
  print(id(d) == id(e))  # 输出：True（缓存范围内，同一对象）
  
  f = 257
  g = 257
  print(id(f) == id(g))  # 输出：False（超出缓存范围，不同对象）
  

6.3. globals()

• 函数定义：globals()

• 功能说明：返回实现当前模块命名空间的字典。

  • 对于函数内的代码：该字典在函数定义时确定，无论函数在何处调用，始终指向定义函数时的模块命名空间（不随调用位置变化）。

• 使用示例：

  # 模块层级：查看当前模块的全局命名空间
  global_var = 10
  def func():
      local_var = 20
      # 函数内调用globals()：返回模块的全局命名空间，包含global_var
      print('函数内globals()中的global_var:', globals().get('global_var'))  # 输出：10
      # 函数内globals()不包含local_var（本地变量）
      print('函数内globals()中的local_var:', globals().get('local_var'))  # 输出：None
  
  func()
  
  # 模块层级查看globals()
  print('模块层级globals()中的global_var:', globals().get('global_var'))  # 输出：10
  print('模块层级globals()中的func:', globals().get('func'))  # 输出：<function func at 0x...>（函数对象）
  

6.4. locals()

• 函数定义：locals()

• 功能说明：返回一个代表当前局部符号表的映射对象（键为变量名，值为变量的当前绑定），行为因作用域类型而异：

  • 模块/类作用域 & exec()/eval() 单命名空间：返回与 globals() 相同的映射对象；
  • exec()/eval() 多命名空间：返回传入的局部命名空间映射；
  • 优化作用域（函数、生成器、协程）：
    1. 每次调用返回新的字典（包含当前局部变量和非局部单元引用）；
    2. 通过映射修改变量不会写回原局部变量/非局部单元，原变量修改也不影响已返回的字典；
  • 非优化作用域（如模块顶层、未优化的函数）：每次调用返回同一个映射对象，修改映射会同步到原局部变量，反之亦然。

• 版本变更：

  • Python 3.12：推导式中 locals() 的行为符合 PEP 709，包含推导式的迭代变量；
  • Python 3.13：明确映射对象的语义，优化作用域的行为正式定义。

• 使用示例：

  # 示例1：模块顶层作用域（非优化，与 globals() 一致）
  module_var = 100
  local_map = locals()
  print(local_map['module_var'])  # 输出：100（查看局部变量）
  
  # 修改映射，同步到原变量
  local_map['module_var'] = 200
  print(module_var)  # 输出：200（原变量被修改）
  
  # 新增变量（通过映射或直接赋值，双向同步）
  local_map['new_var'] = 'test'
  print(new_var)  # 输出：'test'（直接访问新增变量）
  print(local_map['new_var'])  # 输出：'test'（映射同步新增变量）
  
  # 示例2：函数作用域（优化作用域，返回新字典，修改不同步）
  def test_func():
      x = 10
      y = 20
      # 第一次调用locals()，获取当前变量
      first_locals = locals()
      print(first_locals)  # 输出：{'x': 10, 'y': 20}
      
      # 修改映射，不影响原变量
      first_locals['x'] = 100
      print(x)  # 输出：10（原变量 x 未变）
      
      # 修改原变量，不影响已返回的映射
      y = 200
      print(first_locals['y'])  # 输出：20（映射中的 y 未变）
      
      # 第二次调用locals()，返回新字典（包含最新变量）
      second_locals = locals()
      print(second_locals)  # 输出：{'x': 10, 'y': 200, 'first_locals': {...}}
      print(first_locals is second_locals)  # 输出：False（两个不同的字典）
  
  test_func()
  
  # 示例3：推导式中的locals()（Python 3.12+，包含迭代变量）
  numbers = [1, 2, 3]
  # 列表推导式中调用locals()，包含迭代变量 i
  result = [locals()['i'] * 2 for i in numbers]
  print(result)  # 输出：[2, 4, 6]
  
  # 示例4：类作用域（返回类命名空间，将传给元类）
  class TestClass:
      class_var = 50
      # 类定义中调用locals()，返回类的属性映射
      class_locals = locals()
      print(class_locals)  # 输出：{'__module__': '__main__', 'class_var': 50, ...}
  
  print(TestClass.class_locals['class_var'])  # 输出：50
  

6.5. ascii()

• 函数定义：ascii(object, /)

• 功能说明：返回对象的可打印字符串表示，与 repr() 类似，但会对非 ASCII 字符使用 \x、\u 或 \U 进行转义（生成与 Python 2 repr() 类似的结果）。

  • 核心差异：repr() 保留非 ASCII 字符（如 '€'），ascii() 转义非 ASCII 字符（如 '\u20ac'）。

• 使用示例：

  # 包含ASCII字符 → 与repr()结果一致
  print(ascii('hello world!'))  # 输出："'hello world!'"
  print(repr('hello world!'))   # 输出："'hello world!'"
  
  # 包含非ASCII字符 → ascii()转义，repr()保留
  print(ascii('欧元符号：€'))  # 输出："'欧元符号：\\u20ac'"（€被转义为\u20ac）
  print(repr('欧元符号：€'))   # 输出："'欧元符号：€'"（€保留）
  
  # 包含特殊字符 → 均转义（如换行符\n）
  print(ascii('line1\nline2'))  # 输出："'line1\\nline2'"
  print(repr('line1\nline2'))   # 输出："'line1\\nline2'"
  

6.6. repr()

• 函数定义：repr(object, /)

• 功能说明：返回对象的可打印字符串表示，核心目标是“尽可能让字符串能通过 eval() 还原为原对象”（若无法还原，则返回包含类型名称和地址的尖括号字符串）。

  • 自定义控制：类可通过定义 __repr__() 方法，自定义其实例的 repr() 输出；
  • 异常情况：若 sys.displayhook() 不可访问，引发 RuntimeError。

• 使用示例（含文档示例）：

  # 1. 内置类型：返回可eval()的字符串
  print(repr(123))        # 输出：'123'（eval('123') → 123）
  print(repr('hello'))    # 输出："'hello'"（eval("'hello'") → 'hello'）
  print(repr([1,2,3]))    # 输出：'[1, 2, 3]'（eval('[1,2,3]') → [1,2,3]）
  
  # 2. 自定义类：通过__repr__()控制输出（文档示例）
  class Person:
      def __init__(self, name, age):
          self.name = name
          self.age = age
      
      def __repr__(self):
          return f"Person('{self.name}', {self.age})"  # 自定义repr格式
  
  p = Person('Alice', 25)
  print(repr(p))  # 输出："Person('Alice', 25)"（可通过eval还原实例）
  
  # 3. 无法还原的对象：返回类型+地址信息
  print(repr(lambda x: x+1))  # 输出：'<function <lambda> at 0x...>'（函数对象无法通过eval还原）
  

6.7. callable()

• 函数定义：callable(object, /)

• 功能说明：判断 object 是否为可调用对象，返回 True 或 False。

  • 若返回 True，调用对象仍可能失败；若返回 False，调用对象必定失败。
  • 特殊情况：类是可调用的（调用类返回新实例）；若实例所属的类定义了 __call__() 方法，则该实例是可调用的。

• 版本变更：Python 3.0 中被移除，Python 3.2 重新加入。

• 使用示例：

  # 函数是可调用的
  def func():
      pass
  print(callable(func))  # 输出：True
  
  # 类是可调用的（调用返回实例）
  class MyClass:
      pass
  print(callable(MyClass))  # 输出：True
  
  # 实例无__call__()，不可调用
  obj1 = MyClass()
  print(callable(obj1))  # 输出：False
  
  # 实例有__call__()，可调用
  class CallableObj:
      def __call__(self):
          print("实例被调用")
  obj2 = CallableObj()
  print(callable(obj2))  # 输出：True
  obj2()  # 输出：实例被调用（验证可调用性）
  

6.8. memoryview()

• 函数定义：class memoryview(object)

• 功能说明：创建一个内存视图对象（memoryview），用于访问对象的内存缓冲区（无需复制数据），支持对缓冲区进行切片、索引操作，且可直接修改缓冲区内容（若对象支持）。

  • 适用对象：需支持缓冲区接口（如 bytes、bytearray、array.array 等）；
  • 核心优势：避免数据复制，提高对大型二进制数据的操作效率（如处理大文件、网络数据时）。

• 补充说明：详情可参考“memoryview”官方文档。

• 使用示例：

  # 示例1：访问bytes对象的内存视图（不可修改）
  b = b'hello world'
  mv1 = memoryview(b)
  print(mv1)  # 输出：<memory at 0x...>（内存视图对象）
  print(mv1[0])  # 输出：104（第一个字节的整数值，对应'h'）
  print(mv1[1:5])  # 输出：<memory at 0x...>（切片视图，对应'ello'）
  print(bytes(mv1[1:5]))  # 输出：b'ello'（转换为bytes查看切片内容）
  # mv1[0] = 97  # 引发 TypeError: cannot modify read-only memory（bytes不可修改）
  
  # 示例2：访问bytearray对象的内存视图（可修改）
  ba = bytearray(b'hello')
  mv2 = memoryview(ba)
  mv2[0] = 97  # 修改第一个字节为'a'（97）
  print(ba)  # 输出：bytearray(b'aello')（原bytearray被修改）
  
  # 示例3：高效处理大型数据（无需复制）
  large_ba = bytearray(1024 * 1024)  # 1MB的bytearray
  mv3 = memoryview(large_ba)
  # 切片操作仅创建视图，不复制数据
  slice_mv = mv3[512:1024]  # 512字节的视图
  print(len(slice_mv))  # 输出：512
  slice_mv[:] = b'\x01'  # 批量修改切片区域为0x01
  print(large_ba[512])  # 输出：1（验证修改成功）