运算符-标准运算符作为函数

源代码： Lib/operator.py

---

operator模块导出一组与 Python 的固有运算符相对应的有效函数。例如，operator.add(x, y)等效于表达式x+y。许多函数名称是用于特殊方法的名称，没有双下划线。为了向后兼容，其中许多具有保留双下划线的变体。为了清楚起见，不带双下划线的变体是首选。

这些函数分为执行对象比较，逻辑运算，math 运算和序列运算的类别。

对象比较Function对所有对象都有用，并以它们支持的丰富比较运算符命名：

• operator. lt(* a ， b *)
• operator. le(* a ， b *)
• operator. eq(* a ， b *)
• operator. ne(* a ， b *)
• operator. ge(* a ， b *)
• operator. gt(* a ， b *)
• operator. __lt__(* a ， b *)
• operator. __le__(* a ， b *)
• operator. __eq__(* a ， b *)
• operator. __ne__(* a ， b *)
• operator. __ge__(* a ， b *)
• operator. __gt__(* a ， b *)
  • 在* a 和 b *之间执行“丰富比较”。具体而言，lt(a, b)等效于a < b，le(a, b)等效于a <= b，eq(a, b)等效于a == b，ne(a, b)等效于a != b，gt(a, b)等效于a > b，ge(a, b)等效于a >= b。请注意，这些函数可以返回任何值，该值可以或可以不解释为布尔值。有关丰富比较的更多信息，请参见Comparisons。

逻辑运算通常也适用于所有对象，并支持真值测试，身份测试和布尔运算：

• operator. not_(* obj *)

• operator. __not__(* obj *)

  • 返回not * obj *的结果。 (请注意，对象实例没有not()方法；只有解释器内核定义了此操作。结果受bool()和len()方法的影响。)

• operator. truth(* obj *)

  • 如果 obj *为 true，则返回True，否则返回False。这等效于使用bool构造函数。

• operator. is_(* a ， b *)

  • 返回a is b。测试对象身份。

• operator. is_not(* a ， b *)

  • 返回a is not b。测试对象身份。

math 和按位运算是最多的：

• operator. abs(* obj *)

• operator. __abs__(* obj *)

  • 返回* obj *的绝对值。

• operator. add(* a ， b *)

• operator. __add__(* a ， b *)

  • 返回a + b，以获得* a 和 b *数字。

• operator. and_(* a ， b *)

• operator. __and__(* a ， b *)

  • 返回* a 和 b *的按位与。

• operator. floordiv(* a ， b *)

• operator. __floordiv__(* a ， b *)

  • 返回a // b。

• operator. index(* a *)

• operator. __index__(* a *)

  • 返回* a *转换为整数。等效于a.__index__()。

• operator. inv(* obj *)

• operator. invert(* obj *)

• operator. __inv__(* obj *)

• operator. __invert__(* obj *)

  • 返回数字* obj *的按位倒数。这等效于~obj。

• operator. lshift(* a ， b *)

• operator. __lshift__(* a ， b *)

  • 返回* a 向左移动 b *。

• operator. mod(* a ， b *)

• operator. __mod__(* a ， b *)

  • 返回a % b。

• operator. mul(* a ， b *)

• operator. __mul__(* a ， b *)

  • 返回a * b，以获得* a 和 b *数字。

• operator. matmul(* a ， b *)

• operator. __matmul__(* a ， b *)

  • 返回a @ b。

3.5 版中的新Function。

• operator. neg(* obj *)

• operator. __neg__(* obj *)

  • 返回* obj *否定(-obj)。

• operator. or_(* a ， b *)

• operator. __or__(* a ， b *)

  • 返回* a 和 b *的按位或。

• operator. pos(* obj *)

• operator. __pos__(* obj *)

  • 返回* obj *正(+obj)。

• operator. pow(* a ， b *)

• operator. __pow__(* a ， b *)

  • 返回a ** b，以获得* a 和 b *数字。

• operator. rshift(* a ， b *)

