专题：Python标准库精讲系统学习
关键词：Python, 标准库, operator, 运算符, itemgetter, attrgetter, methodcaller, 算术运算, 序列操作
一、operator模块概述
operator模块是Python标准库中一个功能强大但常被忽视的工具模块，它提供了与Python内置运算符一一对应的函数式接口。在函数式编程范式中，我们需要将运算符作为参数传递给高阶函数（如map、filter、sorted、reduce等），而lambda表达式虽然能实现这一需求，但代码可读性和性能往往不如直接使用operator模块的对应函数。
1.1 为什么需要operator模块
在Python中，运算符（如+、-、*、[]）是语法层面的操作，无法直接作为函数参数传递。例如，当我们想对一个列表中的所有元素进行累加时，不能直接将"+"传给reduce函数，而必须写成lambda表达式或将operator.add作为参数。operator模块填补了这一鸿沟，使代码更加简洁高效。
# 不推荐 —— lambda 表达式可读性较差
from functools import reduce
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
# 推荐 —— operator 模块语义清晰
from operator import add
result = reduce(add, [1, 2, 3, 4, 5])
1.2 模块在标准库中的位置
operator模块属于Python标准库中的"函数式编程"工具集，与functools、itertools等模块并列。它不依赖任何外部包，是Python解释器的内置模块，可直接导入使用。该模块中的函数大致可分为六类：算术运算函数、比较运算函数、位运算函数、序列操作函数、便捷获取器以及原地运算函数。
1.3 典型应用场景概览
- 排序与筛选：使用itemgetter作为sorted()的key函数，按字典的某个键或多级键排序
- 数据聚合：结合functools.reduce进行累加、累乘等聚合运算
- ORM与数据访问：使用attrgetter按对象属性排序或取值
- 方法调用：在map中批量调用对象方法
- 操作符重载辅助：在自定义类中快速委托运算符行为
- 批量数据处理：结合itertools进行高效的数据流水线处理
二、算术运算符函数
operator模块提供了一整套与Python内置算术运算符对应的函数，覆盖基本的二元运算、一元运算和原地运算场景。
2.1 二元算术运算
以下函数对应Python中最常用的二元算术运算符，均接受两个参数，返回运算结果。
| 函数 | 运算符 | 说明 | 示例 |
|---|
| add(a, b) | a + b | 加法 | add(10, 5) → 15 |
| sub(a, b) | a - b | 减法 | sub(10, 5) → 5 |
| mul(a, b) | a * b | 乘法 | mul(10, 5) → 50 |
| truediv(a, b) | a / b | 真除法（返回浮点数） | truediv(10, 3) → 3.333... |
| floordiv(a, b) | a // b | 地板除法（返回整数） | floordiv(10, 3) → 3 |
| mod(a, b) | a % b | 取模（取余数） | mod(10, 3) → 1 |
| pow(a, b) | a ** b | 幂运算 | pow(2, 10) → 1024 |
| matmul(a, b) | a @ b | 矩阵乘法（Python 3.5+） | matmul(A, B) → 矩阵积 |
from operator import add, sub, mul, truediv, floordiv, mod, pow
from functools import reduce
# 累加所有元素
total = reduce(add, range(1, 101)) # 5050
# 连乘计算阶乘
factorial_10 = reduce(mul, range(1, 11)) # 3628800
# 批量运算
prices = [29.9, 49.9, 15.0, 88.0]
with_tax = list(map(lambda p: truediv(mul(p, 113), 100), prices))
# 相当于每项乘以1.13（含税价）
# 判断奇偶性
numbers = [10, 15, 22, 37]
is_odd = lambda n: mod(n, 2) == 1
odds = list(filter(is_odd, numbers)) # [15, 37]
2.2 一元算术运算
一元运算函数只接受一个参数，返回运算后的结果。这些函数在处理数值序列时非常有用。
| 函数 | 运算符 | 说明 | 示例 |
|---|
| neg(a) | -a | 取相反数 | neg(5) → -5 |
| pos(a) | +a | 取正数（数值不变） | pos(-5) → -5 |
| abs(a) | abs(a) | 取绝对值 | abs(-5) → 5 |
| inv(a) 或 invert(a) | ~a | 按位取反（等价于 -a-1） | inv(5) → -6 |
from operator import neg, abs as op_abs
# 取反所有数值
values = [1, -2, 3, -4, 5]
negated = list(map(neg, values)) # [-1, 2, -3, 4, -5]
abs_values = list(map(op_abs, values)) # [1, 2, 3, 4, 5]
# 按绝对值排序
sorted_by_abs = sorted(values, key=op_abs) # [1, -2, 3, -4, 5]
2.3 原地运算函数
原地运算函数对应增强赋值运算符（+=、-=等），它们执行运算后将结果赋值给第一个参数（前提是第一个参数是可变的，支持原地修改）。这些函数在处理可变对象（如列表、集合）或需要原地更新变量的场景中特别有用。
| 函数 | 运算符 | 说明 |
|---|
| iadd(a, b) | a += b | 原地加法（列表追加等） |
| isub(a, b) | a -= b | 原地减法 |
| imul(a, b) | a *= b | 原地乘法 |
| itruediv(a, b) | a /= b | 原地真除法 |
| ifloordiv(a, b) | a //= b | 原地地板除法 |
| imod(a, b) | a %= b | 原地取模 |
| ipow(a, b) | a **= b | 原地幂运算 |
| iconcat(a, b) | a += b（序列） | 原地序列拼接 |
from operator import iadd, iconcat
# 列表追加（原地修改）
nums = [1, 2, 3]
iadd(nums, [4, 5, 6])
print(nums) # [1, 2, 3, 4, 5, 6]
# 字符串拼接（注意：字符串是不可变对象，iadd 返回新对象）
s = "hello"
s = iconcat(s, " world")
print(s) # hello world
# reduce 结合 iadd 拼接多个列表
from functools import reduce
lists = [[1, 2], [3, 4], [5, 6]]
flattened = reduce(iadd, lists, [])
print(flattened) # [1, 2, 3, 4, 5, 6]
关键理解：原地运算函数iadd等与普通add函数的区别在于，前者会尝试调用对象的__iadd__方法进行原地修改，而后者总是调用__add__返回新对象。对于可变容器（如list、set），iadd的原地语义可以避免不必要的对象复制，提升性能。
三、比较运算符函数
比较运算符函数对应Python的六种比较运算符，均接受两个参数并返回布尔值。它们在排序、筛选和数据验证等场景中应用广泛。
3.1 基本比较函数
| 函数 | 运算符 | 说明 | 示例 |
|---|
| eq(a, b) | a == b | 等于 | eq(5, 5) → True |
| ne(a, b) | a != b | 不等于 | ne(5, 3) → True |
| lt(a, b) | a < b | 小于 | lt(3, 5) → True |
| le(a, b) | a <= b | 小于等于 | le(5, 5) → True |
| gt(a, b) | a > b | 大于 | gt(5, 3) → True |
| ge(a, b) | a >= b | 大于等于 | ge(5, 5) → True |
from operator import eq, lt, gt, le, ge, ne
# 检查所有元素是否相等
def all_equal(iterable):
from itertools import pairwise
return all(eq(a, b) for a, b in pairwise(iterable))
print(all_equal([1, 1, 1, 1])) # True
print(all_equal([1, 1, 2, 1])) # False
# 筛选出大于阈值的元素
threshold = 50
scores = [35, 72, 88, 43, 91, 67]
passed = list(filter(lambda s: gt(s, threshold), scores))
print(passed) # [72, 88, 91, 67]
# 反向排序（使用 gt 替代 lambda x, y: x > y）
from functools import cmp_to_key
# Python 3 中 sorted 不再支持 cmp，可以使用 cmp_to_key
# 但更简单的做法是直接使用 reverse=True
# 检查序列是否按升序排列
def is_sorted(iterable):
from itertools import pairwise
return all(le(a, b) for a, b in pairwise(iterable))
print(is_sorted([1, 2, 3, 4])) # True
print(is_sorted([1, 3, 2, 4])) # False
3.2 实用比较模式
比较函数可以组合使用，构建更复杂的条件判断逻辑。这在函数式编程管道中尤其便利，避免了lambda的嵌套干扰代码可读性。
from operator import eq, lt, gt
from functools import partial
# 创建偏函数实现"大于某个值"的断言
greater_than_100 = partial(gt, 100) # gt(100, x) → 注意参数顺序：gt(100, x) 等价于 100 > x
# 实际上 gt(100, x) 等价于运算符 100 > x
# 如果想表达 x > 100，应该用 lt(100, x) 或使用偏函数包装
# 更直观的方式：自定义包装
def greater_than(n):
return lambda x: gt(x, n)
above_60 = greater_than(60)
scores = [45, 62, 78, 33, 91, 55]
print(list(filter(above_60, scores))) # [62, 78, 91]
# 数据去重保持顺序（保留首次出现的相等元素）
def unique_stable(iterable, key=lambda x: x):
seen = []
result = []
for item in iterable:
k = key(item)
if not any(eq(k, s) for s in seen):
seen.append(k)
result.append(item)
return result
data = [1, 2, 1, 3, 2, 4, 3]
print(unique_stable(data)) # [1, 2, 3, 4]
性能提示：比较函数是纯Python函数，与直接使用运算符相比有微小的函数调用开销。在性能敏感的内部循环中，直接使用运算符表达式更快。operator模块的优势主要在于程序化的批量操作场景，以及需要将比较操作作为回调参数传递时。
四、位运算与序列操作
operator模块提供了位运算函数和序列操作函数，覆盖了整数二进制操作和容器类型（字符串、列表、元组、字典）的常见操作。
4.1 位运算函数
位运算函数用于整数的二进制位级别操作，在加密算法、权限系统、状态标志和低级数据处理中非常常见。
| 函数 | 运算符 | 说明 | 示例 |
|---|
| and_(a, b) | a & b | 按位与 | and_(5, 3) → 1（0101 & 0011 = 0001） |
| or_(a, b) | a | b | 按位或 | or_(5, 2) → 7（0101 | 0010 = 0111） |
| xor(a, b) | a ^ b | 按位异或 | xor(5, 3) → 6（0101 ^ 0011 = 0110） |
| invert(a) | ~a | 按位取反 | invert(5) → -6（~0101 = 1010，补码表示） |
| lshift(a, b) | a << b | 左移（相当于乘以 2**b） | lshift(3, 2) → 12 |
| rshift(a, b) | a >> b | 右移（相当于整除 2**b） | rshift(12, 2) → 3 |
注意：由于and和or是Python保留关键字，operator模块中对应的按位运算函数使用了下划线后缀（and_、or_）以避免命名冲突。
from operator import and_, or_, xor, invert, lshift, rshift
# 权限系统：位掩码检查
READ = 0b100 # 4
WRITE = 0b010 # 2
EXECUTE = 0b001 # 1
def has_permission(user_perms, required):
return and_(user_perms, required) == required
user = READ | EXECUTE # 0b101（有读取和执行权限）
print(has_permission(user, READ)) # True
print(has_permission(user, WRITE)) # False
# 状态标志切换
flags = 0b0000
flags = or_(flags, 0b0001) # 开启 bit 0
flags = xor(flags, 0b0001) # 切换 bit 0（关闭）
flags = xor(flags, 0b0001) # 切换 bit 0（再次开启）
# 批量位运算
values = [1, 2, 4, 8, 16]
masked = list(map(lambda v: and_(v, 0b10101), values))
print(masked) # [1, 0, 4, 0, 16]
# 颜色通道提取（RGBA）
color = 0xAABBCCDD
alpha = and_(rshift(color, 24), 0xFF) # 0xAA
red = and_(rshift(color, 16), 0xFF) # 0xBB
green = and_(rshift(color, 8), 0xFF) # 0xCC
blue = and_(color, 0xFF) # 0xDD
4.2 序列操作函数
序列操作函数涵盖容器类型（字符串、列表、元组、字典等）的常见操作，包括拼接、包含检查、元素获取和修改等。
| 函数 | 等价操作 | 说明 | 示例 |
|---|
| concat(a, b) | a + b（序列） | 拼接两个序列 | concat([1,2], [3,4]) → [1,2,3,4] |
| contains(a, b) | b in a | 检查 a 是否包含 b | contains([1,2,3], 2) → True |
| countOf(a, b) | a.count(b) | 统计 b 在 a 中出现的次数 | countOf([1,2,2,3], 2) → 2 |
| indexOf(a, b) | a.index(b) | 查找 b 在 a 中的首次位置 | indexOf([1,2,3], 2) → 1 |
| getitem(a, b) | a[b] | 索引或键取值 | getitem(dict(a=1), "a") → 1 |
| setitem(a, b, c) | a[b] = c | 设置索引或键的值 | setitem(lst, 0, 99) |
| delitem(a, b) | del a[b] | 删除索引或键 | delitem(lst, -1) |
| length_hint(a) | len(a)（近似） | 返回对象长度的估计值 | length_hint(range(100)) → 100 |
from operator import concat, contains, countOf, getitem, setitem, delitem
# 批量拼接字符串
words = ["Hello", " ", "World", " from ", "Operator"]
sentence = reduce(concat, words)
print(sentence) # Hello World from Operator
# 筛选包含特定元素的子列表
data_sets = [[1, 2, 3], [4, 5], [6, 7, 8, 9], [10]]
has_5 = lambda lst: contains(lst, 5)
filtered = list(filter(has_5, data_sets))
print(filtered) # [[4, 5]]
# 获取列表中所有字典的某个字段
users = [
{"name": "Alice", "age": 30},
{"name": "Bob", "age": 25},
{"name": "Charlie", "age": 35},
]
names = list(map(lambda u: getitem(u, "name"), users))
print(names) # ['Alice', 'Bob', 'Charlie']
# 嵌套容器取值
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
get_row = lambda r: getitem(matrix, r)
get_col = lambda r, c: getitem(getitem(matrix, r), c)
# 注意：setitem 和 delitem 会原地修改原始对象
nums = [10, 20, 30, 40, 50]
setitem(nums, 1, 25) # nums[1] = 25
delitem(nums, -1) # del nums[-1]
print(nums) # [10, 25, 30, 40]
重要区别：getitem返回指定元素的值而不会修改原容器，属于纯读取操作。setitem和delitem则会原地修改容器对象，属于副作用操作。在函数式编程中应谨慎使用有副作用的函数，确保数据流的可预测性。
五、便捷获取器
operator模块中最常用也最强大的特性之一就是便捷获取器（Getter）系列函数。它们能够高效地从序列、映射或任意对象中提取元素和属性，是替代lambda表达式的绝佳选择。
5.1 itemgetter —— 索引/键获取器
itemgetter接受一个或多个键/索引参数，返回一个可调用对象（callable），该对象被调用时会从传入的容器中提取指定位置的元素。这是operator模块中使用频率最高的函数之一。
from operator import itemgetter
# 单键提取 —— 返回标量值
get_second = itemgetter(1)
print(get_second([10, 20, 30])) # 20
# 多键提取 —— 返回元组
get_first_two = itemgetter(0, 1)
print(get_first_two([10, 20, 30])) # (10, 20)
# 字典键提取
students = [
{"name": "张三", "score": 92, "age": 18},
{"name": "李四", "score": 85, "age": 19},
{"name": "王五", "score": 96, "age": 17},
]
# 按成绩排序
sorted_by_score = sorted(students, key=itemgetter("score"), reverse=True)
for s in sorted_by_score:
print(s["name"], s["score"])
# 王五 96
# 张三 92
# 李四 85
# 提取多个字段
get_info = itemgetter("name", "score")
for student in students:
name, score = get_info(student)
print(f"{name}: {score}")
# 多级排序：先按年龄升序，再按成绩降序
sorted_multi = sorted(students, key=itemgetter("age", "score"))
# 注意：itemgetter 不支持降序，第二个键也是升序
# 如果需要不同方向排序，仍需自定义 key 函数
# 处理嵌套结构：切片取值（注意：itemgetter 不支持 slice 对象作为参数？实际上支持）
from operator import itemgetter
first_three = itemgetter(slice(0, 3))
print(first_three([1, 2, 3, 4, 5])) # (1, 2, 3)
5.2 attrgetter —— 属性获取器
attrgetter根据属性名获取对象的属性值，支持点号分隔的多级属性访问（链式属性提取）。在ORM对象、数据类和命名元组的处理中特别有用。
from operator import attrgetter
from collections import namedtuple
# 定义简单的数据类
class Student:
def __init__(self, name, age, grade):
self.name = name
self.age = age
self.grade = grade
def __repr__(self):
return f"Student({self.name}, {self.age}, {self.grade})"
students = [
Student("Alice", 20, "A"),
Student("Bob", 19, "B"),
Student("Charlie", 21, "A"),
]
# 按年龄排序
sorted_by_age = sorted(students, key=attrgetter("age"))
print(sorted_by_age)
# [Student(Bob, 19, B), Student(Alice, 20, A), Student(Charlie, 21, A)]
# 提取所有名字
names = list(map(attrgetter("name"), students))
print(names) # ['Alice', 'Bob', 'Charlie']
# 多属性排序（先按grade，再按age）
sorted_multi = sorted(students, key=attrgetter("grade", "age"))
print(sorted_multi)
# [Student(Alice, 20, A), Student(Charlie, 21, A), Student(Bob, 19, B)]
# 链式属性访问（点号分隔）
class Address:
def __init__(self, city, street):
self.city = city
self.street = street
class Person:
def __init__(self, name, address):
self.name = name
self.address = address
people = [
Person("Alice", Address("北京", "长安街")),
Person("Bob", Address("上海", "南京路")),
]
get_city = attrgetter("address.city")
cities = list(map(get_city, people))
print(cities) # ['北京', '上海']
# 使用 namedtuple
Point = namedtuple("Point", ["x", "y"])
points = [Point(3, 4), Point(1, 2), Point(5, 1)]
sorted_by_x = sorted(points, key=attrgetter("x"))
print(sorted_by_x) # [Point(x=1, y=2), Point(x=3, y=4), Point(x=5, y=1)]
5.3 methodcaller —— 方法调用器
methodcaller创建一个可调用对象，当被调用时会在目标对象上调用指定的方法（可带参数）。这在批量调用对象方法的场景中非常实用。
from operator import methodcaller
# 批量字符串转换
words = ["hello", "world", "python", "operator"]
uppercased = list(map(methodcaller("upper"), words))
print(uppercased) # ['HELLO', 'WORLD', 'PYTHON', 'OPERATOR']
# 带参数的方法调用
texts = ["a,b,c", "1,2,3", "x,y,z"]
split_lists = list(map(methodcaller("split", ","), texts))
print(split_lists) # [['a', 'b', 'c'], ['1', '2', '3'], ['x', 'y', 'z']]
# 字符串清理
dirty = [" hello ", " world ", " python "]
cleaned = list(map(methodcaller("strip"), dirty))
print(cleaned) # ['hello', 'world', 'python']
# 数字格式化
numbers = [1/3, 1/7, 1/9]
formatted = list(map(methodcaller("__format__", ".4f"), numbers))
print(formatted) # ['0.3333', '0.1429', '0.1111']
# 实际业务场景：批量触发对象的某个状态切换
class Task:
def __init__(self, name):
self.name = name
self.completed = False
def complete(self):
self.completed = True
return f"{self.name} done"
tasks = [Task("A"), Task("B"), Task("C")]
results = list(map(methodcaller("complete"), tasks))
print(results) # ['A done', 'B done', 'C done']
print(tasks[0].completed) # True
5.4 三者的对比与选择
| 函数 | 适用场景 | 等价lambda | 优势 |
|---|
| itemgetter | 从字典、列表、元组等容器中按索引或键取值 | lambda x: x[key] 或 lambda x: (x[k1], x[k2]) | 支持多键提取，性能优于lambda |
| attrgetter | 从对象中按属性名取值，支持链式属性 | lambda x: x.attr 或 lambda x: (x.a1, x.a2) | 支持多属性和链式访问，代码更简洁 |
| methodcaller | 在对象上调用指定方法 | lambda x: x.method(args) | 支持传参，语义清晰 |
性能对比：在CPython中，itemgetter和attrgetter是用C语言实现的，它们的执行速度通常比等价的lambda表达式快10%-30%。在批量数据处理（数万级以上元素）时，使用operator的获取器函数能带来可观的性能提升。
5.5 高级组合用法
将operator的获取器与functools、itertools等模块配合使用，可以构建出强大的数据管道处理流程。
from operator import itemgetter, attrgetter, methodcaller
from functools import partial, reduce
from itertools import groupby
# 示例数据：销售记录
sales = [
{"product": "A", "region": "华东", "amount": 1200},
{"product": "B", "region": "华北", "amount": 800},
{"product": "A", "region": "华北", "amount": 1500},
{"product": "C", "region": "华东", "amount": 600},
{"product": "A", "region": "华东", "amount": 900},
{"product": "B", "region": "华东", "amount": 1100},
]
# 按区域分组并计算总销售额
get_region = itemgetter("region")
get_amount = itemgetter("amount")
sales_sorted = sorted(sales, key=get_region)
region_totals = {}
for region, group in groupby(sales_sorted, key=get_region):
total = reduce(lambda acc, x: acc + get_amount(x), group, 0)
region_totals[region] = total
print(region_totals) # {'华北': 2300, '华东': 2700}
# 提取所有区域的唯一列表
regions = sorted(set(map(get_region, sales)))
print(regions) # ['华北', '华东']
# 复杂的排序需求：按产品分组后提取最高销售额
from itertools import groupby
sales_sorted_by_product = sorted(sales, key=itemgetter("product"))
result = {}
for product, group in groupby(sales_sorted_by_product, key=itemgetter("product")):
amounts = list(map(get_amount, group))
result[product] = max(amounts)
print(result) # {'A': 1500, 'B': 1100, 'C': 600}
六、核心要点总结
operator模块的核心价值：将Python运算符转化为一等函数对象，使运算符能够作为参数传递给高阶函数，提升代码的函数式编程表达能力。
6.1 模块全景图
operator模块的函数可归纳为以下六大类别，覆盖了Python运算符生态的方方面面：
| 类别 | 代表函数 | 典型应用 |
|---|
| 算术运算 | add, sub, mul, truediv, floordiv, mod, pow | reduce做累加/累乘、批量数值转换 |
| 比较运算 | eq, ne, lt, le, gt, ge | 排序key函数、数据验证、自定义比较器 |
| 位运算 | and_, or_, xor, invert, lshift, rshift | 权限掩码、状态标志、颜色通道处理 |
| 序列操作 | concat, contains, countOf, indexOf, getitem | 容器拼接、元素查找、嵌套数据访问 |
| 原地运算 | iadd, isub, iconcat等所有i开头函数 | 列表追加、集合原地更新、原地数值累加 |
| 便捷获取器 | itemgetter, attrgetter, methodcaller | 排序/分组key、对象属性提取、批量方法调用 |
6.2 实战建议
- 优先使用获取器替代lambda：在sorted()、map()、filter()等场景中，能用itemgetter/attrgetter时尽量优先使用，代码更简洁且性能更好。
- 注意命名冲突：and_和or_中的下划线后缀是为了避开Python关键字，使用时不要遗漏。
- 原地运算的副作用：iadd等原地运算函数会修改第一个参数对象，在函数式编程管道中使用时需格外注意。
- 参数顺序与运算符一致：operator函数的参数顺序与运算符的操作数顺序完全一致，例如sub(a, b)等价于a - b而非b - a。
- 与functools配合：operator函数常与partial、reduce等配合使用，形成强大的函数式编程工具链。
- 自定义类支持：operator函数的底层依赖于Python的数据模型特殊方法（__add__、__getitem__等），因此自定义类只要实现了这些方法，就能直接使用operator函数进行操作。
6.3 常见陷阱
from operator import *
# 陷阱1：and_ / or_ 与布尔运算符的区别
# and_(a, b) 做的是按位与（bitwise AND），而非逻辑与（boolean AND）
result = and_(True, False) # 0（等价于 True & False）
# 逻辑与应该使用：True and False
# 陷阱2：参数顺序混淆
# sub(a, b) 等价于 a - b，不要写反
sub(10, 3) # 7
# sub(3, 10) # -7，如果写反了结果完全不同
# 陷阱3：concat 的泛型行为
# concat 对字符串和列表都适用，但返回类型取决于输入类型
concat([1, 2], [3, 4]) # [1, 2, 3, 4]
concat("ab", "cd") # "abcd"
# concat([1, 2], "cd") # TypeError! 类型必须一致
# 陷阱4：methodcaller 与类方法绑定
# methodcaller 不会自动绑定 self，它只是调用对象的方法
class Counter:
def __init__(self, n):
self.n = n
def increment(self, delta=1):
self.n += delta
return self.n
c = Counter(10)
inc = methodcaller("increment", 5)
inc(c) # 正常工作，因为 increment 的 self 会在对象方法查找时自动绑定
# 这等价于 c.increment(5)
# 陷阱5：getitem 对不可变对象
# getitem 本身是只读操作，可以安全用于字符串等不可变对象
getitem("hello", 1) # 'e'
# 但 setitem 和 delitem 不能用于不可变对象
# setitem("hello", 1, "E") # TypeError: 'str' object does not support item assignment
6.4 学习路径与延伸阅读
operator模块虽然包含数十个函数，但核心设计思想非常统一：每个函数都直接对应于一个Python运算符或操作。掌握operator之后，可以沿着以下路径进一步深入学习：
- functools模块：学习partial（偏函数）、reduce（归约）、lru_cache（缓存）等，与operator配合形成完整函数式工具箱。
- itertools模块：掌握无限迭代器、组合生成器、分组工具，与operator获取器共同构建数据管道。
- Python数据模型：深入理解特殊方法（__add__、__getitem__、__call__等），从根本上理解operator的工作机制。
- 函数式编程范式：了解纯函数、不可变性、高阶函数等概念，提升代码的表达力和可靠性。
总结：operator模块是Python函数式编程的基石工具。它以函数的形式封装了所有原生运算符，使得运算符可以像普通函数一样被传递、组合和重用。无论是简单的数值计算，还是复杂的数据处理管道，operator模块都能让代码更加简洁、可读、高效。掌握它是从Python入门到进阶的必经之路。