什么是 operator 模块？

operator 模块是 Python 的一个标准库，它提供了一系列与 Python 内置运算符相对应的函数，它把 , , , >, <, in, is, not 等运算符,封装成了可调用的函数。

核心思想： 将“操作”本身变成一个“对象”（函数），这使得我们可以在一些需要函数作为参数的高级场景中（如高阶函数、回调、函数式编程）更方便地使用运算符的功能。

为什么需要 operator 模块？（使用场景）

直接使用运算符（如 a + b）非常直观，但在某些情况下，使用 operator 模块的函数会带来巨大的便利,主要体现在以下几个方面：

1. 函数式编程和高阶函数： 当你需要将一个操作作为参数传递给另一个函数时，使用函数比使用 lambda 表达式更简洁、更高效、更易读。
   • 对比：
     • 使用 Lambda: map(lambda x: x * 2, my_list)
     • 使用 operator: map(operator.mul, my_list, [2]*len(my_list)) (更复杂的例子见下文)
2. 代码可读性和意图表达： 有时，operator.add(a, b) 比一个匿名的 lambda 函数更能清晰地表达“进行加法操作”的意图。
3. 动态属性访问： operator 模块提供了 attrgetter、itemgetter 和 methodcaller，它们是动态访问对象属性、字典键和方法的利器，比写一长串 getattr 或 obj['key'] 更优雅。
4. 性能优化： 在某些底层实现中，直接调用预定义的 operator 函数可能比执行一个动态生成的 lambda 表达式有轻微的性能优势。

operator 模块的主要功能分类

operator 模块的功能可以大致分为以下几类：

对应 Python 标准运算符的函数

这是 operator 模块最核心的功能，它几乎涵盖了所有 Python 的运算符。

便捷的getter函数

这是 operator 模块非常强大和实用的部分，它们返回的是“函数”,这些函数在被调用时才会真正去获取值。

itemgetter

用于从对象（如字典、列表、元组等）中获取指定项。

import operator
# 从字典中获取值
d = {'name': 'Alice', 'age': 30, 'city': 'New York'}
getter_name = operator.itemgetter('name')
getter_age_city = operator.itemgetter('age', 'city')
print(getter_name(d))          # 输出: Alice
print(getter_age_city(d))      # 输出: (30, 'New York')
# 从列表/元组中获取元素
my_list = [('a', 1), ('b', 2), ('c', 3)]
get_first = operator.itemgetter(0)
get_second = operator.itemgetter(1)
print(list(map(get_first, my_list)))   # 输出: ['a', 'b', 'c']
print(list(map(get_second, my_list)))  # 输出: [1, 2, 3]

attrgetter

用于从对象中获取指定的属性。

import operator
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
p1 = Person('Alice', 30)
p2 = Person('Bob', 25)
getter_name = operator.attrgetter('name')
getter_age = operator.attrgetter('age')
print(getter_name(p1))  # 输出: Alice
print(getter_age(p2))  # 输出: 25
# 也可以获取嵌套属性
class Address:
    def __init__(self, city):
        self.city = city
class PersonWithAddress:
    def __init__(self, name, address):
        self.name = name
        self.address = address
p = PersonWithAddress('Charlie', Address('London'))
getter_city = operator.attrgetter('address.city')
print(getter_city(p))  # 输出: London

methodcaller

用于调用对象的方法,并可以预先绑定参数。

import operator
s = "hello world"
# 调用无参方法
upper_caller = operator.methodcaller('upper')
print(upper_caller(s))  # 输出: HELLO WORLD
# 调用带参方法
find_caller = operator.methodcaller('find', 'world')
print(find_caller(s))  # 输出: 6
# 调用带多个参数的方法
strip_caller = operator.methodcaller('strip', 'h', 'o')
print(strip_caller("hohello worldoh")) # 输出: ell w

实战应用示例

示例1：结合 sorted 和 itemgetter 对复杂数据排序

这是 itemgetter 最经典的用法。

import operator
people = [
    {'name': 'John', 'age': 30, 'city': 'New York'},
    {'name': 'Jane', 'age': 25, 'city': 'London'},
    {'name': 'Dave', 'age': 30, 'city': 'Paris'},
    {'name': 'Emily', 'age': 25, 'city': 'New York'}
]
# 按 'age' 排序
sorted_by_age = sorted(people, key=operator.itemgetter('age'))
print("按年龄排序:")
for p in sorted_by_age:
    print(p)
# 输出:
# {'name': 'Jane', 'age': 25, 'city': 'London'}
# {'name': 'Emily', 'age': 25, 'city': 'New York'}
# {'name': 'John', 'age': 30, 'city': 'New York'}
# {'name': 'Dave', 'age': 30, 'city': 'Paris'}
# 先按 'age' 排序，再按 'name' 排序
sorted_by_age_name = sorted(people, key=operator.itemgetter('age', 'name'))
print("\n先按年龄后按姓名排序:")
for p in sorted_by_age_name:
    print(p)
# 输出:
# {'name': 'Emily', 'age': 25, 'city': 'New York'}
# {'name': 'Jane', 'age': 25, 'city': 'London'}
# {'name': 'Dave', 'age': 30, 'city': 'Paris'}
# {'name': 'John', 'age': 30, 'city': 'New York'}

示例2：结合 map 和 operator 进行列表操作

假设我们有两个列表,需要将它们对应位置的元素相乘。

import operator
list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]
# 使用 lambda
result_lambda = list(map(lambda x, y: x * y, list_a, list_b))
print(f"使用 lambda: {result_lambda}")
# 使用 operator.mul
result_operator = list(map(operator.mul, list_a, list_b))
print(f"使用 operator: {result_operator}")
# 输出:
# 使用 lambda: [10, 40, 90, 160]
# 使用 operator: [10, 40, 90, 160]

在这个例子中，operator.mul 比 lambda x, y: x * y 更直接，因为它明确表达了“乘法”这个意图。

示例3：动态属性访问

假设你有一个类，但你不知道具体要访问哪个属性,这个属性名可能是动态传入的。

import operator
class Config:
    def __init__(self, host, port, user):
        self.host = host
        self.port = port
        self.user = user
config = Config('localhost', 8080, 'admin')
# 假设属性名是动态的
attr_name = 'port' 
# 使用 getattr
port_getattr = getattr(config, attr_name)
print(f"使用 getattr: {port_getattr}")
# 使用 operator.attrgetter
port_getter = operator.attrgetter(attr_name)
print(f"使用 operator.attrgetter: {port_getter(config)}")
# attrgetter 的优势在于可以链式调用
attr_name_nested = 'config.host' # 假设我们有一个嵌套的字符串表示
# getter_nested = operator.attrgetter(attr_name_nested) # 这会报错，因为字符串不是对象
# 正确用法是直接传递属性名链
getter_nested = operator.attrgetter('host') # 从config对象获取host
print(f"使用 operator.attrgetter 获取嵌套属性: {getter_nested(config)}")

operator 模块是 Python 工具箱中一个低调但极其有用的成员，掌握它，特别是 itemgetter 和 attrgetter,能让你在数据处理和函数式编程中如虎添翼。