• operator. __rshift__(* a ， b *)

  • 返回* a 向右移动 b *。

• operator. sub(* a ， b *)

• operator. __sub__(* a ， b *)

  • 返回a - b。

• operator. truediv(* a ， b *)

• operator. __truediv__(* a ， b *)

  • 返回a / b，其中 2/3 是.66 而不是 0.这也称为“ true”除法。

• operator. xor(* a ， b *)

• operator. __xor__(* a ， b *)

  • 返回* a 和 b *的按位异或。

适用于序列的操作(其中一些也适用于 Map)包括：

• operator. concat(* a ， b *)

• operator. __concat__(* a ， b *)

  • 为** a 和 b *序列返回a + b。

• operator. contains(* a ， b *)

• operator. __contains__(* a ， b *)

  • 返回测试结果b in a。注意相反的操作数。

• operator. countOf(* a ， b *)

  • 返回* a 中 b *的出现次数。

• operator. delitem(* a ， b *)

• operator. __delitem__(* a ， b *)

  • 删除索引* b 处的 a *值。

• operator. getitem(* a ， b *)

• operator. __getitem__(* a ， b *)

  • 在索引* b 处返回 a *的值。

• operator. indexOf(* a ， b *)

  • 返回* a 中第一次出现 b *的索引。

• operator. setitem(* a ， b ， c *)

• operator. __setitem__(* a ， b ， c *)

  • 将索引* b 处的 a 值设置为 c *。

• operator. length_hint(* obj ， default = 0 *)

  • 返回对象* o *的估计长度。首先try返回其实际长度，然后使用object.length_hint()进行估算，最后返回默认值。

3.4 版的新Function。

operator模块还定义了用于通用属性和项目查找的工具。这些对于将快速字段提取器用作map()，sorted()，itertools.groupby()或需要函数参数的其他函数的参数很有用。

• operator. attrgetter(* attr *)

• operator. attrgetter(“ **” *)

  • 返回从其操作数获取* attr *的可调用对象。如果请求多个属性，则返回一个 Tuples。属性名称也可以包含点。例如：

• 在f = attrgetter('name')之后，呼叫f(b)返回b.name。

• 在f = attrgetter('name', 'date')之后，呼叫f(b)返回(b.name, b.date)。

• 在f = attrgetter('name.first', 'name.last')之后，呼叫f(b)返回(b.name.first, b.name.last)。

Equivalent to:

def attrgetter(*items):
    if any(not isinstance(item, str) for item in items):
        raise TypeError('attribute name must be a string')
    if len(items) == 1:
        attr = items[0]
        def g(obj):
            return resolve_attr(obj, attr)
    else:
        def g(obj):
            return tuple(resolve_attr(obj, attr) for attr in items)
    return g

def resolve_attr(obj, attr):
    for name in attr.split("."):
        obj = getattr(obj, name)
    return obj

• operator. itemgetter(* item *)

• operator. itemgetter(*个)

  • 返回使用操作数的getitem()方法从其操作数中获取* item *的可调用对象。如果指定了多个项目，则返回查找值的 Tuples。例如：

• 在f = itemgetter(2)之后，呼叫f(r)返回r[2]。

• 在g = itemgetter(2, 5, 3)之后，呼叫g(r)返回(r[2], r[5], r[3])。

Equivalent to:

def itemgetter(*items):
    if len(items) == 1:
        item = items[0]
        def g(obj):
            return obj[item]
    else:
        def g(obj):
            return tuple(obj[item] for item in items)
    return g

这些项目可以是操作数的getitem()方法接受的任何类型。字典接受任何可哈希值。列表，Tuples 和字符串接受索引或切片：

>>> itemgetter('name')({'name': 'tu', 'age': 18})
'tu'
>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1,3,5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2,None))('ABCDEFG')
'CDEFG'

>>> soldier = dict(rank='captain', name='dotterbart')
>>> itemgetter('rank')(soldier)
'captain'

