python3教程：Operator模塊

Operator——標准功能性操作符接口.

代碼中使用迭代器時,有時必須要為一個簡單表達式創建函數。有些情況這些函數可以用一個lambda函數實現，但是對於某些操作，根本沒必要去寫一個新的函數。因此operator模塊定義了一些函數，這些函數對應於算術、比較和其他與標准對象API對應的操作。

1.邏輯操作符(Logical Operations)

下面函數用於確定一個值的布爾等價值，或者否定它創建相反的布爾值，或比較對象確定它們是否相同。

from operator import *
a = -1
b = 5
print('a =', a)
print('b =', b)
print()
print('not_(a) :', not_(a))
print('truth(a) :', truth(a))
print('is_(a, b) :', is_(a, b))
print('is_not(a, b):', is_not(a, b))

not_()後面有一個下劃線，是因為not是Python關鍵字。true()使用的邏輯和if語句加表達式或將表達式轉換為bool.is_()時相同的邏輯。is_()實現的是使用is關鍵字相同的檢查，is_not()也執行相同的檢查但返回相反的結果。

a = -1
b = 5
not_(a) : False
truth(a) : True
is_(a, b) : False
is_not(a, b): True

2.比較操作符(Comparison Operators)

它支持所有富比較操作符：

from operator import *
a = 1
b = 5.0
print('a =', a)
print('b =', b)
for func in (lt, le, eq, ne, ge, gt):
print('{}(a, b): {}'.format(func.__name__, func(a, b)))

這些函數等價於使用<、<=、==、>=和>的表達式語法。

a = 1
b = 5.0
lt(a, b): True
le(a, b): True
eq(a, b): False
ne(a, b): True
ge(a, b): False
gt(a, b): False

3.算術操作符(Arithmetic Operators)

它還支持用於操作數值的算術運算符：

from operator import *
a = -1
b = 5.0
c = 2
d = 6
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)
print('\n正數/負數:')
print('abs(a):', abs(a))
print('neg(a):', neg(a))
print('neg(b):', neg(b))
print('pos(a):', pos(a))
print('pos(b):', pos(b))
print('\n算術:')
print('add(a, b) :', add(a, b))
print('floordiv(a, b):', floordiv(a, b))
print('floordiv(d, c):', floordiv(d, c))
print('mod(a, b) :', mod(a, b))
print('mul(a, b) :', mul(a, b))
print('pow(c, d) :', pow(c, d))
print('sub(b, a) :', sub(b, a))
print('truediv(a, b) :', truediv(a, b))
print('truediv(d, c) :', truediv(d, c))
print('\n按位:')
print('and_(c, d) :', and_(c, d))
print('invert(c) :', invert(c))
print('lshift(c, d):', lshift(c, d))
print('or_(c, d) :', or_(c, d))
print('rshift(d, c):', rshift(d, c))
print('xor(c, d) :', xor(c, d))

有兩種除法運算符:floordiv()(在3.0版本之前Python中實現的整數除法)和truediv()(浮點除法)。

a = -1
b = 5.0
c = 2
d = 6
正數/負數:
abs(a): 1
neg(a): 1
neg(b): -5.0
pos(a): -1
pos(b): 5.0
算術:
add(a, b) : 4.0
floordiv(a, b): -1.0
floordiv(d, c): 3
mod(a, b) : 4.0
mul(a, b) : -5.0
pow(c, d) : 64
sub(b, a) : 6.0
truediv(a, b) : -0.2
truediv(d, c) : 3.0
按位:
and_(c, d) : 2
invert(c) : -3
lshift(c, d): 128
or_(c, d) : 6
rshift(d, c): 1
xor(c, d) : 4

4.序列操作符(Sequence Operators)

處理序列的操作符可以分為四種:構建序列、搜索條目、訪問內容和從序列中刪除條目:

from operator import *
a = [1, 2, 3]
b = ['a', 'b', 'c']
print('a =', a)
print('b =', b)
print('\n構建序列:')
print(' concat(a, b):', concat(a, b))
print('\n搜索:')
print(' contains(a, 1) :', contains(a, 1))
print(' contains(b, "d"):', contains(b, "d"))
print(' countOf(a, 1) :', countOf(a, 1))
print(' countOf(b, "d") :', countOf(b, "d"))
print(' indexOf(a, 5) :', indexOf(a, 1))
print('\n訪問:')
print(' getitem(b, 1) :',
getitem(b, 1))
print(' getitem(b, slice(1, 3)) :',
getitem(b, slice(1, 3)))
print(' setitem(b, 1, "d") :', end=' ')
setitem(b, 1, "d")
print(b)
print(' setitem(a, slice(1, 3), [4, 5]):', end=' ')
setitem(a, slice(1, 3), [4, 5])
print(a)
print('\n刪除:')
print(' delitem(b, 1) :', end=' ')
delitem(b, 1)
print(b)
print(' delitem(a, slice(1, 3)):', end=' ')
delitem(a, slice(1, 3))
print(a)

