10.3. operator - 标准运算符作为函数

源代码： Lib / operator.py

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

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

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

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之间执行“丰富比较”。Specifically, lt(a, b) is equivalent to a < b, le(a, b) is equivalent to a <= b, eq(a, b) is equivalent to a == b, ne(a, b) is equivalent to a != b, gt(a, b) is equivalent to a > b and ge(a, b) is equivalent to a >= b. 注意，这些函数可以返回任何值，这些值可以或可以不被解释为布尔值。有关丰富比较的详细信息，请参见Comparisons。

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

operator.not_(obj)
operator.__not__(obj)

返回not obj。（请注意，对象实例没有__not__()方法；只有解释器核定义了此操作。结果受到__bool__()和__len__()方法的影响。）

operator.truth(obj)

如果obj为真，则返回True，否则返回False。这相当于使用bool构造函数。

operator.is_(a, b)

返回a 是 b。测试对象标识。

operator.is_not(a, b)

返回a 是 不是 b。测试对象标识。

数学和按位操作是最多的：

operator.abs(obj)
operator.__abs__(obj)

返回obj的绝对值。

operator.add(a, b)
operator.__add__(a, b)

返回a + b，对于a和b t5 >数字。

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 t5 >数字。

operator.matmul(a, b)
operator.__matmul__(a, b)

返回a @ b。

版本3.5中的新功能。

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 t5>数字。

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。这也被称为“真正的”分裂。

operator.xor(a, b)
operator.__xor__(a, b)

返回a和b的逐位异或。

使用序列（其中一些与映射）的操作包括：

operator.concat(a, b)
operator.__concat__(a, b)

对于a和b返回a + b序列。

operator.contains(a, b)
operator.__contains__(a, b)

返回 t> a中的测试结果b 。注意反向操作数。

operator.countOf(a, b)

返回a中b的出现次数。

operator.delitem(a, b)
operator.__delitem__(a, b)

删除索引b处a的值。

operator.getitem(a, b)
operator.__getitem__(a, b)

返回a在索引b的值。

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的估计长度。首先尝试返回其实际长度，然后使用object.__length_hint__()进行估计，最后返回默认值。

版本3.4中的新功能。

operator模块还定义了用于广义属性和项查找的工具。这些对于使快速字段提取器作为map()，sorted()，itertools.groupby()或其他函数期望一个函数参数。

operator.attrgetter(attr)
operator.attrgetter(*attrs)

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

  • After f = attrgetter('name'), the call f(b) returns b.name.
  • 在f = attrgetter（'name'， 'date'）调用f(b)返回（b.name， b.date）。
  • After f = attrgetter('name.first', 'name.last'), the call f(b) returns (b.name.first, b.name.last).

相当于：

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(*items)

返回使用操作数的__getitem__()方法从其操作数获取项的可调用对象。如果指定了多个项，则返回查找值的元组。例如：

  • 在f = itemgetter（2）之后，调用f(r)返回r[2]。
  • g = itemgetter（2， 5， 3） / t0>，则调用g(r)返回（r [2]， r [5]， r [3]）。

相当于：

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__()方法接受的任何类型。字典接受任何哈希值。列表，元组和字符串接受索引或切片：

>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1,3,5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2,None))('ABCDEFG')
'CDEFG'

使用itemgetter()从元组记录中检索特定字段的示例：

>>> 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...])

返回在其操作数上调用方法name的可调用对象。如果给出了额外的参数和/或关键字参数，它们也将被给予方法。例如：

  • After f = methodcaller('name'), the call f(b) returns b.name().
  • f = methodcaller（'name'， 'foo'， bar = 1 ），则调用f(b)返回（b.name，b.foo， bar = 1）;。

相当于：

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

10.3.1.将运算符映射到函数

此表显示抽象操作如何对应于Python语法中的操作符号以及operator模块中的函数。

操作句法功能
加a + badd（a， b）
串联seq1 + seq2concat（seq1， seq2）
成员测试obj in seq包含（seq， obj）
除a / btruediv（a， b）
整除a // bfloordiv（a， b）
按位与a ＆amp； band_（a， b）
按位异或a ^ bxor（a， b）
按位取反〜 ainvert(a)
按位或a | bor_（a， b）
取幂a ** bpow（a， b）
身份运算a 是 bis_（a， b）
身份运算a 是 不是 bis_not（a， b）
索引分配obj [k] = vsetitem（obj， k， v）
索引删除del obj [k]delitem（obj， k）
索引取值obj[k]getitem（obj， k）
左移a blshift（a， b）
取模a ％ bmod（a， b）
乘a * bmul（a， b）
矩阵乘法a @ bmatmul（a， b）
取负 - aneg(a)
逻辑非不是 anot_(a)
取正+ apos(a)
右移a >＆gt； brshift（a， b）
切片赋值seq [i：j] = 值 setitem（seq， slice（i， j）， values）
删除切片del seq [i：j]delitem（seq， slice（i， j））
切片seq[i:j]getitem（seq， slice（i， j））
取模（同%）s ％ objmod（s， obj）
减a - bsub（a， b）
真相测试objtruth(obj)
小于a blt（a， b）
小于等于a ble（a， b）
等于a == beq（a， b）
不等于a ！= bne（a， b）
大于等于a > = bge（a， b）
大于a > bgt（a， b）

10.3.2。Inplace运算符

许多操作都有“in-place”版本。下面列出的是比通常的语法提供对原位操作符更原始的访问的函数；例如statement x + = y等效于x = operator.iadd（x， y）。Another way to put it is to say that z = operator.iadd(x, y) is equivalent to the compound statement z = x; z += y.

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

对于不可变目标（如字符串，数字和元组），计算更新的值，但不会分配回输入变量：

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

对于可变目标（如列表和字典），inplace方法将执行更新，因此不需要后续分配：

>>> 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) is equivalent to a += b.

operator.iand(a, b)
操作符。 __ iand __ （ a，b ） t5 >

a = iand(a, b) is equivalent to a &= b.

operator.iconcat(a, b)
operator.__iconcat__(a, b)

a = iconcat(a, b) is equivalent to a += b for a and b sequences.

operator.ifloordiv(a, b)
operator.__ifloordiv__(a, b)

a = ifloordiv(a, b) is equivalent to a //= b.

operator.ilshift(a, b)
operator.__ilshift__(a, b)

a = ilshift(a, b) is equivalent to a <<= b.

operator.imod(a, b)
operator.__imod__(a, b)

a = imod(a, b) is equivalent to a %= b.

operator.imul(a, b)
operator.__imul__(a, b)

a = imul(a, b) is equivalent to a *= b.

operator.imatmul(a, b)
operator.__imatmul__(a, b)

a = imatmul(a, b) is equivalent to a @= b.

版本3.5中的新功能。

operator.ior(a, b)
operator.__ior__(a, b)

a = ior(a, b) is equivalent to a |= b.

operator.ipow(a, b)
operator.__ipow__(a, b)

a = ipow(a, b) is equivalent to a **= b.

operator.irshift(a, b)
operator.__irshift__(a, b)

a = irshift(a, b) is equivalent to a >>= b.

operator.isub(a, b)
operator.__isub__(a, b)

a = isub(a, b) is equivalent to a -= b.

operator.itruediv(a, b)
operator.__itruediv__(a, b)

a = itruediv(a, b) is equivalent to a /= b.

operator.ixor(a, b)
operator.__ixor__(a, b)

a = ixor(a, b) is equivalent to a ^= b.