2025-10-08 Python 标准库 1——内置函数（1）

如果你用过 Python，一定对 print()、 len()这类不用 import 就能直接调用的函数不陌生 —— 它们就是 Python 的「内置函数」，是解释器自带的 “工具箱”，也是高效编程的基础。

我们就从最常用的数值处理开始，对 Python 的内置函数进行分类整理。

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

1. 数据类型转换与创建

负责创建特定类型对象（如 list()、dict()）或转换数据类型（如 int()、bin()），包含文件对象创建（open()）、属性对象创建（property()）等。

1.1. bin()

• 函数定义：bin(integer, /)

• 功能说明：将一个整数转换为带前缀 “0b” 的二进制数字符串，结果是合法的 Python 表达式。若 integer 不是 Python int 对象，则它必须定义返回整数的 __index__() 方法。

• 使用示例：

  # 基础转换
  print(bin(3))         # 输出：'0b11'
  print(bin(-10))       # 输出：'-0b1010'
  
  # 控制是否显示前缀 "0b"
  print(format(14, '#b'), format(14, 'b'))  # 输出：('0b1110', '1110')
  print(f'{14:#b}', f'{14:b}')              # 输出：('0b1110', '1110')
  

1.2. bool()

• 函数定义：class bool(object=False, /)

• 功能说明：返回布尔值（True 或 False）。参数将通过标准的真值测试过程转换：若参数为假值或被省略，返回 False；否则返回 True。bool 是 int 的子类，不能被继续子类化，且仅有 False 和 True 两个实例。

• 版本变更：Python 3.7 中，该形参变为仅限位置形参。

• 使用示例：

  print(bool())         # 输出：False（无参数，默认假值）
  print(bool(0))        # 输出：False（整数 0 为假值）
  print(bool(123))      # 输出：True（非零整数为真值）
  print(bool('hello'))  # 输出：True（非空字符串为真值）
  

1.3. bytearray()

• 函数定义：

  class bytearray(source=b'')

  class bytearray(source, encoding, errors='strict')

• 功能说明：创建一个可变的二进制序列对象（bytearray），元素为 0 ≤ x < 256 的整数，支持可变序列的大部分方法（如 append()、pop()）和 bytes 类型的大部分方法。

  • source 参数的初始化规则（根据类型不同）：
    1. 字符串：必须提供 encoding 参数（指定字符串编码），errors 可选（控制编码错误处理），通过 str.encode() 转换为字节序列；
    2. 整数：创建长度为该整数的数组，用 null 字节（\x00）填充；
    3. 缓冲区接口对象（如 bytes、memoryview）：使用对象的只读缓冲区初始化；
    4. 可迭代对象：元素必须是 0 ≤ x < 256 的整数，直接作为数组初始内容；
    5. 无参数：创建长度为0的空 bytearray。

• 补充说明：详情可参考“二进制序列类型 — bytes, bytearray, memoryview”和“bytearray 对象”官方文档。

• 使用示例：

  # 示例1：source为字符串（需指定encoding）
  ba1 = bytearray('hello 世界', encoding='utf-8')
  print(ba1)  # 输出：bytearray(b'hello \xe4\xb8\x96\xe7\x95\x8c')（UTF-8编码的字节）
  print(len(ba1))  # 输出：11（'hello '占6字节，'世界'占5字节）
  
  # 示例2：source为整数（用null字节填充）
  ba2 = bytearray(5)
  print(ba2)  # 输出：bytearray(b'\x00\x00\x00\x00\x00')（5个null字节）
  
  # 示例3：source为缓冲区对象（如bytes）
  b = b'python'
  ba3 = bytearray(b)
  print(ba3)  # 输出：bytearray(b'python')（从bytes复制）
  
  # 示例4：source为可迭代对象（0~255的整数）
  ba4 = bytearray([65, 66, 67, 255])  # A(65)、B(66)、C(67)、0xff
  print(ba4)  # 输出：bytearray(b'ABC\xff')
  
  # 示例5：可变操作（修改元素、添加元素）
  ba4[0] = 97  # 将A(65)改为a(97)
  ba4.append(98)  # 添加b(98)
  print(ba4)  # 输出：bytearray(b'aBC\xffb')
  

1.4. bytes()

• 函数定义：

  class bytes(source=b'')

  class bytes(source, encoding, errors='strict')

• 功能说明：创建一个不可变的二进制序列对象（bytes），元素为 0 ≤ x < 256 的整数，是 bytearray 的不可变版本，支持 bytearray 的大部分非修改方法（如 count()、find()）和相同的索引、切片操作。

  • source 参数的初始化规则与 bytearray() 完全一致（字符串需 encoding、整数为 null 填充、缓冲区对象复制、可迭代对象需整数元素）；
  • 额外创建方式：可通过字节字面值创建（如 b'hello'、b'\x00\x01'）。

• 补充说明：详情可参考“二进制序列类型 — bytes, bytearray, memoryview”和“bytes 对象”官方文档。

• 使用示例：

  # 示例1：source为字符串（需指定encoding）
  b1 = bytes('hello 世界', encoding='utf-8')
  print(b1)  # 输出：b'hello \xe4\xb8\x96\xe7\x95\x8c'（不可变，无法修改元素）
  
  # 示例2：source为整数（null字节填充）
  b2 = bytes(3)
  print(b2)  # 输出：b'\x00\x00\x00'
  
  # 示例3：source为可迭代对象
  b3 = bytes([104, 101, 108, 108, 111])  # h(104)、e(101)、l(108)、l(108)、o(111)
  print(b3)  # 输出：b'hello'
  
  # 示例4：字节字面值创建（更简洁的方式）
  b4 = b'python123'
  print(b4)  # 输出：b'python123'
  print(b4[2])  # 输出：116（切片获取单个字节的整数值，对应字符't'）
  
  # 示例5：不可变特性（修改元素会引发异常）
  # b4[0] = 97  # 引发 TypeError: 'bytes' object does not support item assignment
  

1.5. chr()

• 函数定义：chr(codepoint, /)

• 功能说明：返回表示指定 Unicode 码位 对应字符的字符串，是 ord() 的逆操作。

  • 参数要求：codepoint 需为整数，有效范围是 0 ~ 1114111（十六进制 0x10FFFF），超出范围将引发 ValueError；
  • 典型场景：根据 Unicode 码位生成对应字符（如特殊符号、非 ASCII 字符）。

• 使用示例：

  # 基础 ASCII 字符（码位 97 对应小写字母 'a'）
  print(chr(97))        # 输出：'a'
  # 大写字母（码位 65 对应 'A'）
  print(chr(65))        # 输出：'A'
  # 特殊符号（码位 8364 对应欧元符号 '€'）
  print(chr(8364))      # 输出：'€'
  # 汉字（码位 20013 对应 '中'）
  print(chr(20013))     # 输出：'中'
  # 表情符号（码位 128512 对应 😀）
  print(chr(128512))    # 输出：'😀'
  
  # 超出范围的码位（引发异常）
  try:
      chr(1114112)  # 码位超出 0x10FFFF
  except ValueError as e:
      print(e)      # 输出：chr() arg not in range(0x110000)
  

1.6. complex()

• 函数定义：

  class complex(number=0, /)

  class complex(string, /)

  class complex(real=0, imag=0)

• 功能说明：将特定字符串或数字转换为复数，或基于实部（real）和虚部（imag）创建复数。

  • 若参数为字符串：需包含实部（与 float() 格式一致）、虚部（带 j/J 后缀），或两者兼具（虚部需带正负号），首尾可加空格和圆括号，数字与 +/-/j 之间不可有空格。
  • 若参数为数字：委托给 __complex__()，无则回退 __float__()，再无则回退 __index__()。
  • 若提供两个参数：实部为 real，虚部为 imag；若均为复数，结果实部为 real.real - imag.imag，虚部为 real.imag + imag.real。

