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 之間執行“富比較”。具體來說，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。請注意，這些函式可以返回任何值，這些值可能或不可能被解釋為布林值。有關富比較的更多資訊，請參閱比較。

邏輯操作通常也適用於所有物件，並支援真值測試、同一性測試和布林操作

operator.not_(obj)

operator.__not__(obj)

返回 not obj 的結果。（請注意，物件例項沒有 __not__() 方法；只有直譯器核心定義此操作。結果受 __bool__() 和 __len__() 方法的影響。）

operator.truth(obj)

如果 obj 為真，則返回 True，否則返回 False。這等價於使用 bool 建構函式。

operator.is_(a, b)

返回 a is b。測試物件同一性。

operator.is_not(a, b)

返回 a is not b。測試物件同一性。

operator.is_none(a)

返回 a is None。測試物件同一性。

在 3.14 版本加入。

operator.is_not_none(a)

返回 a is not None。測試物件同一性。

在 3.14 版本加入。

數學和位運算最為繁多

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__()。

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 為數字時，返回 a * b。

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。

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)

返回測試 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 在索引 b 處的值設定為 c。

operator.length_hint(obj, default=0)

返回物件 obj 的估計長度。首先嚐試返回其實際長度，然後使用 object.__length_hint__() 估計，最後返回預設值。

在 3.4 版本加入。

以下操作適用於可呼叫物件

operator.call(obj, /, *args, **kwargs)

operator.__call__(obj, /, *args, **kwargs)

返回 obj(*args, **kwargs)。

在 3.11 版本中新增。

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)

返回一個可呼叫物件，該物件使用運算元的 __getitem__() 方法從其運算元中獲取 item。如果指定了多個項，則返回一個查詢值元組。例如

• 在 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__() 方法接受的任何型別。字典接受任何可雜湊值。列表、元組和字串接受索引或切片。

>>> 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)
按位或	a | b	or_(a, b)
冪運算	a ** b	pow(a, b)
同一性	a is b	is_(a, b)
同一性	a is not b	is_not(a, b)
同一性	a is None	is_none(a)
同一性	a is not None	is_not_none(a)
索引賦值	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)

原地運算子

許多操作都有“原地”版本。下面列出的函式提供了比通常語法更原始的訪問原地運算子的方式；例如，語句 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 的 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 版本加入。

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。