使用itemgetter()从 TuplesLogging 检索特定字段的示例：

>>> inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
>>> getcount = itemgetter(1)
>>> list(map(getcount, inventory))
[3, 2, 5, 1]
>>> sorted(inventory, key=getcount)
[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

• operator. methodcaller(* name ，/*， *args ， * kwargs *)

  • 返回一个可调用对象，该对象在其操作数上调用方法* name *。如果给出了其他参数和/或关键字参数，它们也将被赋予方法。例如：

• 在f = methodcaller('name')之后，呼叫f(b)返回b.name()。

• 在f = methodcaller('name', 'foo', bar=1)之后，呼叫f(b)返回b.name('foo', bar=1)。

Equivalent to:

def methodcaller(name, /, *args, **kwargs):
    def caller(obj):
        return getattr(obj, name)(*args, **kwargs)
    return caller

将运算符 Map 到函数

下表显示了抽象运算如何与 Python 语法中的运算符和operator模块中的函数相对应。

In-place Operators

许多操作都有“就地”版本。下面列出的函数比通常的语法提供对原始操作符的更多原始访问；例如statement x += y等效于x = operator.iadd(x, y)。换句话说，z = operator.iadd(x, y)等效于复合语句z = x; z += y。

在这些示例中，请注意，当调用就地方法时，计算和分配是在两个单独的步骤中执行的。下面列出的就地函数仅执行第一步，即调用就地方法。第二步，分配，不处理。

对于不可变的目标(例如字符串，数字和 Tuples)，将计算更新后的值，但不会将其分配回 Importing 变量：

>>> a = 'hello'
>>> iadd(a, ' world')
'hello world'
>>> a
'hello'

对于诸如列表和字典之类的可变目标，就地方法将执行更新，因此不需要后续分配：

>>> s = ['h', 'e', 'l', 'l', 'o']
>>> iadd(s, [' ', 'w', 'o', 'r', 'l', 'd'])
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> s
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

• operator. iadd(* a ， b *)

• operator. __iadd__(* a ， b *)

  • a = iadd(a, b)等效于a += b。

• operator. iand(* a ， b *)

• operator. __iand__(* a ， b *)

  • a = iand(a, b)等效于a &= b。

• operator. iconcat(* a ， b *)

• operator. __iconcat__(* a ， b *)

  • 对于* a 和 b *序列，a = iconcat(a, b)等效于a += b。

• operator. ifloordiv(* a ， b *)

• operator. __ifloordiv__(* a ， b *)

  • a = ifloordiv(a, b)等效于a //= b。

• operator. ilshift(* a ， b *)

• operator. __ilshift__(* a ， b *)

  • a = ilshift(a, b)等效于a <<= b。

• operator. imod(* a ， b *)

• operator. __imod__(* a ， b *)

  • a = imod(a, b)等效于a %= b。

• operator. imul(* a ， b *)

• operator. __imul__(* a ， b *)

  • a = imul(a, b)等效于a *= b。

• operator. imatmul(* a ， b *)

• operator. __imatmul__(* a ， b *)

  • a = imatmul(a, b)等效于a @= b。

3.5 版中的新Function。

• operator. ior(* a ， b *)

• operator. __ior__(* a ， b *)

  • a = ior(a, b)等效于a |= b。

• operator. ipow(* a ， b *)

• operator. __ipow__(* a ， b *)

  • a = ipow(a, b)等效于a **= b。

• operator. irshift(* a ， b *)

• operator. __irshift__(* a ， b *)

  • a = irshift(a, b)等效于a >>= b。

• operator. isub(* a ， b *)

• operator. __isub__(* a ， b *)

  • a = isub(a, b)等效于a -= b。

• operator. itruediv(* a ， b *)

• operator. __itruediv__(* a ， b *)

  • a = itruediv(a, b)等效于a /= b。

• operator. ixor(* a ， b *)

• operator. __ixor__(* a ， b *)

  • a = ixor(a, b)等效于a ^= b。