其中一些操作，如setitem()和delitem()，修改序列時屬於原地操作，不返回值。

a = [1, 2, 3]
b = ['a', 'b', 'c']
構建序列:
concat(a, b): [1, 2, 3, 'a', 'b', 'c']
搜索:
contains(a, 1) : True
contains(b, "d"): False
countOf(a, 1) : 1
countOf(b, "d") : 0
indexOf(a, 5) : 0
訪問:
getitem(b, 1) : b
getitem(b, slice(1, 3)) : ['b', 'c']
setitem(b, 1, "d") : ['a', 'd', 'c']
setitem(a, slice(1, 3), [4, 5]): [1, 4, 5]
刪除:
delitem(b, 1) : ['a', 'c']
delitem(a, slice(1, 3)): [1]

5.原地操作符(In-place Operators)

除了標准操作符之外，許多對象類型還支持通過特殊操作符(如+=)"原地"修改。原地操作符也有相同的功能:

from operator import *
a = -1
b = 5.0
c = [1, 2, 3]
d = ['a', 'b', 'c']
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)
print()
iadd(a, b)
print('a = iadd(a, b) =>', a)
print()
iconcat(c, d)
print('c = iconcat(c, d) =>', c)

上面示例只演示了個別函數。有關詳細信息，請參閱標准庫文檔。

a = -1
b = 5.0
c = [1, 2, 3]
d = ['a', 'b', 'c']
a = iadd(a, b) => -1
c = iconcat(c, d) => [1, 2, 3, 'a', 'b', 'c']

6.屬性和內容"Getters"

operator模塊最出眾的特性之一就是getter的概念。這些是在運行時構造的可調用對象，用於從序列中檢索對象屬性或內容。getter在處理迭代器或生成器序列時特別有用，因為它們的開銷要小於lambda和Python函數。

from operator import *
class MyObj:
"""attrgetter 演示類"""
def __init__(self, arg):
super().__init__()
self.arg = arg
def __repr__(self):
return 'MyObj({})'.format(self.arg)
l = [MyObj(i) for i in range(5)]
print('objects :', l)
# 從每個對象中提取'arg'屬性
g = attrgetter('arg')
vals = [g(i) for i in l]
print('arg values:', vals)
# 使用arg排序
l.reverse()
print('reversed :', l)
print('sorted :', sorted(l, key=g))

本例中的屬性getters功能類似於:lambda x, n=‘attrname’: getattr(x, n):

objects : [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]
arg values: [0, 1, 2, 3, 4]
reversed : [MyObj(4), MyObj(3), MyObj(2), MyObj(1), MyObj(0)]
sorted : [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]

而內容getters功能類似於lambda x, y=5: x[y]:

''' 學習中遇到問題沒人解答？小編創建了一個Python學習交流QQ群：711312441 尋找有志同道合的小伙伴，互幫互助,群裡還有不錯的視頻學習教程和PDF電子書！ '''
from operator import *
l = [dict(val=-1 * i) for i in range(4)]
print('Dictionaries:')
print(' original:', l)
g = itemgetter('val')
vals = [g(i) for i in l]
print(' values:', vals)
print(' sorted:', sorted(l, key=g))
print()
l = [(i, i * -2) for i in range(4)]
print('\nTuples:')
print(' original:', l)
g = itemgetter(1)
vals = [g(i) for i in l]
print(' values:', vals)
print(' sorted:', sorted(l, key=g))

內容getters既可以處字典，也可以處理序列。

Dictionaries:
original: [{
'val': 0}, {
'val': -1}, {
'val': -2}, {
'val': -3}]
values: [0, -1, -2, -3]
sorted: [{
'val': -3}, {
'val': -2}, {
'val': -1}, {
'val': 0}]
Tuples:
original: [(0, 0), (1, -2), (2, -4), (3, -6)]
values: [0, -2, -4, -6]
sorted: [(3, -6), (2, -4), (1, -2), (0, 0)]

7.自定義類中使用

operator模塊中的函數操作是通過標准的Python接口工作，因此它們也可以處理用戶自定義的類和內置類型。

from operator import *
class MyObj:
"""重載操作符例子"""
def __init__(self, val):
super(MyObj, self).__init__()
self.val = val
def __str__(self):
return 'MyObj({})'.format(self.val)
def __lt__(self, other):
"""小於比較"""
print('Testing {} < {}'.format(self, other))
return self.val < other.val
def __add__(self, other):
"""add操作"""
print('Adding {} + {}'.format(self, other))
return MyObj(self.val + other.val)
a = MyObj(1)
b = MyObj(2)
print('比較操作:')
print(lt(a, b))
print('\n算術運算:')
print(add(a, b))

比較操作:

Testing MyObj(1) < MyObj(2)
True

算術運算:

Adding MyObj(1) + MyObj(2)
MyObj(3)