• 版本变更：

  • Python 3.6：支持用下划线分组数字（如 complex('1_234.56j')）。
  • Python 3.8：若 __complex__() 和 __float__() 均未定义，回退至 __index__()。

• 使用示例：

  # 字符串参数
  print(complex('+1.23'))          # 输出：(1.23+0j)
  print(complex('-4.5j'))          # 输出：(-0-4.5j)
  print(complex('\t( -1.23+4.5J )\n'))  # 输出：(-1.23+4.5j)
  
  # 数字/实部+虚部参数
  print(complex(1.23))             # 输出：(1.23+0j)
  print(complex(imag=-4.5))        # 输出：(-0-4.5j)
  print(complex(-1.23, 4.5))       # 输出：(-1.23+4.5j)
  

1.7. dict()

• 函数定义：

  class dict(**kwargs)

  class dict(mapping, /, **kwargs)

  class dict(iterable, /, **kwargs)

• 功能说明：创建一个新的字典对象（dict 是 Python 内置的映射类型），支持多种构造方式：

  1. 传入 **kwargs：关键字参数会成为字典的键值对（键为字符串）；
  2. 传入 mapping（映射对象，如另一个字典）：会复制 mapping 的键值对，若同时传入 **kwargs，则追加关键字参数的键值对；
  3. 传入 iterable（元素为键值对的可迭代对象，如元组列表）：会将每个键值对加入字典，若同时传入 **kwargs，则追加关键字参数的键值对；
  4. 无参数：创建空字典。

• 补充说明：详情可参考“dict”和“映射类型 — dict”官方文档，其他容器类型可参考 list、set、tuple 等。

• 使用示例：

  # 方式1：**kwargs
  print(dict(a=1, b=2, c=3))  # 输出：{'a': 1, 'b': 2, 'c': 3}
  
  # 方式2：mapping + **kwargs
  mapping = {1: 'one', 2: 'two'}
  print(dict(mapping, three=3))  # 输出：{1: 'one', 2: 'two', 'three': 3}
  
  # 方式3：iterable + **kwargs
  iterable = [('x', 10), ('y', 20)]
  print(dict(iterable, z=30))  # 输出：{'x': 10, 'y': 20, 'z': 30}
  
  # 方式4：无参数（空字典）
  print(dict())  # 输出：{}
  
  # 方式5：单一iterable（元素为键值对）
  print(dict([(1, 'a'), (2, 'b')]))  # 输出：{1: 'a', 2: 'b'}
  

1.8. float()

• 函数定义：

  class float(number=0.0, /)

  class float(string, /)

• 功能说明：返回基于数字或字符串构建的浮点数。

  • 若参数为字符串：需包含十进制数字（可带符号、嵌入空格），或代表 NaN（非数字）、正负无穷大的字符串（如 'nan'、'Infinity'），大小写不敏感。
  • 若参数为整数/浮点数：返回相同值（Python 浮点精度范围内），超出范围则引发 OverflowError。
  • 若参数为普通对象：委托给 __float__()，无则回退 __index__()。
  • 无参数时返回 0.0。

• 版本变更：

  • Python 3.6：支持用下划线分组数字（如 float('1_234.56')）。
  • Python 3.7：该形参变为仅限位置形参。
  • Python 3.8：若 __float__() 未定义，回退至 __index__()。

• 使用示例：

  # 字符串参数
  print(float('+1.23'))        # 输出：1.23
  print(float('   -12345\n'))  # 输出：-12345.0
  print(float('1e-003'))       # 输出：0.001
  print(float('-Infinity'))    # 输出：-inf
  
  # 数字参数
  print(float(123))            # 输出：123.0
  print(float(45.67))          # 输出：45.67
  

1.9. format()

• 函数定义：format(value, format_spec='', /)

• 功能说明：将 value 转换为“格式化后”的字符串，格式规则由 format_spec 控制：

  • format_spec 的解释依赖 value 的类型：大多数内置类型（如 int、float、str）遵循“格式规格迷你语言”（如 'd' 十进制、'f' 浮点数、's' 字符串）；
  • 默认行为：format_spec 为空时，结果与 str(value) 一致。
  • 底层实现：调用 type(value).__format__(value, format_spec)，若搜索到 object 且 format_spec 非空，或结果非字符串，引发 TypeError。

• 版本变更：Python 3.4 中，object().__format__(format_spec)（format_spec 非空）会引发 TypeError。

• 使用示例（基于“格式规格迷你语言”）：

  # 1. 整数格式化（十进制、二进制、十六进制）
  print(format(42, 'd'))    # 输出：'42'（十进制，默认）
  print(format(42, 'b'))    # 输出：'101010'（二进制）
  print(format(42, 'x'))    # 输出：'2a'（小写十六进制）
  print(format(42, '#X'))   # 输出：'0X2A'（大写十六进制，带前缀0X）
  
  # 2. 浮点数格式化（保留小数、科学计数法）
  print(format(3.14159, 'f'))   # 输出：'3.141590'（默认6位小数）
  print(format(3.14159, '.2f')) # 输出：'3.14'（保留2位小数）
  print(format(1234.56, 'e'))   # 输出：'1.234560e+03'（科学计数法）
  
  # 3. 字符串格式化（左对齐、右对齐、居中）
  print(format('hello', '<10')) # 输出：'hello     '（左对齐，占10位）
  print(format('hello', '>10')) # 输出：'     hello'（右对齐，占10位）
  print(format('hello', '^10')) # 输出：'  hello   '（居中，占10位）
  
  # 4. 默认格式（与str()一致）
  print(format([1,2,3]))   # 输出：'[1, 2, 3]'
  print(str([1,2,3]))      # 输出：'[1, 2, 3]'
  

1.10. frozenset()

• 函数定义：class frozenset(iterable=(), /)

• 功能说明：创建一个新的不可变集合对象（frozenset 是 Python 内置的集合类型），元素由可选参数 iterable 提供（iterable 为序列、迭代器或支持迭代的对象）。

  • 若未传入 iterable：创建空的 frozenset；
  • 特性：不可变（无法添加/删除元素），因此可作为字典的键或其他集合的元素（set 不可）。

• 补充说明：详情可参考“frozenset”和“集合类型 — set, frozenset”官方文档，其他容器类型可参考 list、tuple、dict 等。

• 使用示例：

  # 从列表创建frozenset
  print(frozenset([1, 2, 3, 2]))  # 输出：frozenset({1, 2, 3})（自动去重）
  
  # 从字符串创建frozenset
  print(frozenset('hello'))  # 输出：frozenset({'h', 'e', 'l', 'o'})（去重，无序）
  
  # 创建空frozenset
  print(frozenset())  # 输出：frozenset()
  
  # 作为字典的键（验证不可变性）
  dict_with_frozenset = {frozenset([1,2]): 'value'}
  print(dict_with_frozenset)  # 输出：{frozenset({1, 2}): 'value'}
  

1.11. int()

• 函数定义：

  class int(number=0, /)

  class int(string, /, base=10)

• 功能说明：返回从数字或字符串构建的整数，无参数时返回 0。

  • 若参数为数字：委托给 __int__()，无则回退 __index__()，再无则回退 __trunc__()（浮点数会向零截断）。
  • 若参数为字符串/bytes/bytearray（且给定 base）：需表示 base 进制的整数，可带正负号、前导零、两侧空格，数字间可加单个下划线；base 取值为 0 或 2-36，base=0 时按代码中整数字面值规则解析（前缀决定进制：0b 二进制、0o 八进制、0x 十六进制）。

