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)

Возвращает 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 преобразовано в целое число. Эквивалентно 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.

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)

Возвращает расчетную длину объекта 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__(). Словари принимают любые хэшируемые значение. Списки, кортежи и строки принимают индекс или фрагмент:

>>> 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)
Bitwise Exclusive Or	a ^ b	xor(a, b)
Bitwise Inversion	~ a	invert(a)
Bitwise Or	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)

Операторы на месте

Многие операции имеют версию «на месте». Ниже перечислены функции, обеспечивающие более примитивный доступ к операторам на месте, чем обычный синтаксис; например, инструкция 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.