operator-标准运算符作为函数详解(3)Python语言的功能编程模块(必读进阶学习教程)(参考资料)

该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 < 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 ）

返回obj的结果。（请注意，对象实例没有 方法;只有解释器核心定义了此操作。结果受到和 方法的影响。）not __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数字。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.__index__()。

operator.inv（obj ）

operator.invert（obj ）

operator.__inv__（obj ）

operator.__invert__（obj ）

返回数字obj的按位反转。这相当于~obj。

operator.lshift（a，b ）

operator.__lshift__（a，b ）

返回一个左移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 negated（-obj）。

operator.or_（a，b ）

operator.__or__（a，b ）

返回按位或a和b。

operator.pos（obj ）

operator.__pos__（obj ）

返回obj positive（+obj）。

operator.pow（a，b ）

operator.__pow__（a，b ）

返回，a和b数字。a ** b

operator.rshift（a，b ）

operator.__rshift__（a，b ）

返回一个由右移b。

operator.sub（a，b ）

operator.__sub__（a，b ）

返回。a - b

operator.truediv（a，b ）

operator.__truediv__（a，b ）

返回2/3是.66而不是0.这也称为“真正的”除法。a / b

operator.xor（a，b ）

operator.__xor__（a，b ）

返回按位异或a和b。

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

operator.concat（a，b ）

operator.__concat__（a，b ）

返回为一个和b序列。a + b

operator.contains（a，b ）

operator.__contains__（a，b ）

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

operator.countOf（a，b ）

返回的出现次数b中的一个。

operator.delitem（a，b ）

operator.__delitem__（a，b ）

除去的值一个索引b。

operator.getitem（a，b ）

operator.__getitem__（a，b ）

返回的值一个索引b。

operator.indexOf（a，b ）

返回第一个的发生的索引b中一个。

operator.setitem（a，b，c ）

operator.__setitem__（a，b，c ）

设定的值一个索引b到Ç。

operator.length_hint（obj，默认= 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（项目）

operator.itemgetter（*项目）

返回一个可调用对象，该对象使用操作数的方法从其操作数中获取项__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__() 方法接受的任何类型。字典接受任何可混合的值。列表，元组和字符串接受索引或切片：

>>> 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 … ] ）

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

• 之后，呼叫返回。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

 

>>> 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']