• 版本变更：

  • Python 3.4：base 若为非 int 对象，使用 base.__index__() 获取进制（原用 __int__()）。
  • Python 3.6：支持用下划线分组数字（如 int('1_234')）。
  • Python 3.7：第一个形参变为仅限位置形参。
  • Python 3.8：若 __int__() 未定义，回退至 __index__()。
  • Python 3.11：弃用委托给 __trunc__() 的行为；限制整数字符串转换长度，超出则引发 ValueError。

• 使用示例：

  # 数字参数
  print(int(123.45))     # 输出：123（浮点数向零截断）
  print(int(-67.89))     # 输出：-67
  
  # 字符串+base参数
  print(int('123'))      # 输出：123（默认 base=10）
  print(int('   -12_345\n'))  # 输出：-12345（支持下划线和空格）
  print(int('FACE', 16)) # 输出：64206（base=16，十六进制）
  print(int('0xface', 0))# 输出：64206（base=0，按前缀解析为十六进制）
  print(int('01110011', base=2))  # 输出：115（base=2，二进制）
  

1.12. list()

• 函数定义：class list(iterable=(), /)

• 功能说明：list 是 Python 内置的可变序列类型，调用该函数会创建一个新的列表对象。

  • 若传入 iterable（序列、迭代器或支持迭代的对象）：列表会包含 iterable 的所有元素；
  • 若未传参数：创建空列表。

• 补充说明：详情可参考“列表”和“序列类型 — list, tuple, range”官方文档。

• 使用示例：

  # 从可迭代对象创建列表
  print(list(range(5)))        # 输出：[0, 1, 2, 3, 4]（从range创建）
  print(list('python'))        # 输出：['p', 'y', 't', 'h', 'o', 'n']（从字符串创建）
  print(list((1, 2, 3)))       # 输出：[1, 2, 3]（从元组创建）
  
  # 创建空列表
  print(list())                # 输出：[]
  

1.13. object()

• 函数定义：class object

• 功能说明：object 是Python中所有类的终极基类，所有内置类型（如 int、list）和自定义类都直接或间接继承自 object。

  • 构造器行为：调用 object() 会返回一个新的基础对象，且不接受任何参数；
  • 核心特性：object 实例没有 __dict__ 属性，因此无法给 object 实例动态添加任意属性；
  • 方法提供：object 提供了所有Python对象共有的基础方法（如 __hash__()、__eq__()、__repr__() 等），子类可根据需要重写这些方法。

• 使用示例：

  # 示例1：创建object实例
  obj = object()
  print(type(obj))  # 输出：<class 'object'>（验证是object类型）
  
  # 示例2：object实例无法添加属性（无__dict__）
  try:
      obj.name = "test"  # 尝试添加属性
  except AttributeError as e:
      print(e)  # 输出：'object' object has no attribute 'name'（报错，无法添加）
  
  # 示例3：自定义类默认继承object（Python 3中默认，无需显式声明）
  class MyCustomClass:  # 等价于 class MyCustomClass(object):
      pass
  
  # 验证继承关系：MyCustomClass是object的子类
  print(issubclass(MyCustomClass, object))  # 输出：True
  # MyCustomClass的实例继承自object的方法
  custom_obj = MyCustomClass()
  print(hasattr(custom_obj, '__eq__'))  # 输出：True（__eq__是object的方法）
  

1.14. oct()

• 函数定义：oct(integer, /)

• 功能说明：将整数转换为带前缀 “0o” 的八进制字符串，结果是合法的 Python 表达式。若 integer 不是 Python int 对象，则它必须定义返回整数的 __index__() 方法。

• 使用示例：

  # 基础转换
  print(oct(8))         # 输出：'0o10'
  print(oct(-56))       # 输出：'-0o70'
  
  # 控制是否显示前缀 "0o"
  print('%#o' % 10, '%o' % 10)  # 输出：('0o12', '12')
  print(format(10, '#o'), format(10, 'o'))  # 输出：('0o12', '12')
  print(f'{10:#o}', f'{10:o}')  # 输出：('0o12', '12')
  

1.15. open()

• 函数定义：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• 功能说明：打开指定文件并返回对应的文件对象（file object），是Python中文件读写的核心函数；若文件无法打开（如不存在、权限不足），引发 OSError。

  • 核心参数解释：

    1. file：文件路径（绝对路径或相对当前工作目录的路径），或整数类型的文件描述符（需配合 closefd 使用）；

    2. mode：文件打开模式（字符串），决定文件的读写方式和类型（文本/二进制），常见模式如下：

       模式字符	含义
       r	读取（默认模式，文件需存在）
       w	写入，若文件存在则清空内容，不存在则创建
       x	独占创建，若文件已存在则失败
       a	追加写入，若文件存在则在末尾追加，不存在则创建（Unix下忽略当前指针位置）
       b	二进制模式（读取/写入bytes对象，不涉及编码）
       t	文本模式（默认模式，读取/写入str对象，需指定编码）
       +	读写模式（与 r/w/a/x 结合，如 r+ 表示读写，不清空内容）
       常见组合：'rt'（默认，文本读取）、'wb'（二进制写入）、'r+'（文本读写）；

    3. encoding：文本模式下的编码格式（如 'utf-8'、'gbk'），二进制模式下无需指定；默认值依赖平台（通过 locale.getencoding() 获取）；

    4. errors：文本模式下的编码/解码错误处理方式（如 'strict' 引发异常、'replace' 替换为 �、'ignore' 忽略错误）；

    5. buffering：缓冲策略（整数）：

       • 0：关闭缓冲（仅二进制模式支持）；
       • 1：行缓冲（仅文本模式写入支持）；
       • >1：固定大小的块缓冲（字节数，默认值根据系统和文件类型自动确定）；

    6. newline：文本模式下的换行符处理（None/''/'\n'/'\r'/'\r\n'），控制读取时换行符的转换和写入时换行符的替换；

    7. closefd：若 file 为文件描述符，closefd=False 表示关闭文件对象时不关闭文件描述符（默认 True）；

    8. opener：自定义文件开启器（可调用对象），用于自定义文件打开逻辑（如指定目录描述符）。

  • 文本模式 vs 二进制模式：

    • 文本模式（t）：读取内容为 str 对象，需指定 encoding，自动处理换行符；
    • 二进制模式（b）：读取内容为 bytes 对象，无需编码，直接操作字节数据。

  • 返回的文件对象类型：根据 mode 不同，返回 io.TextIOWrapper（文本模式）、io.BufferedReader/io.BufferedWriter（二进制缓冲模式）或 io.FileIO（无缓冲二进制模式）。

• 版本变更：

  • Python 3.3：新增 opener 参数、'x' 模式；IOError 改为 OSError 的别名；
  • Python 3.4：文件对象默认禁止继承；
  • Python 3.5：系统调用被中断时重试（PEP 475）；新增 'namereplace' 错误处理方式；
  • Python 3.6：支持 os.PathLike 对象作为 file 参数；Windows下打开控制台缓冲区返回 io.RawIOBase 子类；
  • Python 3.11：移除 'U' 模式（通用换行模式通过 newline=None 实现）。

