52

我说的是这个模块： http ://docs.python.org/library/operator.html

来自文章：

operator 模块导出一组用 C 实现的函数，对应于 Python 的内在运算符。例如，operator.add(x, y) 等价于表达式 x+y。函数名称是用于特殊类方法的名称；为方便起见，还提供了没有前导和尾随 __ 的变体。

我不确定我是否了解此模块的好处或目的。

4

6 回答 6

45

可能最流行的用法是 operator.itemgetter。给定一个lst元组列表，您可以通过以下方式按第 i 个元素排序：lst.sort(key=operator.itemgetter(i))

当然，您可以通过定义自己的键函数来在没有操作符的情况下做同样的事情，但是操作符模块使它稍微整洁一些。

至于其余的，python 允许一种函数式编程风格，因此它可以出现——例如，Greg 的 reduce 示例。

你可能会争辩说：“当我能做的时候，为什么我需要operator.add：add = lambda x, y: x+y？” 答案是：

  1. operator.add（我认为）稍微快一点。
  2. 它使您或稍后查看代码的其他人更容易理解代码。他们不需要寻找 add 的定义，因为他们知道 operator 模块的作用。
  3. operator.add是可腌制的，而lambda不是。这意味着该函数可以保存到磁盘或在进程之间传递。
于 2009-01-22T03:19:40.963 回答
33

一个例子是reduce()函数的使用：

>>> import operator
>>> a = [2, 3, 4, 5]
>>> reduce(lambda x, y: x + y, a)
14
>>> reduce(operator.add, a)
14
于 2009-01-22T03:15:07.103 回答
6

例如获取列表中成员为元组的列，按列排序：

def item_ope():
    s = ['h', 'e', 'l', 'l', 'o']
    print operator.getitem(s, 1)
    # e
    print operator.itemgetter(1, 4)(s)
    # ('e', 'o')

    inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
    get_count = operator.itemgetter(1)
    print map(get_count, inventory)
    # [3, 2, 5, 1]

    print sorted(inventory, key=get_count)
    # [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

看一个更实际的例子，我们想按键或值对字典进行排序：

def dict_sort_by_value():
    dic_num = {'first': 11, 'second': 2, 'third': 33, 'Fourth': 4}

    # print all the keys
    print dic_num.keys()
    # ['second', 'Fourth', 'third', 'first']

    # sorted by value
    sorted_val = sorted(dic_num.items(), key=operator.itemgetter(1))
    # [('second', 2), ('Fourth', 4), ('first', 11), ('third', 33)]
    print sorted_val

    # sorted by key
    sorted_key = sorted(dic_num.items(), key=operator.itemgetter(0))
    print sorted_key
    # [('Fourth', 4), ('first', 11), ('second', 2), ('third', 33)]

当我们想要获取最大值并且它是列表中的索引时的另一个示例：

def get_max_val_idx():
    lst = [1, 7, 3, 5, 6]
    max_val = max(lst)
    print max_val
    # 7
    max_idx = lst.index(max_val)
    print max_idx
    # 1

    # simplify it by use operator
    index, value = max(enumerate(lst), key=operator.itemgetter(1))
    print index, value
    # 1 7

更多演示如下：

import operator

def cmp_fun():
    a, b = 5, 3
    print operator.le(a, b)
    # False
    print operator.gt(a, b)
    # True


def lst_ope():
    lst = [1, 2, 3]
    print operator.indexOf(lst, 2)
    # 1
    lst1 = [1, 2, 3, 2]
    print operator.countOf(lst1, 2)
    # 2


def cal_ope():
    lst1 = [0, 1, 2, 3]
    lst2 = [10, 20, 30, 40]
    print map(operator.mul, lst1, lst2)
    # [0, 20, 60, 120]

    print sum(map(operator.mul, lst1, lst2))
    # 200

    a, b = 1, 3
    print operator.iadd(a, b)
    # 4

从python 文档中查看更多信息

于 2017-11-16T02:53:05.543 回答
5

当您需要将函数作为参数传递给某物时，该模块很有用。然后有两个选项：使用operator模块，或定义一个新函数（使用def或lambda）。如果你动态定义一个函数，如果你需要pickle这个函数，或者将它保存到磁盘或在进程之间传递它，这可能会产生问题。虽然itemgetter是可腌制的，但动态定义的函数（带有def或lambda）不是。在以下示例中，用表达式替换itemgetter将lambda导致PicklingError.

from operator import itemgetter

def sort_by_key(sequence, key):
    return sorted(sequence, key=key)

if __name__ == "__main__":
    from multiprocessing import Pool

    items = [([(1,2),(4,1)], itemgetter(1)),
             ([(5,3),(2,7)], itemgetter(0))]

    with Pool(5) as p:
        result = p.starmap(sort_by_key, items)
    print(result)
于 2017-07-01T10:58:31.157 回答
3

一般来说，这个模块的目的（正如上面的一些答案所暗示的）是为您提供罐头函数，用于简单的操作，否则您必须自己编写并传递给高阶函数，例如sort()or reduce()。

例如，如果没有运算符，要对列表中的数字求和，您必须执行以下操作：

from functools import reduce

l = list(range(100))
f = lambda x, y: x + y
result = reduce(f, l)
print(result)

使用 operator 模块，您可以add()像这样使用它的功能：

from operator import add

result = reduce(add, l)
print(result)

从而避免了创建 lambda 表达式的需要。

于 2018-07-21T18:53:13.823 回答
0

我不记得确切的用例，但我在某个地方有一个需要动态进行一些计算的需求，这可能会使用不同的运算符，具体取决于它的来源。

一个非常简单的例子是这样的：

import operator

def add_or_subtract(x, y, op):
    return op(x, y)

x = 3
y = 10
o = operator.add #operator.sub

add_or_subtract(x, y, o)
于 2020-12-18T09:23:33.127 回答