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)

ab . 明确地, lt(a, b) 等于 a < ble(a, b) 等于 a <= beq(a, b) 等于 a == bne(a, b) 等于 a != bgt(a, b) 等于 a > bge(a, b) 等于 a >= b . 请注意,这些函数可以返回任何值,这些值可以解释为布尔值,也可以不解释为布尔值。见 比较 有关丰富比较的更多信息。

逻辑操作通常也适用于所有对象,并支持真值测试、身份测试和布尔操作:

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

返回的结果 not obj . (注意没有 __not__() 对象实例的方法;只有解释器核心定义此操作。结果受 __bool__()__len__() 方法。

operator.truth(obj)

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

operator.is_(a, b)

返回 a is b . 测试对象标识。

operator.is_not(a, b)

返回 a is not b . 测试对象标识。

数学运算和位运算是最多的:

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

返回的绝对值 obj .

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

返回 a + b ,为了 ab 数字。

operator.and_(a, b)
operator.__and__(a, b)

返回的位与 ab .

operator.floordiv(a, b)
operator.__floordiv__(a, b)

返回 a // b .

operator.index(a)
operator.__index__(a)

返回 a 已转换为整数。相当于 a.__index__() .

在 3.10 版更改: 结果总是具有精确的类型 int . 以前,结果可能是 int .

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 ,为了 ab 数字。

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)

返回的位或 ab .

operator.pos(obj)
operator.__pos__(obj)

返回 obj 积极的 (+obj

operator.pow(a, b)
operator.__pow__(a, b)

返回 a ** b ,为了 ab 数字。

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)

返回的按位异或 ab .

处理序列的操作(其中一些还带有映射)包括:

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

返回 a + b 对于 ab 序列。

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

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

operator.countOf(a, b)

返回出现的次数 b 在里面 a .

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

删除的值 a 在索引 b .

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

返回的值 a 在索引 b .

operator.indexOf(a, b)

返回第一次出现的索引 b 在里面 a .

operator.setitem(a, b, c)
operator.__setitem__(a, b, c)

设置的值 a 在索引 bc .

operator.length_hint(obj, default=0)

返回对象的估计长度 o . 首先尝试返回其实际长度,然后使用 object.__length_hint__() ,最后返回默认值。

3.4 新版功能.

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

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

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

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

等同于:

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)

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

  • f = itemgetter(2) 调用 f(r) 返回 r[2] .

  • g = itemgetter(2, 5, 3) 调用 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__() 方法。字典接受任何hash值。列表、元组和字符串接受索引或切片:

>>> 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() 要从元组记录中检索特定字段,请执行以下操作:

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

等同于:

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

将运算符映射到函数

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

操作

句法

功能

加法

a + b

add(a, b)

级联

seq1 + seq2

concat(seq1, seq2)

安全壳试验

obj in seq

contains(seq, obj)

除法

a / b

truediv(a, b)

除法

a // b

floordiv(a, b)

按位与

a & b

and_(a, b)

位异或

a ^ b

xor(a, b)

位反转

~ a

invert(a)

Bitwise或

a | b

or_(a, b)

求幂

a ** b

pow(a, b)

身份

a is b

is_(a, b)

身份

a is not b

is_not(a, b)

索引分配

obj[k] = v

setitem(obj, k, v)

索引删除

del obj[k]

delitem(obj, k)

索引

obj[k]

getitem(obj, k)

左移

a << b

lshift(a, b)

a % b

mod(a, b)

乘法

a * b

mul(a, b)

矩阵乘法

a @ b

matmul(a, b)

否定(算术)

- a

neg(a)

否定(逻辑)

not a

not_(a)

积极的

+ a

pos(a)

右移

a >> b

rshift(a, b)

切片分配

seq[i:j] = values

setitem(seq, slice(i, j), values)

切片删除

del seq[i:j]

delitem(seq, slice(i, j))

切片

seq[i:j]

getitem(seq, slice(i, j))

字符串格式化

s % obj

mod(s, obj)

减法

a - b

sub(a, b)

真值检验

obj

truth(obj)

排序

a < b

lt(a, b)

排序

a <= b

le(a, b)

平等

a == b

eq(a, b)

差异

a != b

ne(a, b)

排序

a >= b

ge(a, b)

排序

a > b

gt(a, b)

原位操作

许多操作都有一个“就地”版本。下面列出的函数提供了比常规语法更原始的对就地运算符的访问;例如, statement x += y 等于 x = operator.iadd(x, y) . 另一种说法是 z = operator.iadd(x, y) 等价于复合语句 z = x; z += y .

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

对于字符串、数字和元组等不可变目标,将计算更新后的值,但不将其分配回输入变量:

>>> 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 = iconcat(a, b) 等于 a += b 对于 ab 序列。

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 新版功能.

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 .