• 审计事件：引发 open 审计事件，附带参数 path、mode、flags。

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

  # 示例1：文本模式读取文件（默认mode='r'）
  # 方式1：手动关闭文件（需try-finally保证关闭）
  f1 = open('test.txt', mode='r', encoding='utf-8')
  try:
      content = f1.read()  # 读取全部内容（str对象）
      print("文件内容：", content)
  finally:
      f1.close()  # 必须关闭文件
  
  # 方式2：with语句（自动关闭文件，推荐）
  with open('test.txt', 'r', encoding='utf-8') as f2:
      lines = f2.readlines()  # 读取所有行，返回列表（每行末尾含换行符）
      print("文件行数：", len(lines))
      for line in lines:
          print("行内容：", line.strip())  # strip()去除换行符和空格
  
  # 示例2：文本模式写入文件（mode='w'）
  with open('output.txt', 'w', encoding='utf-8') as f3:
      f3.write("Hello, Python!\n")  # 写入字符串，需手动加换行符
      f3.writelines(["第一行\n", "第二行\n", "第三行\n"])  # 写入字符串列表
  
  # 示例3：二进制模式读取/写入文件（mode='rb'/'wb'）
  # 写入二进制文件（如图片、音频）
  with open('data.bin', 'wb') as f4:
      f4.write(b'\x00\x01\x02\x03')  # 写入bytes对象
  
  # 读取二进制文件
  with open('data.bin', 'rb') as f5:
      binary_content = f5.read()  # 读取bytes对象
      print("二进制内容：", binary_content)  # 输出：b'\x00\x01\x02\x03'
  
  # 示例4：读写模式（mode='r+'）
  with open('test.txt', 'r+', encoding='utf-8') as f6:
      content = f6.read()  # 先读取内容
      f6.seek(0)  # 移动指针到文件开头
      f6.write("新的内容：" + content)  # 覆盖写入（原内容被截断）
      f6.flush()  # 强制刷新缓冲区
  
  # 示例5：自定义opener（文档示例，按目录描述符打开文件）
  import os
  # 打开目录"somedir"，获取目录描述符
  dir_fd = os.open('somedir', os.O_RDONLY)
  # 定义自定义opener：按目录描述符打开文件
  def opener(path, flags):
      return os.open(path, flags, dir_fd=dir_fd)
  
  # 在"somedir"目录下创建并写入文件"spamspam.txt"
  with open('spamspam.txt', 'w', opener=opener) as f7:
      f7.write('This will be written to somedir/spamspam.txt')
  
  os.close(dir_fd)  # 关闭目录描述符（避免泄漏）
  

1.16. ord()

• 函数定义：ord(character, /)

• 功能说明：返回字符的Unicode 码位值（或 bytes/bytearray 对象的单个字节值），是 chr() 的逆操作：

  • 若参数为单字符字符串：返回该字符的 Unicode 码位（如 ord('a') → 97、ord('€') → 8364）；
  • 若参数为长度为1的 bytes/bytearray 对象：返回其单个字节的整数值（如 ord(b'a') → 97、ord(b'\xe2') → 226）；
  • 参数限制：字符串需长度为1，否则引发 TypeError；Unicode 码位需在 0~1114111（0x10FFFF）范围内，否则引发 ValueError。

• 使用示例：

  # 1. 单字符字符串：返回Unicode码位
  print(ord('a'))        # 输出：97（小写字母a的码位）
  print(ord('A'))        # 输出：65（大写字母A的码位）
  print(ord('€'))        # 输出：8364（欧元符号的Unicode码位）
  print(ord('中'))       # 输出：20013（汉字“中”的Unicode码位）
  
  # 2. 长度为1的bytes对象：返回字节值
  print(ord(b'a'))       # 输出：97（字节b'a'的整数值）
  print(ord(b'\x80'))    # 输出：128（十六进制字节\x80的整数值）
  print(ord(bytearray(b'x')[0]))  # 输出：120（bytearray对象的单个字节值）
  
  # 3. 非法参数：引发异常
  # ord('ab')  # 字符串长度>1 → TypeError: ord() expected a character, but string of length 2 found
  # ord('𝄞')  # Unicode码位119070（0x1D11E）在范围内 → 输出119070
  # ord(chr(1114112))  # 码位超出1114111 → ValueError: ord() arg not in range(0x110000)
  

1.17. property()

• 函数定义：class property(fget=None, fset=None, fdel=None, doc=None)

• 功能说明：创建一个受管理的属性（property），用于控制类属性的访问（读取、设置、删除），实现“属性访问的封装”（如只读属性、值验证、访问日志）：

  • 参数解释：
    1. fget：用于读取属性的函数（getter），无则属性为只读；
    2. fset：用于设置属性的函数（setter），无则属性不可设置；
    3. fdel：用于删除属性的函数（deleter），无则属性不可删除；
    4. doc：属性的文档字符串，无则复用 fget 的文档字符串。
  • 核心优势：通过 property，可将方法伪装为属性（如 obj.x 而非 obj.get_x()），同时在访问时执行自定义逻辑（如值校验）。

• 使用方式：

  1. 直接调用 property(fget, fset, fdel, doc) 绑定到类属性；
  2. 装饰器形式（推荐）：通过 @property（getter）、@x.setter（setter）、@x.deleter（deleter）定义。

• 版本变更：

  • Python 3.5：property 对象的文档字符串变为可写；
  • Python 3.13：新增 __name__ 属性，保存 property 的名称（可在运行时修改）。

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

  # 示例1：基础用法（直接调用property()）
  class C:
      def __init__(self):
          self._x = None  # 私有变量（约定用单下划线标识）
      
      # getter：读取_x
      def getx(self):
          return self._x
      
      # setter：设置_x（可添加验证逻辑）
      def setx(self, value):
          if not isinstance(value, int):
              raise TypeError("x must be an integer")
          self._x = value
      
      # deleter：删除_x
      def delx(self):
          del self._x
      
      # 绑定property：x是受管理的属性
      x = property(getx, setx, delx, "I'm the 'x' property.")
  
  c = C()
  # 读取属性（调用getx()）
  c.x = 10  # 调用setx()，验证value为int
  print(c.x)  # 输出：10
  # 删除属性（调用delx()）
  del c.x
  # print(c.x)  # 引发 AttributeError: 'C' object has no attribute '_x'
  # c.x = "abc"  # 引发 TypeError: x must be an integer（setx()验证失败）
  # 查看文档字符串
  print(C.x.__doc__)  # 输出："I'm the 'x' property."
  
  # 示例2：装饰器形式（推荐，更简洁）
  class Parrot:
      def __init__(self):
          self._voltage = 100000  # 私有变量
      
      @property  # 标记为getter，属性名=方法名（voltage）
      def voltage(self):
          """Get the current voltage."""  # 文档字符串
          return self._voltage
      
      @voltage.setter  # 标记为setter，绑定到voltage属性
      def voltage(self, value):
          if value < 0:
              raise ValueError("Voltage cannot be negative")
          self._voltage = value
      
      @voltage.deleter  # 标记为deleter
      def voltage(self):
          raise PermissionError("Cannot delete voltage")  # 禁止删除
  
  p = Parrot()
  print(p.voltage)  # 输出：100000（调用getter）
  p.voltage = 120000  # 调用setter，验证value≥0
  print(p.voltage)  # 输出：120000
  # p.voltage = -5000  # 引发 ValueError: Voltage cannot be negative
  # del p.voltage  # 引发 PermissionError: Cannot delete voltage
  
  # 示例3：只读属性（无setter）
  class ReadOnly:
      @property
      def info(self):
          return "This is a read-only property"
  
  ro = ReadOnly()
  print(ro.info)  # 输出："This is a read-only property"
  # ro.info = "new info"  # 引发 AttributeError: can't set attribute（无setter）
  

1.18. range()

• 函数定义：

  class range(stop, /)

  class range(start, stop, step=1, /)

• 功能说明：range 是 Python 内置的不可变序列类型，调用该函数会创建一个表示整数范围的 range 对象。

  • 参数规则：
    • start：起始值（默认 0）；
    • stop：结束值（不包含在序列内，必填）；
    • step：步长（默认 1，不能为 0，否则引发 ValueError）。

