Python 常用方法分类大全
1. 字符串（str）方法 - 字符串对象可以使用
文本处理方法
python
复制代码
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'] - 保留换行符
大小写转换方法
python
复制代码
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）
查找和替换方法
python
复制代码
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 - 检查字符串是否以指定子字符串结尾
字符检查方法（返回布尔值）
python
复制代码
# 数字检查
"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）
格式化方法
python
复制代码
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"
编码解码方法
python
复制代码
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）方法 - 列表对象可以使用
增加元素方法
python
复制代码
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'] - 在指定索引位置插入元素
删除元素方法
python
复制代码
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() # 返回: [] - 清空列表，删除所有元素
查找和统计方法
python
复制代码
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出现的次数
排序和反转方法
python
复制代码
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] - 返回新列表，不修改原列表
复制和其他方法
python
复制代码
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）方法 - 字典对象可以使用
访问和修改方法
python
复制代码
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'}) # 更新多个键值对
删除方法
python
复制代码
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() # 清空字典: {}
视图方法
python
复制代码
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']
其他字典方法
python
复制代码
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）方法 - 集合对象可以使用
基本操作方法
python
复制代码
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} - 浅拷贝集合
集合运算方法
python
复制代码
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
关系判断方法
python
复制代码
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）方法 - 元组对象可以使用
python
复制代码
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返回的对象可以使用
读取文件方法
python
复制代码
# 打开文件进行读取
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())
写入文件方法
python
复制代码
# 打开文件进行写入
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() # 立即将缓冲区内容写入磁盘
文件控制方法
python
复制代码
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() # 关闭文件，释放资源
文件属性
python
复制代码
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）方法
python
复制代码
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）方法
python
复制代码
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）方法
python
复制代码
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. 常用内置函数（全局可用）
类型转换函数
python
复制代码
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' - 将整数转换为八进制字符串
数学运算函数
python
复制代码
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 - 最大值
对象操作函数
python
复制代码
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 - 字符串不可调用
输入输出函数
python
复制代码
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()
迭代工具函数
python
复制代码
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语句的对象可以使用
python
复制代码
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__的对象
资源管理、异常处理
是（管理资源状态）