Python3 operator模块完全指南-平芜编程栈

好的，这是一个关于Python 3中operator模块的全面学习教程。

Python3 operator模块全面学习教程

operator模块提供了Python内置运算符的函数版本。它包含了一系列的函数，这些函数对应于Python中的大多数运算符（如+,-,*,/,==,>等）以及一些常用操作（如属性访问、序列操作）。使用operator模块可以使代码更简洁、更具可读性，特别是在函数式编程（配合map()、filter()、reduce()等）或需要将操作作为参数传递的场景中。

1. 模块导入

import operator

2. 算术运算符函数

这些函数实现了基本的算术运算：

operator.add(a, b): 返回a + b
```
print(operator.add(3, 5)) # 输出: 8
```
operator.sub(a, b): 返回a - b
```
print(operator.sub(10, 4)) # 输出: 6
```
operator.mul(a, b): 返回a * b
```
print(operator.mul(7, 6)) # 输出: 42
```
operator.truediv(a, b): 返回a / b(真除法，结果为浮点数)
```
print(operator.truediv(10, 3)) # 输出: 3.333...
```
operator.floordiv(a, b): 返回a // b(向下取整除法)
```
print(operator.floordiv(10, 3)) # 输出: 3
```
operator.mod(a, b): 返回a % b(取模)
```
print(operator.mod(10, 3)) # 输出: 1
```
operator.pow(a, b): 返回a ** b(幂运算)
```
print(operator.pow(2, 3)) # 输出: 8
```
operator.neg(a): 返回-a(取负)
```
print(operator.neg(7)) # 输出: -7
```
operator.pos(a): 返回+a(取正，通常返回自身)
```
print(operator.pos(-5)) # 输出: -5
```
operator.abs(a): 返回abs(a)(绝对值)
```
print(operator.abs(-10)) # 输出: 10
```

3. 比较运算符函数

这些函数实现了比较运算，通常返回布尔值True或False：

operator.eq(a, b): 返回a == b
```
print(operator.eq(5, 5)) # 输出: True
```
operator.ne(a, b): 返回a != b
```
print(operator.ne(5, 3)) # 输出: True
```
operator.lt(a, b): 返回a < b
```
print(operator.lt(3, 5)) # 输出: True
```
operator.le(a, b): 返回a <= b
```
print(operator.le(3, 3)) # 输出: True
```
operator.gt(a, b): 返回a > b
```
print(operator.gt(5, 3)) # 输出: True
```
operator.ge(a, b): 返回a >= b
```
print(operator.ge(5, 5)) # 输出: True
```

operator.is_(a, b): 返回a is b(对象身份比较)

a = [1, 2]; b = a; c = [1, 2] print(operator.is_(a, b)) # 输出: True print(operator.is_(a, c)) # 输出: False

operator.is_not(a, b): 返回a is not b

print(operator.is_not(a, c)) # 输出: True

4. 逻辑运算符函数

operator.not_(a): 返回not a(逻辑非)

print(operator.not_(True)) # 输出: False

operator.and_(a, b): 返回a and b(逻辑与 - 注意：此函数实际计算的是按位与，逻辑与通常用and关键字)
```
print(operator.and_(True, False)) # 输出: False (按位与结果) # 注意：逻辑与效果通常直接用 `and`
```

operator.or_(a, b): 返回a or b(逻辑或 - 同上，此函数是位或)

print(operator.or_(True, False)) # 输出: True (按位或结果) # 注意：逻辑或效果通常直接用 `or`

5. 位运算符函数

这些函数实现了按位运算：

operator.and_(a, b): 返回a & b(按位与)
operator.or_(a, b): 返回a | b(按位或)

operator.xor(a, b): 返回a ^ b(按位异或)

print(operator.xor(0b1100, 0b1010)) # 输出: 0b0110 (即 6)

operator.invert(a): 返回~a(按位取反)

print(operator.invert(5)) # 输出: -6 (因为 ~5 = -6)

operator.lshift(a, b): 返回a << b(左移)

print(operator.lshift(5, 1)) # 输出: 10 (5<<1 = 10)

operator.rshift(a, b): 返回a >> b(右移)