• 补充说明：详情可参考“range 对象”和“序列类型 — list, tuple, range”官方文档。

• 使用示例：

  # 示例1：仅传stop（start=0，step=1）
  print(list(range(5)))        # 输出：[0, 1, 2, 3, 4]
  
  # 示例2：传start和stop（step=1）
  print(list(range(2, 7)))     # 输出：[2, 3, 4, 5, 6]
  
  # 示例3：传start、stop和step（步长为2）
  print(list(range(1, 10, 2))) # 输出：[1, 3, 5, 7, 9]
  
  # 示例4：反向序列（step为负）
  print(list(range(10, 0, -2)))# 输出：[10, 8, 6, 4, 2]
  

1.19. set()

• 函数定义：class set(iterable=(), /)

• 功能说明：创建一个新的可变集合对象（set 是 Python 内置的集合类型），元素由可选参数 iterable 提供（iterable 为序列、迭代器或支持迭代的对象）。

  • 若未传入 iterable：创建空的 set；
  • 特性：可变（可添加/删除元素）、无序、自动去重，因此不可作为字典的键或其他集合的元素（frozenset 可）。

• 补充说明：详情可参考“set”和“集合类型 — set, frozenset”官方文档，其他容器类型可参考 list、tuple、dict 等。

• 使用示例：

  # 从列表创建set（自动去重）
  print(set([1, 2, 3, 2, 1]))  # 输出：{1, 2, 3}
  
  # 从字符串创建set（去重，无序）
  print(set('hello'))  # 输出：{'h', 'e', 'l', 'o'}
  
  # 创建空set（注意：{}是空字典，不是空set）
  print(set())  # 输出：set()
  
  # 可变操作（添加/删除元素）
  s = set([1, 2, 3])
  s.add(4)
  print(s)  # 输出：{1, 2, 3, 4}
  s.remove(2)
  print(s)  # 输出：{1, 3, 4}
  
  # 不可作为字典的键（验证可变性）
  # dict_with_set = {set([1,2]): 'value'}  # 引发 TypeError: unhashable type: 'set'
  

1.20. slice()

• 函数定义：

  class slice(stop, /)

  class slice(start, stop, step=None, /)

• 功能说明：返回一个切片对象，表示由 range(start, stop, step) 定义的索引集。

  • 切片对象的只读属性：start（起始索引，默认 None）、stop（结束索引，必填）、step（步长，默认 None）；
  • 扩展索引语法（如 a[start:stop:step]）会隐式生成切片对象。

• 版本变更：Python 3.12 中，若 start、stop、step 均为可哈希对象，切片对象变为可哈希。

• 使用示例：

  # 创建切片对象
  s1 = slice(3)          # 等价于 [0:3:1]
  s2 = slice(1, 5)       # 等价于 [1:5:1]
  s3 = slice(1, 10, 2)   # 等价于 [1:10:2]
  
  # 应用于序列
  a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  print(a[s1])  # 输出：[0, 1, 2]
  print(a[s2])  # 输出：[1, 2, 3, 4]
  print(a[s3])  # 输出：[1, 3, 5, 7, 9]
  
  # 查看切片属性
  print(s3.start)  # 输出：1
  print(s3.stop)   # 输出：10
  print(s3.step)   # 输出：2
  

1.21. str()

• 函数定义：

  class str(*, encoding='utf-8', errors='strict')

  class str(object)

  class str(object, encoding, errors='strict')

  class str(object, *, errors)

• 功能说明：创建一个新的字符串对象（str），Python 内置的文本序列类型，支持多种构造方式：

  1. 无参数：不允许（需至少指定 object 或关键字参数）；
  2. 传入 object：返回 object 的字符串表示（委托给 object.__str__()，无则回退 repr()）；
  3. 传入 object + encoding + errors：object 需为 bytes/bytearray，按 encoding 解码为字符串，errors 控制解码错误处理（如 'strict' 引发异常、'replace' 替换为 �）；
  4. 关键字参数：encoding 默认为 'utf-8'，errors 默认为 'strict'。

• 补充说明：详情可参考“文本序列类型 — str”官方文档。

• 使用示例：

  # 1. 传入object：转换为字符串表示
  print(str(123))          # 输出：'123'（整数转字符串）
  print(str(3.14159))      # 输出：'3.14159'（浮点数转字符串）
  print(str([1,2,3]))      # 输出：'[1, 2, 3]'（列表转字符串）
  
  # 2. 传入bytes + encoding：解码为字符串
  b = b'hello 世界'  # bytes对象（含ASCII和UTF-8编码的“世界”）
  print(str(b, encoding='utf-8'))  # 输出：'hello 世界'（正确解码）
  print(str(b, encoding='ascii', errors='replace'))  # 输出：'hello ��'（ASCII无法解码“世界”，替换为�）
  
  # 3. 关键字参数形式
  print(str(object=b'欧元：€', encoding='utf-8'))  # 输出：'欧元：€'
  print(str(object=b'欧元：€', encoding='ascii', errors='ignore'))  # 输出：'欧元：'（忽略无法解码的字符）
  

1.22. super()

• 函数定义： class super(type, object_or_type=None, /)

• 功能说明：返回一个代理对象，该对象会将方法调用委托给 type 的父类或兄弟类，主要用于访问被子类重写的父类方法，支持单继承和协作多重继承。

  • 参数解释：
    1. type：指定“从哪个类之后开始搜索父类”（即跳过 type 本身，搜索其MRO中的后续类）；
    2. object_or_type：确定方法解析顺序（MRO）的对象/类型：
       • 若为对象：需满足 isinstance(object_or_type, type)（即对象是 type 的实例）；
       • 若为类型：需满足 issubclass(object_or_type, type)（常用于类方法）；
    3. 零参数形式（推荐）：在类的普通方法/类方法中可省略参数（super()），此时 type 自动设为当前类，object_or_type 自动设为方法的第一个参数（通常是 self 或 cls）。
  • 核心用途：
    1. 单继承：引用父类方法而无需显式写父类名（便于代码维护，如父类名修改时无需改动子类）；
    2. 多重继承：支持协作多重继承（如“菱形继承”），按MRO顺序调用父类方法，避免重复调用。

• 补充说明：super() 不仅支持方法调用，也支持属性查找；零参数形式仅在类定义内部有效（编译器需获取当前类和方法参数信息）。

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

  # 示例1：单继承中使用super()（调用父类方法）
  class Parent:
      def __init__(self, name):
          self.name = name
          print(f"Parent __init__: {self.name}")
  
  class Child(Parent):
      def __init__(self, name, age):
          # 调用父类的__init__方法（无需显式写Parent.__init__）
          super().__init__(name)  # 等价于 super(Child, self).__init__(name)
          self.age = age
          print(f"Child __init__: {self.name}, {self.age}")
  
  child = Child("Alice", 25)
  # 输出：
  # Parent __init__: Alice
  # Child __init__: Alice, 25
  
  # 示例2：协作多重继承（菱形继承）
  class A:
      def method(self):
          print("A.method")
  
  class B(A):
      def method(self):
          print("B.method start")
          super().method()  # 委托给MRO中的下一个类（A）
          print("B.method end")
  
  class C(A):
      def method(self):
          print("C.method start")
          super().method()  # 委托给MRO中的下一个类（A）
          print("C.method end")
  
  class D(B, C):  # MRO：D → B → C → A → object
      def method(self):
          print("D.method start")
          super().method()  # 委托给MRO中的下一个类（B）
          print("D.method end")
  
  d = D()
  d.method()
  # 输出（按MRO顺序调用）：
  # D.method start
  # B.method start
  # C.method start
  # A.method
  # C.method end
  # B.method end
  # D.method end
  
  # 示例3：类方法中使用super()
  class Base:
      @classmethod
      def class_method(cls):
          print(f"Base class_method: {cls.__name__}")
  
  class Derived(Base):
      @classmethod
      def class_method(cls):
          print(f"Derived class_method: {cls.__name__}")
          # 类方法中用super()，需指定cls（或Derived）
          super(Derived, cls).class_method()
  
  Derived.class_method()
  # 输出：
  # Derived class_method: Derived
  # Base class_method: Derived
  

