Python 常用方法分类大全
1. 字符串（str）方法 - 字符串对象可以使用
文本处理方法
text = " Hello World, Python 3.10 "
# 去除空白字符
text.strip() # 返回: "Hello World, Python 3.10" - 去除字符串两端的空白字符（空格、换行符、制表符等）
text.lstrip() # 返回: "Hello World, Python 3.10 " - 只去除字符串左端的空白字符
text.rstrip() # 返回: " Hello World, Python 3.10" - 只去除字符串右端的空白字符
# 分割字符串
text.split() # 返回: ['Hello', 'World,', 'Python', '3.10'] - 默认按空白字符分割
text.split(',') # 返回: [' Hello World', ' Python 3.10 '] - 按指定字符分割
text.split(',', 1) # 返回: [' Hello World', ' Python 3.10 '] - 只分割一次，maxsplit=1
# 连接字符串
'-'.join(['a', 'b', 'c']) # 返回: "a-b-c" - 用指定字符串连接列表中的元素
# 其他分割方法
text.partition(',') # 返回: (' Hello World', ',', ' Python 3.10 ') - 将字符串分为三部分（分隔符前、分隔符、分隔符后）
text.rpartition(',') # 从右边开始分割，返回同上例
text.splitlines() # 返回: [' Hello World, Python 3.10 '] - 按行分割，保留行尾换行符
text.splitlines(True) # 返回: [' Hello World, Python 3.10 \n'] - 保留换行符
大小写转换方法
s = "hello world"
s.upper() # 返回: "HELLO WORLD" - 将所有字符转换为大写
s.lower() # 返回: "hello world" - 将所有字符转换为小写
s.title() # 返回: "Hello World" - 将每个单词的首字母大写
s.capitalize() # 返回: "Hello world" - 将字符串的第一个字母大写，其余小写
s.swapcase() # 返回: "HELLO WORLD"（原为小写）或 "hello world"（原为大写）- 交换大小写
s.casefold() # 返回: "hello world" - 更彻底的小写转换，适合比较（如德语ß会转为ss）
查找和替换方法
s = "apple, banana, apple, cherry"
# 查找方法
s.find('apple') # 返回: 0 - 返回子字符串第一次出现的索引，找不到返回-1
s.rfind('apple') # 返回: 14 - 从右边开始查找，返回最后一次出现的索引
s.index('apple') # 返回: 0 - 与find类似，但找不到时会抛出ValueError异常
s.rindex('apple') # 返回: 14 - 从右边开始查找，找不到时抛出ValueError异常
s.count('apple') # 返回: 2 - 统计子字符串出现的次数
# 替换方法
s.replace('apple', 'orange') # 返回: "orange, banana, orange, cherry" - 替换所有匹配项
s.replace('apple', 'orange', 1) # 返回: "orange, banana, apple, cherry" - 只替换第一个匹配项
# 开头和结尾检查
s.startswith('apple') # 返回: True - 检查字符串是否以指定子字符串开头
s.endswith('cherry') # 返回: True - 检查字符串是否以指定子字符串结尾
字符检查方法（返回布尔值）
# 数字检查
"123".isdigit() # 返回: True - 字符串是否只包含数字字符（0-9）
"123".isnumeric() # 返回: True - 字符串是否只包含数字字符（更广泛，包括罗马数字等）
"123".isdecimal() # 返回: True - 字符串是否只包含十进制数字字符
# 字母检查
"hello".isalpha() # 返回: True - 字符串是否只包含字母字符
"hello123".isalnum() # 返回: True - 字符串是否只包含字母和数字字符
# 大小写检查
"hello".islower() # 返回: True - 字符串中所有字母是否都是小写
"HELLO".isupper() # 返回: True - 字符串中所有字母是否都是大写
# 空白字符检查
" ".isspace() # 返回: True - 字符串是否只包含空白字符（空格、换行、制表符等）
# 其他检查
"Hello".isprintable() # 返回: True - 字符串中所有字符是否都是可打印的
"var_name".isidentifier() # 返回: True - 字符串是否是有效的Python标识符
"hello".isascii() # 返回: True - 字符串中所有字符是否都是ASCII字符（0-127）
格式化方法
name = "Alice"
age = 25
# format() 方法
"Name: {}, Age: {}".format(name, age) # 返回: "Name: Alice, Age: 25"
"Name: {1}, Age: {0}".format(age, name) # 返回: "Name: Alice, Age: 25" - 按索引位置
"Name: {name}, Age: {age}".format(name=name, age=age) # 返回: "Name: Alice, Age: 25" - 按关键字
# 对齐和填充
"Hello".center(10) # 返回: " Hello " - 居中对齐，总宽度10
"Hello".center(10, '*') # 返回: "**Hello***" - 居中对齐，用*填充
"Hello".ljust(10) # 返回: "Hello " - 左对齐，总宽度10
"Hello".rjust(10) # 返回: " Hello" - 右对齐，总宽度10
"42".zfill(5) # 返回: "00042" - 左边用0填充到指定宽度
# 制表符处理
"hello\tworld".expandtabs(4) # 返回: "hello world" - 将制表符转换为4个空格
# f-string（Python 3.6+，不是方法但常用）
f"Name: {name}, Age: {age}" # 返回: "Name: Alice, Age: 25"
编码解码方法
s = "你好"
s.encode('utf-8') # 返回: b'\xe4\xbd\xa0\xe5\xa5\xbd' - 将字符串编码为UTF-8字节
s.encode('gbk') # 返回: b'\xc4\xe3\xba\xc3' - 将字符串编码为GBK字节
# 字符映射
trans_table = str.maketrans('abc', '123') # 创建转换表：a→1, b→2, c→3
"abc".translate(trans_table) # 返回: "123" - 根据转换表转换字符
2. 列表（list）方法 - 列表对象可以使用
增加元素方法
fruits = ['apple', 'banana']
fruits.append('orange') # 返回: ['apple', 'banana', 'orange'] - 在列表末尾添加单个元素
fruits.extend(['grape', 'melon']) # 返回: ['apple', 'banana', 'orange', 'grape', 'melon'] - 在列表末尾添加多个元素
fruits.insert(1, 'peach') # 返回: ['apple', 'peach', 'banana', 'orange', 'grape', 'melon'] - 在指定索引位置插入元素
删除元素方法
fruits = ['apple', 'banana', 'apple', 'cherry']
fruits.remove('apple') # 返回: ['banana', 'apple', 'cherry'] - 删除第一个匹配的元素，找不到会报错
popped = fruits.pop() # 返回: 'cherry'，fruits变为['banana', 'apple'] - 删除并返回最后一个元素
popped = fruits.pop(0) # 返回: 'banana'，fruits变为['apple'] - 删除并返回指定索引的元素
fruits.clear() # 返回: [] - 清空列表，删除所有元素
查找和统计方法
numbers = [1, 2, 3, 2, 4, 2]
index = numbers.index(2) # 返回: 1 - 返回元素第一次出现的索引
index = numbers.index(2, 2) # 返回: 3 - 从索引2开始查找元素2
index = numbers.index(2, 2, 4) # 返回: 3 - 在索引2到4之间查找元素2
count = numbers.count(2) # 返回: 3 - 统计元素2出现的次数
排序和反转方法
numbers = [3, 1, 4, 1, 5]
numbers.sort() # 返回: [1, 1, 3, 4, 5] - 原地升序排序，修改原列表
numbers.sort(reverse=True) # 返回: [5, 4, 3, 1, 1] - 原地降序排序
numbers.reverse() # 返回: [5, 4, 3, 1, 1]（如果之前已排序）- 原地反转列表顺序
# sorted()函数（不是列表方法，但常用）
sorted_list = sorted(numbers) # 返回: [1, 1, 3, 4, 5] - 返回新列表，不修改原列表
复制和其他方法
original = [1, 2, [3, 4]]
shallow_copy = original.copy() # 返回: [1, 2, [3, 4]] - 浅拷贝，只拷贝第一层
import copy
deep_copy = copy.deepcopy(original) # 深拷贝，递归拷贝所有嵌套对象
# 列表运算
[1, 2] + [3, 4] # 返回: [1, 2, 3, 4] - 连接两个列表
[1, 2] * 3 # 返回: [1, 2, 1, 2, 1, 2] - 重复列表
3 in [1, 2, 3] # 返回: True - 检查元素是否在列表中
len([1, 2, 3]) # 返回: 3 - 获取列表长度
min([1, 2, 3]) # 返回: 1 - 获取最小值
max([1, 2, 3]) # 返回: 3 - 获取最大值
sum([1, 2, 3]) # 返回: 6 - 求和
# 列表推导式（不是方法但常用）
squares = [x**2 for x in range(5)] # 返回: [0, 1, 4, 9, 16]
even_squares = [x**2 for x in range(10) if x % 2 == 0] # 返回: [0, 4, 16, 36, 64]
3. 字典（dict）方法 - 字典对象可以使用
访问和修改方法
person = {'name': 'Alice', 'age': 25}
# 访问值
name = person['name'] # 返回: 'Alice' - 通过键访问值，键不存在会报错
name = person.get('name') # 返回: 'Alice' - 安全获取，键不存在返回None
name = person.get('gender', 'unknown') # 返回: 'unknown' - 键不存在时返回默认值
# 添加和修改
person['gender'] = 'female' # 添加新键值对: {'name': 'Alice', 'age': 25, 'gender': 'female'}
person['age'] = 26 # 修改已有键的值: {'name': 'Alice', 'age': 26, 'gender': 'female'}
# 安全添加
person.setdefault('city', 'Beijing') # 返回: 'Beijing' - 键不存在时设置默认值并返回
person.setdefault('name', 'Bob') # 返回: 'Alice' - 键已存在时返回原值，不修改
# 批量更新
person.update({'age': 27, 'city': 'Shanghai'}) # 更新多个键值对
删除方法
person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
value = person.pop('age') # 返回: 25，person变为{'name': 'Alice', 'city': 'Beijing'} - 删除指定键并返回值
value = person.pop('gender', 'unknown') # 返回: 'unknown' - 键不存在时返回默认值，不报错
item = person.popitem() # 返回: ('city', 'Beijing')，person变为{'name': 'Alice'} - 删除并返回最后一对键值
del person['name'] # 直接删除键值对，person变为{}
person.clear() # 清空字典: {}
视图方法
person = {'name': 'Alice', 'age': 25}
keys = person.keys() # 返回: dict_keys(['name', 'age']) - 键的视图对象
values = person.values() # 返回: dict_values(['Alice', 25]) - 值的视图对象
items = person.items() # 返回: dict_items([('name', 'Alice'), ('age', 25)]) - 键值对的视图对象
# 视图对象可迭代
for key in person.keys():
print(key) # 输出: name, age
# 转换为列表
list(person.keys()) # 返回: ['name', 'age']
其他字典方法
person = {'name': 'Alice', 'age': 25}
copy_dict = person.copy() # 返回: {'name': 'Alice', 'age': 25} - 浅拷贝字典
# 类方法创建字典
dict.fromkeys(['a', 'b', 'c']) # 返回: {'a': None, 'b': None, 'c': None}
dict.fromkeys(['a', 'b', 'c'], 0) # 返回: {'a': 0, 'b': 0, 'c': 0}
# 检查键是否存在
'name' in person # 返回: True - 检查键是否在字典中
len(person) # 返回: 2 - 获取字典键值对数量
4. 集合（set）方法 - 集合对象可以使用
基本操作方法
s = {1, 2, 3}
s.add(4) # 返回: {1, 2, 3, 4} - 添加元素，如果已存在则不操作
s.remove(2) # 返回: {1, 3, 4} - 删除指定元素，元素不存在会报错
s.discard(5) # 返回: {1, 3, 4} - 删除指定元素，元素不存在不会报错
element = s.pop() # 返回: 1（随机），s变为{3, 4} - 随机删除并返回一个元素
s.clear() # 返回: set() - 清空集合
copy_set = s.copy() # 返回: {3, 4} - 浅拷贝集合
集合运算方法
A = {1, 2, 3}
B = {3, 4, 5}
# 并集运算
A.union(B) # 返回: {1, 2, 3, 4, 5} - 并集，等价于 A | B
A.update(B) # A变为{1, 2, 3, 4, 5} - 原地并集，等价于 A |= B
# 交集运算
A.intersection(B) # 返回: {3} - 交集，等价于 A & B
A.intersection_update(B) # A变为{3} - 原地交集，等价于 A &= B
# 差集运算
A.difference(B) # 返回: {1, 2} - 差集（在A中但不在B中），等价于 A - B
A.difference_update(B) # A变为{1, 2} - 原地差集，等价于 A -= B
# 对称差集运算
A.symmetric_difference(B) # 返回: {1, 2, 4, 5} - 对称差集（在A或B中但不同时在两者中），等价于 A ^ B
A.symmetric_difference_update(B) # A变为{1, 2, 4, 5} - 原地对称差集，等价于 A ^= B
关系判断方法
A = {1, 2}
B = {1, 2, 3}
C = {4, 5}
A.isdisjoint(C) # 返回: True - 判断两个集合是否没有交集
A.issubset(B) # 返回: True - 判断A是否是B的子集，等价于 A <= B
B.issuperset(A) # 返回: True - 判断B是否是A的超集，等价于 B >= A
A < B # 返回: True - 判断A是否是B的真子集
B > A # 返回: True - 判断B是否是A的真超集
5. 元组（tuple）方法 - 元组对象可以使用
t = (1, 2, 3, 2, 4)
count = t.count(2) # 返回: 2 - 统计元素2出现的次数
index = t.index(3) # 返回: 2 - 返回元素3第一次出现的索引
index = t.index(2, 2) # 返回: 3 - 从索引2开始查找元素2
# 元组不可变，没有增删改方法
# t[0] = 10 # 报错: TypeError - 元组不支持赋值操作
6. 文件对象方法 - open()或sys.stdin返回的对象可以使用
读取文件方法
# 打开文件进行读取
with open('example.txt', 'r') as f:
# 读取全部内容
content = f.read() # 返回: 整个文件内容的字符串
content = f.read(100) # 返回: 最多100个字符的内容
# 读取一行
line = f.readline() # 返回: 下一行的字符串（包含换行符）
line = f.readline(50) # 返回: 最多50个字符的下一行
# 读取所有行
lines = f.readlines() # 返回: 包含所有行的列表
lines = f.readlines(1024) # 返回: 大约1024字节的行列表
# 逐行迭代（推荐用于大文件）
for line in f: # 每次迭代返回一行
print(line.strip())
写入文件方法
# 打开文件进行写入
with open('output.txt', 'w') as f:
# 写入字符串
f.write('Hello World\n') # 写入字符串，返回写入的字符数
# 写入多行
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
f.writelines(lines) # 写入字符串列表
# 刷新缓冲区
f.flush() # 立即将缓冲区内容写入磁盘
文件控制方法
with open('example.txt', 'r') as f:
# 获取当前位置
position = f.tell() # 返回: 当前文件指针位置（字节数）
# 移动文件指针
f.seek(0) # 移动到文件开头
f.seek(10) # 移动到第10个字节
f.seek(0, 2) # 移动到文件末尾（第二个参数：0=开头，1=当前位置，2=末尾）
# 截断文件
f.truncate(100) # 将文件截断为100字节大小
# 关闭文件（with语句会自动关闭）
f.close() # 关闭文件，释放资源
文件属性
with open('example.txt', 'r') as f:
print(f.name) # 输出: 'example.txt' - 文件名
print(f.mode) # 输出: 'r' - 打开模式（r=读，w=写，a=追加，rb=二进制读等）
print(f.encoding) # 输出: 'UTF-8'（或系统默认编码）- 文件编码
print(f.closed) # 输出: False - 文件是否已关闭
7. 数字类型方法 - int/float/complex对象可以使用
整数（int）方法
n = 42
n.bit_length() # 返回: 6 - 表示这个整数所需的最小二进制位数（42的二进制是101010，需要6位）
n.to_bytes(2, 'big') # 返回: b'\x00*' - 将整数转换为2个字节的大端序字节串
n.to_bytes(2, 'little') # 返回: b'*\x00' - 将整数转换为2个小端序字节串
int.from_bytes(b'\x00*', 'big') # 返回: 42 - 类方法，从字节串创建整数
n.as_integer_ratio() # 返回: (42, 1) - 返回整数与1的比例（主要用于分数表示）
n.conjugate() # 返回: 42 - 返回复共轭（实数的共轭是自身）
n.real # 返回: 42 - 实部（对于整数就是它本身）
n.imag # 返回: 0 - 虚部（整数没有虚部）
浮点数（float）方法
f = 3.14
f.is_integer() # 返回: False - 检查浮点数是否为整数（3.0.is_integer()返回True）
f.as_integer_ratio() # 返回: (7070651414971679, 2251799813685248) - 返回最简分数表示
f.hex() # 返回: '0x1.91eb851eb851fp+1' - 浮点数的十六进制表示
float.fromhex('0x1.91eb851eb851fp+1') # 返回: 3.14 - 从十六进制字符串创建浮点数
f.real # 返回: 3.14 - 实部
f.imag # 返回: 0.0 - 虚部
f.conjugate() # 返回: 3.14 - 复共轭
8. 字节/字节数组方法 - bytes/bytearray对象可以使用
字节（bytes）方法
b = b'hello world'
# 编码解码
b.decode('utf-8') # 返回: 'hello world' - 将字节解码为字符串
'hello'.encode('utf-8') # 返回: b'hello' - 将字符串编码为字节
# 十六进制表示
b.hex() # 返回: '68656c6c6f20776f726c64' - 字节的十六进制表示
bytes.fromhex('68656c6c6f') # 返回: b'hello' - 从十六进制字符串创建字节
# 查找和统计
b.find(b'world') # 返回: 6 - 查找子字节串的位置
b.count(b'l') # 返回: 3 - 统计子字节串出现的次数
# 分割和连接
b.split(b' ') # 返回: [b'hello', b'world'] - 按空格分割
b' '.join([b'hello', b'world']) # 返回: b'hello world' - 连接字节串
# 开头和结尾检查
b.startswith(b'hello') # 返回: True
b.endswith(b'world') # 返回: True
# 字节数组特有方法（bytes不可变，bytearray可变）
ba = bytearray(b'hello')
ba.append(33) # ba变为: bytearray(b'hello!') - 33是'!'的ASCII码
ba.extend(b' world') # ba变为: bytearray(b'hello! world')
9. 常用内置函数（全局可用）
类型转换函数
int('123') # 返回: 123 - 将字符串或数字转换为整数
int('1010', 2) # 返回: 10 - 将二进制字符串转换为整数
float('3.14') # 返回: 3.14 - 转换为浮点数
str(123) # 返回: '123' - 转换为字符串
bool(1) # 返回: True - 转换为布尔值（非零数字为True）
bool(0) # 返回: False
bool('') # 返回: False - 空字符串为False
bool('hello') # 返回: True - 非空字符串为True
list('abc') # 返回: ['a', 'b', 'c'] - 将可迭代对象转换为列表
tuple([1, 2, 3]) # 返回: (1, 2, 3) - 将可迭代对象转换为元组
dict([('a', 1), ('b', 2)]) # 返回: {'a': 1, 'b': 2} - 将键值对序列转换为字典
set([1, 2, 2, 3]) # 返回: {1, 2, 3} - 将可迭代对象转换为集合
chr(65) # 返回: 'A' - 将Unicode码点转换为字符
ord('A') # 返回: 65 - 将字符转换为Unicode码点
bin(10) # 返回: '0b1010' - 将整数转换为二进制字符串
hex(255) # 返回: '0xff' - 将整数转换为十六进制字符串
oct(8) # 返回: '0o10' - 将整数转换为八进制字符串
数学运算函数
abs(-5) # 返回: 5 - 绝对值
divmod(10, 3) # 返回: (3, 1) - 返回商和余数（10÷3=3余1）
pow(2, 3) # 返回: 8 - 幂运算（2的3次方）
pow(2, 3, 5) # 返回: 3 - 模幂运算（(2³) % 5）
round(3.14159, 2) # 返回: 3.14 - 四舍五入到2位小数
round(3.5) # 返回: 4 - 四舍五入（银行家舍入法：.5向偶数舍入）
sum([1, 2, 3]) # 返回: 6 - 求和
min([3, 1, 4, 1, 5]) # 返回: 1 - 最小值
max([3, 1, 4, 1, 5]) # 返回: 5 - 最大值
对象操作函数
len('hello') # 返回: 5 - 获取长度
len([1, 2, 3]) # 返回: 3
len({'a': 1, 'b': 2}) # 返回: 2
type(123) # 返回: <class 'int'> - 获取对象类型
type('hello') # 返回: <class 'str'>
isinstance(123, int) # 返回: True - 检查对象是否是指定类型
isinstance('hello', (str, int)) # 返回: True - 检查是否是元组中的任一类型
issubclass(bool, int) # 返回: True - 检查一个类是否是另一个类的子类
id('hello') # 返回: 内存地址（如140000000） - 获取对象的唯一标识符
hash('hello') # 返回: 哈希值（如-762302555） - 获取对象的哈希值
callable(print) # 返回: True - 检查对象是否可调用（函数、方法、类等）
callable('hello') # 返回: False - 字符串不可调用
输入输出函数
print('Hello', 'World') # 输出: Hello World - 打印多个对象
print('Hello', 'World', sep=', ') # 输出: Hello, World - 指定分隔符
print('Hello', end=' ') # 输出: Hello （不换行）
print('World') # 输出: World（接在前面的空格后）
name = input('Enter your name: ') # 显示提示并等待用户输入，返回输入的字符串
with open('file.txt', 'r') as f: # 打开文件，返回文件对象
content = f.read()
迭代工具函数
list(range(5)) # 返回: [0, 1, 2, 3, 4] - 生成整数序列
list(range(1, 5)) # 返回: [1, 2, 3, 4] - 从1开始到5（不含）
list(range(1, 10, 2)) # 返回: [1, 3, 5, 7, 9] - 步长为2
list(enumerate(['a', 'b', 'c'])) # 返回: [(0, 'a'), (1, 'b'), (2, 'c')] - 添加索引
list(enumerate(['a', 'b', 'c'], start=1)) # 返回: [(1, 'a'), (2, 'b'), (3, 'c')]
list(zip([1, 2, 3], ['a', 'b', 'c'])) # 返回: [(1, 'a'), (2, 'b'), (3, 'c')] - 并行迭代
list(zip([1, 2], ['a', 'b', 'c'])) # 返回: [(1, 'a'), (2, 'b')] - 以最短的为准
list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4])) # 返回: [2, 4] - 过滤偶数
list(map(lambda x: x**2, [1, 2, 3, 4])) # 返回: [1, 4, 9, 16] - 平方映射
list(reversed([1, 2, 3])) # 返回: [3, 2, 1] - 反转序列
sorted([3, 1, 4, 1, 5]) # 返回: [1, 1, 3, 4, 5] - 排序
sorted([3, 1, 4], reverse=True) # 返回: [4, 3, 1] - 降序排序
sorted(['apple', 'Banana', 'cherry'], key=str.lower) # 返回: ['apple', 'Banana', 'cherry'] - 忽略大小写排序
10. 上下文管理器方法 - 支持with语句的对象可以使用
class MyResource:
def __enter__(self):
"""进入with代码块时调用，返回值会赋给as后面的变量"""
print("获取资源")
return self # 通常返回self
def __exit__(self, exc_type, exc_value, traceback):
"""退出with代码块时调用，处理异常和清理资源"""
print("释放资源")
# 如果返回True，则异常会被抑制，不会继续传播
# 如果返回False或None，异常会继续传播
return False
def do_something(self):
print("执行操作")
# 使用上下文管理器
with MyResource() as resource: # __enter__被调用，返回值赋给resource
resource.do_something() # 执行操作
# 退出with块时，__exit__被自动调用
# 文件对象是内置的上下文管理器
with open('file.txt', 'r') as f:
content = f.read() # 文件会在with块结束后自动关闭
# 这里不需要调用f.close()，文件已自动关闭
方法使用权限总结表
| 方法类别 |
哪些对象可以使用 |
主要用途 |
是否原地操作 |
| 字符串方法 |
str类型对象 |
文本处理、格式化、查找替换 |
否（返回新字符串） |
| 列表方法 |
list类型对象 |
元素增删改查、排序 |
是（修改原列表） |
| 字典方法 |
dict类型对象 |
键值对操作、查询、更新 |
是（修改原字典） |
| 集合方法 |
set类型对象 |
数学集合运算、去重 |
是（修改原集合） |
| 元组方法 |
tuple类型对象 |
查找、统计 |
否（元组不可变） |
| 文件方法 |
文件对象 |
文件读写、指针控制 |
是（改变文件状态） |
| 数字方法 |
int, float, complex |
数值计算、进制转换 |
否（数字不可变） |
| 字节方法 |
bytes, bytearray |
二进制数据处理 |
bytes否，bytearray是 |
| 内置函数 |
所有对象 |
类型转换、数学运算、对象检查 |
视具体函数而定 |
| 上下文管理器 |
实现__enter__和__exit__的对象 |
资源管理、异常处理 |
是（管理资源状态） |