print(operator.rshift(10, 1)) # 输出: 5 (10>>1 = 5)

6. 序列操作函数

这些函数用于处理序列（列表、元组等）：

operator.concat(a, b): 返回a + b(序列连接)

print(operator.concat([1, 2], [3, 4])) # 输出: [1, 2, 3, 4]

operator.contains(a, b): 返回b in a(成员测试)

print(operator.contains([1, 2, 3], 2)) # 输出: True

operator.countOf(a, b): 返回a.count(b)(计算b在a中出现的次数)
```
print(operator.countOf("hello", "l")) # 输出: 2
```
operator.indexOf(a, b): 返回a.index(b)(b在a中首次出现的索引)
```
print(operator.indexOf("hello", "l")) # 输出: 2
```

operator.getitem(a, b): 返回a[b](索引访问)

lst = ['a', 'b', 'c'] print(operator.getitem(lst, 1)) # 输出: 'b'

operator.setitem(a, b, c): 执行a[b] = c(索引赋值)

lst = ['a', 'b', 'c'] operator.setitem(lst, 1, 'x') print(lst) # 输出: ['a', 'x', 'c']

operator.delitem(a, b): 执行del a[b](删除索引项)

lst = ['a', 'b', 'c'] operator.delitem(lst, 1) print(lst) # 输出: ['a', 'c']

operator.length_hint(obj, default=0): 返回len(obj)的估计值（对于迭代器很有用，不一定是精确长度）

7. 对象属性与元素访问

operator.attrgetter(attr): 返回一个可调用对象，该对象从其操作数中获取命名属性attr。如果请求多个属性，则返回一个属性元组。

class Person: def __init__(self, name, age): self.name = name self.age = age p = Person("Alice", 30) get_name = operator.attrgetter('name') print(get_name(p)) # 输出: 'Alice' get_name_age = operator.attrgetter('name', 'age') print(get_name_age(p)) # 输出: ('Alice', 30)

operator.itemgetter(item): 返回一个可调用对象，该对象使用其操作数的__getitem__()方法获取给定索引item处的元素。如果指定了多个索引，则返回一个查找值元组。

data = [('apple', 3), ('banana', 2), ('cherry', 5)] get_second = operator.itemgetter(1) print(get_second(data[0])) # 输出: 3 get_first_and_second = operator.itemgetter(0, 1) print(get_first_and_second(data[1])) # 输出: ('banana', 2)

operator.methodcaller(name, /, *args, **kwargs): 返回一个可调用对象，该对象在其操作数上调用给定方法name。任何额外的位置参数或关键字参数都将传递给方法。

s = "hello world" upper_call = operator.methodcaller('upper') print(upper_call(s)) # 输出: 'HELLO WORLD' split_call = operator.methodcaller('split', ' ') print(split_call(s)) # 输出: ['hello', 'world']

8. 函数式编程应用示例

operator模块的函数非常适合与map(),filter(),reduce()（在Python 3的functools中）等函数式工具结合使用。

使用map()和add进行向量加法:

import operator import functools vec1 = [1, 2, 3] vec2 = [4, 5, 6] sum_vec = list(map(operator.add, vec1, vec2)) print(sum_vec) # 输出: [5, 7, 9]

使用reduce()和mul计算乘积:

numbers = [1, 2, 3, 4, 5] product = functools.reduce(operator.mul, numbers) print(product) # 输出: 120

使用itemgetter进行排序:

students = [('Charlie', 'B', 15), ('Alice', 'A', 20), ('Dave', 'B', 10), ('Bob', 'C', 5)] # 按姓名排序 sorted_by_name = sorted(students, key=operator.itemgetter(0)) print(sorted_by_name) # 输出: [('Alice', 'A', 20), ('Bob', 'C', 5), ('Charlie', 'B', 15), ('Dave', 'B', 10)] # 按年龄排序 (索引2) sorted_by_age = sorted(students, key=operator.itemgetter(2)) print(sorted_by_age) # 输出: [('Bob', 'C', 5), ('Dave', 'B', 10), ('Charlie', 'B', 15), ('Alice', 'A', 20)]