1.23. tuple()

• 函数定义：class tuple(iterable=(), /)

• 功能说明：tuple 是 Python 内置的不可变序列类型，调用该函数会创建一个新的元组对象。

  • 若传入 iterable（序列、迭代器或支持迭代的对象）：元组会包含 iterable 的所有元素；
  • 若未传参数：创建空元组。

• 补充说明：详情可参考“元组”和“序列类型 — list, tuple, range”官方文档。

• 使用示例：

  # 从可迭代对象创建元组
  print(tuple(range(3)))       # 输出：(0, 1, 2)（从range创建）
  print(tuple('python'))       # 输出：('p', 'y', 't', 'h', 'o', 'n')（从字符串创建）
  print(tuple([1, 2, 3]))      # 输出：(1, 2, 3)（从列表创建）
  
  # 创建空元组
  print(tuple())               # 输出：()
  
  # 单元素元组（需加逗号，否则视为普通括号）
  print(tuple([5]))            # 输出：(5,)
  

1.24. hex()

• 函数定义：hex(integer, /)

• 功能说明：将整数转换为带前缀 “0x” 的小写十六进制字符串，结果是合法的 Python 表达式。若 integer 不是 Python int 对象，则它必须定义返回整数的 __index__() 方法。

• 使用示例：

  # 基础转换
  print(hex(255))        # 输出：'0xff'
  print(hex(-42))        # 输出：'-0x2a'
  
  # 控制前缀和大小写
  print('%#x' % 255, '%x' % 255, '%X' % 255)  # 输出：('0xff', 'ff', 'FF')
  print(format(255, '#x'), format(255, 'x'), format(255, 'X'))  # 输出：('0xff', 'ff', 'FF')
  print(f'{255:#x}', f'{255:x}', f'{255:X}')  # 输出：('0xff', 'ff', 'FF')
  

• 备注：若需获取浮点数的十六进制字符串，使用 float.hex() 方法（如 (1.23).hex()）。

2. 对象属性操作

用于获取、设置、删除对象属性（如 getattr()、setattr()），检查对象类型（isinstance()）、定义类方法 / 静态方法（classmethod()、staticmethod()）等。

2.1. getattr()

• 函数定义：

  getattr(object, name, /)

  getattr(object, name, default, /)

• 功能说明：获取对象 object 中名称为 name（字符串）的属性值，是 setattr() 的对应函数：

  • 若 name 是对象的属性名称：返回该属性的值（等价于 object.name）；
  • 若 name 不是对象的属性名称：
    1. 若提供 default：返回 default；
    2. 若未提供 default：引发 AttributeError。

• 备注：

  1. name 不必是 Python 标识符（参考 setattr() 的说明）；
  2. 私有属性（以两个下划线开头）因“私有名称混合”（编译时处理），需手动混合名称才能通过 getattr() 获取（如 getattr(obj, '_ClassName__private_attr')）。

• 使用示例：

  class MyClass:
      def __init__(self):
          self.public_attr = 100
          self._private_attr = 200  # 约定的私有属性（非严格）
          self.__strict_private = 300  # 严格私有属性（编译时混合名称）
  
  obj = MyClass()
  
  # 获取存在的公有属性
  print(getattr(obj, 'public_attr'))  # 输出：100（等价于 obj.public_attr）
  
  # 获取存在的约定私有属性（单下划线）
  print(getattr(obj, '_private_attr'))  # 输出：200
  
  # 获取严格私有属性（需手动混合名称：_类名__属性名）
  print(getattr(obj, '_MyClass__strict_private'))  # 输出：300
  
  # 获取不存在的属性（带默认值）
  print(getattr(obj, 'non_exist_attr', 'default_value'))  # 输出：'default_value'
  
  # 获取不存在的属性（无默认值，引发异常）
  # print(getattr(obj, 'non_exist_attr'))  # 引发 AttributeError: 'MyClass' object has no attribute 'non_exist_attr'
  

2.2. setattr()

• 函数定义：setattr(object, name, value, /)

• 功能说明：设置对象 object 中名称为 name（字符串）的属性值，是 getattr() 的对应函数：

  • 若 name 是对象已有的属性：更新该属性的值；
  • 若 name 是对象不存在的属性：在对象允许的情况下，新增该属性并赋值；
  • 操作等价于 object.name = value。

• 备注：

  1. name 不必是 Python 标识符（除非对象通过自定义 __getattribute__() 或 __slots__ 强制限制），非标识符属性无法通过点号访问，但可通过 getattr()/setattr() 操作；
  2. 严格私有属性（以两个下划线开头）需手动混合名称才能设置（参考 getattr() 的备注）。

• 使用示例：

  class MyClass:
      def __init__(self):
          self.public_attr = 100
  
  obj = MyClass()
  
  # 更新已有属性
  print(obj.public_attr)  # 输出：100
  setattr(obj, 'public_attr', 200)
  print(obj.public_attr)  # 输出：200（属性已更新）
  
  # 新增属性（非标识符名称示例）
  setattr(obj, 'non-identifier-attr', 300)
  # print(obj.non-identifier-attr)  # 无法通过点号访问（语法错误）
  print(getattr(obj, 'non-identifier-attr'))  # 输出：300（通过getattr()访问）
  
  # 设置严格私有属性（需手动混合名称）
  setattr(obj, '_MyClass__strict_private', 400)
  print(getattr(obj, '_MyClass__strict_private'))  # 输出：400
  

2.3. delattr()

• 函数定义：delattr(object, name, /)

• 功能说明：删除对象的指定属性，是 setattr() 的对应函数。

  • 参数 name 需为对象属性的名称（字符串形式），操作等价于 del object.name。
  • name 不必是 Python 标识符（参考 setattr() 的说明），只要对象允许删除该属性即可。

• 使用示例：

  class MyClass:
      def __init__(self):
          self.foo = 10
          self.bar = 20
  
  obj = MyClass()
  print(obj.foo)  # 输出：10（删除前存在属性）
  
  # 删除属性foo
  delattr(obj, 'foo')
  # print(obj.foo)  # 若执行此句，会引发 AttributeError（属性已删除）
  
  # 等价于del语句
  del obj.bar  # 等价于 delattr(obj, 'bar')
  # print(obj.bar)  # 引发 AttributeError
  

2.4. hasattr()

• 函数定义：hasattr(object, name, /)

• 功能说明：判断 object 是否具有名称为 name（字符串）的属性，返回 True 或 False。

  • 实现原理：通过调用 getattr(object, name) 并捕获 AttributeError 异常实现——若未捕获到异常则返回 True，否则返回 False。

• 使用示例：

  class MyClass:
      attr1 = 10
      def __init__(self):
          self.attr2 = 20
  
  obj = MyClass()
  
  # 判断类属性是否存在
  print(hasattr(MyClass, 'attr1'))  # 输出：True
  print(hasattr(MyClass, 'attr2'))  # 输出：False（attr2是实例属性）
  
  # 判断实例属性是否存在
  print(hasattr(obj, 'attr1'))  # 输出：True（实例可访问类属性）
  print(hasattr(obj, 'attr2'))  # 输出：True（实例自身的属性）
  print(hasattr(obj, 'attr3'))  # 输出：False（不存在的属性）
  
  # 判断方法是否存在（方法也是类/实例的属性）
  class MyClass2:
      def my_method(self):
          pass
  
  obj2 = MyClass2()
  print(hasattr(obj2, 'my_method'))  # 输出：True
  

2.5. dir()

• 函数定义：

  dir()

  dir(object, /)

• 功能说明：返回对象的有效属性列表，行为因参数是否存在而异：

  • 无参数：返回当前本地作用域中的名称列表；
  • 有参数：
    1. 若对象定义了 __dir__() 方法，调用该方法并返回其返回的属性列表（支持自定义属性报告方式）；
    2. 若未定义 __dir__()，则从对象的 __dict__ 属性和其类型对象中收集属性，结果可能不完整（尤其当对象有自定义 __getattr__() 时）。

• 默认行为差异：

  • 模块对象：返回模块属性名称；
  • 类型/类对象：返回类属性名称及所有基类的属性名称（递归）；
  • 其他对象：返回对象属性名称、类属性名称及类的所有基类的属性名称（递归）。

• 备注：dir() 主要用于交互式环境，结果按字母排序，行为可能随版本变化（优先返回“用户感兴趣的名称”而非严格完整的属性列表）。

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

  # 示例1：无参数（返回当前本地作用域名称）
  import struct
  print(dir())  # 输出：['__builtins__', '__name__', 'struct']（示例，具体因环境而异）
  
  # 示例2：传入模块对象（查看struct模块属性）
  print(dir(struct))  # 输出：['Struct', '__all__', '__builtins__', ..., 'unpack', 'unpack_from']（示例）
  
  # 示例3：自定义__dir__()方法的类
  class Shape:
      def __dir__(self):
          return ['area', 'perimeter', 'location']
  
  s = Shape()
  print(dir(s))  # 输出：['area', 'location', 'perimeter']
  

2.6. vars()

• 函数定义：

  vars()

  vars(object, /)

• 功能说明：返回对象的 __dict__ 属性（存储对象属性的字典），行为因参数是否存在而异：

  • 有参数：
    1. 若对象（模块、类、实例等）具有 __dict__ 属性：返回该属性（模块和实例的 __dict__ 可更新，类的 __dict__ 可能被包装为 types.MappingProxyType 以防止直接更新）；
    2. 若对象无 __dict__ 属性（如类定义了 __slots__）：引发 TypeError。
  • 无参数：行为与 locals() 类似（返回当前局部符号表的映射对象）。

• 版本变更：Python 3.13 中，无参数调用的结果与 locals() 的描述一致。

• 使用示例：

  # 示例1：传入实例（返回实例的__dict__）
  class MyClass:
      def __init__(self):
          self.a = 1
          self.b = 2
  
  obj = MyClass()
  print(vars(obj))  # 输出：{'a': 1, 'b': 2}（实例的属性字典）
  
  # 修改实例的__dict__（等价于修改属性）
  vars(obj)['a'] = 100
  print(obj.a)  # 输出：100
  
  # 示例2：传入模块（返回模块的__dict__）
  import math
  print(vars(math).keys())  # 输出：dict_keys(['__name__', '__doc__', 'pi', 'sin', ...])（模块的属性名称）
  
  # 示例3：无参数（返回当前局部作用域的映射）
  local_var = 3
  print(vars())  # 输出：包含'local_var'、'MyClass'、'obj'、'math'等的字典（因环境而异）
  
  # 示例4：无__dict__属性的对象（引发TypeError）
  class MyClassWithSlots:
      __slots__ = ('x', 'y')  # 定义slots，实例无__dict__
      def __init__(self):
          self.x = 10
          self.y = 20
  
  obj2 = MyClassWithSlots()
  # print(vars(obj2))  # 引发 TypeError: vars() argument must have __dict__ attribute
  

2.7. isinstance()

• 函数定义：isinstance(object, classinfo, /)

• 功能说明：判断 object 是否为 classinfo 及其（直接、间接或虚拟）子类的实例，返回 True 或 False：

  • classinfo 允许的类型：
    1. 单个类型对象（如 int、list）；
    2. 类型对象的元组（或递归的元组，如 (int, (list, dict))）；
    3. 类型的 union 类型（Python 3.10+，如 int | str）。
  • 特殊情况：若 classinfo 不是上述类型，引发 TypeError；若检查成功，可能不引发无效类型的 TypeError。

• 版本变更：Python 3.10 中，classinfo 支持 union 类型。

• 使用示例：

  # 示例1：单个类型
  print(isinstance(10, int))        # 输出：True
  print(isinstance('hello', str))   # 输出：True
  print(isinstance([1,2], list))    # 输出：True
  print(isinstance(10, str))        # 输出：False
  
  # 示例2：类型元组
  print(isinstance(10, (int, str))) # 输出：True（10是int，在元组中）
  print(isinstance('10', (int, str)))# 输出：True（'10'是str，在元组中）
  print(isinstance([1], (int, str)))# 输出：False（[1]是list，不在元组中）
  
  # 示例3：子类（直接/间接继承）
  class Parent:
      pass
  class Child(Parent):
      pass
  class GrandChild(Child):
      pass
  
  obj = GrandChild()
  print(isinstance(obj, GrandChild))# 输出：True（直接实例）
  print(isinstance(obj, Child))     # 输出：True（间接子类）
  print(isinstance(obj, Parent))    # 输出：True（间接子类）
  
  # 示例4：union类型（Python 3.10+）
  print(isinstance(10, int | str))  # 输出：True
  print(isinstance(3.14, int | float))# 输出：True
  

2.8. issubclass()

• 函数定义：issubclass(class, classinfo, /)

• 功能说明：判断 class 是否为 classinfo 及其（直接、间接或虚拟）子类，返回 True 或 False：

  • 特性：类视为自身的子类（issubclass(C, C) 返回 True）；
  • classinfo 允许的类型：与 isinstance() 相同（单个类型、类型元组、union 类型（Python 3.10+））；
  • 特殊情况：若 classinfo 不是上述类型，引发 TypeError。

• 版本变更：Python 3.10 中，classinfo 支持 union 类型。

• 使用示例：

  # 示例1：单个类型（类自身）
  class C:
      pass
  print(issubclass(C, C))  # 输出：True（类是自身的子类）
  
  # 示例2：直接子类
  class D(C):
      pass
  print(issubclass(D, C))  # 输出：True（D是C的直接子类）
  print(issubclass(C, D))  # 输出：False（C不是D的子类）
  
  # 示例3：间接子类
  class E(D):
      pass
  print(issubclass(E, C))  # 输出：True（E是C的间接子类）
  
  # 示例4：类型元组
  print(issubclass(D, (C, E)))  # 输出：True（D是C的子类，在元组中）
  print(issubclass(E, (C, D)))  # 输出：True（E是C和D的子类，在元组中）
  
  # 示例5：union类型（Python 3.10+）
  print(issubclass(D, C | E))  # 输出：True（D是C的子类，在union中）
  print(issubclass(E, D | int))# 输出：True（E是D的子类，在union中）
  

2.9. type()

• 函数定义：

  class type(object, /)

  class type(name, bases, dict, /, **kwargs)

• 功能说明：type 具有双重角色，既是获取对象类型的函数，也是动态创建类的类（Python中所有类都是 type 的实例，即“元类”）。

  • 单参数形式（获取类型）：
    • 传入一个对象 object，返回该对象的类型（等价于 object.__class__）；
    • 推荐使用 isinstance() 检测对象类型（因 isinstance() 会考虑子类，而 type() 仅判断精确类型）。
  • 三参数形式（动态创建类）：
    • 等价于 class 语句的动态形式，用于在运行时创建类：
      1. name：类名（字符串），会成为类的 __name__ 属性；
      2. bases：基类元组，会成为类的 __bases__ 属性（为空时自动添加 object 作为基类）；
      3. dict：类的属性和方法字典（键为属性名，值为属性值/方法），会成为类的 __dict__ 属性；
      4. **kwargs：关键字参数，传递给元类的 __init_subclass__() 方法（类似 class 语句中的关键字参数）。

• 版本变更：Python 3.6 中，type 的子类若未重写 type.__new__，将无法用单参数形式获取对象类型。

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

  # 示例1：单参数形式（获取对象类型）
  # 基本类型
  print(type(10))          # 输出：<class 'int'>
  print(type('hello'))     # 输出：<class 'str'>
  print(type([1,2,3]))     # 输出：<class 'list'>
  # 自定义类实例
  class MyClass:
      pass
  obj = MyClass()
  print(type(obj))         # 输出：<class '__main__.MyClass'>
  # 对比type()和isinstance()（isinstance考虑子类）
  class MySubClass(MyClass):
      pass
  sub_obj = MySubClass()
  print(type(sub_obj) == MyClass)          # 输出：False（精确类型不匹配）
  print(isinstance(sub_obj, MyClass))       # 输出：True（子类实例属于父类类型）
  
  # 示例2：三参数形式（动态创建类，等价于class语句）
  # 方式1：用class语句创建类
  class X:
      a = 1
  print(X.a)  # 输出：1
  print(type(X))  # 输出：<class 'type'>（X是type的实例，即元类的实例）
  
  # 方式2：用type()动态创建类（与上面的class X等价）
  X_dynamic = type('X', (), dict(a=1))  # name='X', bases=(), dict={'a':1}
  print(X_dynamic.a)  # 输出：1
  print(type(X_dynamic))  # 输出：<class 'type'>
  
  # 示例3：动态创建带基类和方法的类
  # 定义基类
  class Base:
      def base_method(self):
          print("Base method")
  # 定义要添加到动态类的方法
  def dynamic_method(self, value):
      self.value = value
      print(f"Dynamic method: value={self.value}")
  # 动态创建类（继承Base，包含dynamic_method和属性b）
  DynamicClass = type(
      'DynamicClass',  # 类名
      (Base,),         # 基类元组（继承Base）
      dict(            # 类属性和方法字典
          b=2,
          dynamic_method=dynamic_method
      )
  )
  # 使用动态创建的类
  dc_obj = DynamicClass()
  dc_obj.base_method()  # 输出：Base method（继承自Base）
  dc_obj.dynamic_method(100)  # 输出：Dynamic method: value=100
  print(dc_obj.b)  # 输出：2（类属性b）
  
  # 示例4：带**kwargs的动态创建（传递给__init_subclass__）
  class MetaBase:
      @classmethod
      def __init_subclass__(cls, extra_attr=None, **kwargs):
          super().__init_subclass__(**kwargs)
          if extra_attr is not None:
              cls.extra_attr = extra_attr
  # 动态创建类时传递extra_attr关键字参数
  SubClass = type('SubClass', (MetaBase,), {}, extra_attr="test")
  print(SubClass.extra_attr)  # 输出：test（通过__init_subclass__添加的属性）
  

2.10. classmethod()

• 函数定义：@classmethod（装饰器形式，或 classmethod(function)）

• 功能说明：将类中的方法封装为类方法，类方法的隐含第一个参数是类对象（通常命名为 cls），而非实例对象（self）：

  • 调用方式：可通过类（如 C.f()）或实例（如 C().f()）调用，实例调用时会忽略实例本身，仅传递类对象；
  • 派生类调用：若在派生类上调用类方法，传递的隐含参数为派生类对象（而非基类）；
  • 与静态方法区别：不同于 staticmethod()（无隐含参数），类方法可通过 cls 访问类的属性和其他类方法。

• 使用方式：通常以装饰器 @classmethod 放在方法定义前（推荐），也可直接调用 classmethod(function) 包装函数。

• 版本变更：

  • Python 3.9：类方法可包装其他描述器（如 property()）；
  • Python 3.10：类方法继承原方法的属性（__module__、__name__ 等），新增 __wrapped__ 属性；
  • Python 3.11（弃用）/ 3.13（移除）：类方法不再支持包装其他描述器（如 property()）。

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

  # 示例1：基础类方法（装饰器形式）
  class C:
      count = 0  # 类属性（计数实例创建次数）
      
      def __init__(self):
          C.count += 1  # 每次创建实例，类属性+1
      
      @classmethod
      def get_count(cls):
          # cls 指向类对象（C或其派生类）
          return f"Class: {cls.__name__}, Instance count: {cls.count}"
  
  # 通过类调用
  print(C.get_count())  # 输出：Class: C, Instance count: 0（未创建实例）
  # 通过实例调用
  c1 = C()
  c2 = C()
  print(c1.get_count())  # 输出：Class: C, Instance count: 2（创建2个实例）
  
  # 示例2：派生类调用（传递派生类对象）
  class D(C):
      pass
  
  d1 = D()
  print(D.get_count())  # 输出：Class: D, Instance count: 1（D的count独立于C）
  print(C.get_count())  # 输出：Class: C, Instance count: 2（C的count不受影响）
  
  # 示例3：直接调用classmethod()包装函数（非装饰器形式）
  class E:
      @staticmethod
      def static_func():
          return "Static method"
      
  # 将静态方法包装为类方法（不推荐，仅示例语法）
  E.class_func = classmethod(E.static_func)
  print(E.class_func())  # 输出：Static method（隐含参数cls被忽略，因原方法无参数）
  

2.11. staticmethod()

• 函数定义：@staticmethod（装饰器形式，或 staticmethod(function)）

• 功能说明：将类中的方法转换为静态方法，静态方法无隐含参数（既无 self，也无 cls），与普通函数的行为一致：

  • 调用方式：可通过类（如 C.f()）、实例（如 C().f()）调用，或直接作为类属性引用后调用（如 f = C.f; f()）；
  • 核心作用：用于定义与类相关但无需访问类属性或实例属性的工具方法（如格式验证、数据转换）；
  • 与类方法区别：类方法需接收 cls 参数，可访问类属性；静态方法无参数约束，无法直接访问类/实例属性。

• 使用方式：通常以装饰器 @staticmethod 放在方法定义前，也可直接调用 staticmethod(function) 包装函数。

• 版本变更：Python 3.10：静态方法继承原方法的属性（__module__、__name__ 等），新增 __wrapped__ 属性，且成为与普通函数类似的可调用对象。

• 使用示例：

  # 示例1：基础静态方法（装饰器形式）
  class MathUtils:
      @staticmethod
      def is_even(num):
          # 无隐含参数，仅依赖传入的num
          return num % 2 == 0
      
      @staticmethod
      def add(a, b):
          return a + b
  
  # 通过类调用
  print(MathUtils.is_even(4))  # 输出：True
  print(MathUtils.add(3, 5))   # 输出：8
  
  # 通过实例调用（实例无意义，仅为语法允许）
  mu = MathUtils()
  print(mu.is_even(5))  # 输出：False
  print(mu.add(10, 20)) # 输出：30
  
  # 直接引用并调用（类似普通函数）
  even_checker = MathUtils.is_even
  print(even_checker(6))  # 输出：True
  
  # 示例2：非装饰器形式（包装普通函数）
  def format_date(year, month, day):
      # 普通函数：格式化日期为"YYYY-MM-DD"
      return f"{year:04d}-{month:02d}-{day:02d}"
  
  class DateHelper:
      # 将普通函数包装为静态方法
      format = staticmethod(format_date)
  
  print(DateHelper.format(2024, 5, 3))  # 输出：'2024-05-03'