> **Источник:** https://python-all.ru/3.1/library/operator.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 9.9. `operator` – Стандартные операторы в виде функций

Модуль `operator` экспортирует набор функций, реализованных на C, соответствующих встроенным операторам 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`

. Обратите внимание, что эти функции могут возвращать любое значение, которое может трактоваться или не трактоваться как булево. См.

[*Сравнения*](https://python-all.ru/3.1/reference/expressions.html#comparisons)

для получения дополнительной информации о расширенных сравнениях.

Логические операции также в целом применимы ко всем объектам и поддерживают проверки истинности, проверки тождественности и булевы операции:

#### `operator.not_(obj)`

#### `operator.__not__(obj)`

Возвращает результат

[`not`](https://python-all.ru/3.1/reference/expressions.html#not)

*obj*

. (Обратите внимание, что для экземпляров объектов не существует метода

[`__not__()`](https://python-all.ru/3.1/library/operator.html#operator.__not__)

; только ядро интерпретатора определяет эту операцию. Результат зависит от методов

[`__bool__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__bool__)

и

[`__len__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__len__)

.)

#### `operator.truth(obj)`

Возвращает

[`True`](https://python-all.ru/3.1/library/constants.html#True)

, если

*obj*

истинно, и

[`False`](https://python-all.ru/3.1/library/constants.html#False)

в противном случае. Это эквивалентно вызову конструктора

[`bool`](https://python-all.ru/3.1/library/functions.html#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.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*

.

У многих операций есть версия «на месте». Следующие функции предоставляют более низкоуровневый доступ к операторам «на месте», чем обычный синтаксис; например, [*оператор*](https://python-all.ru/3.1/glossary.html#term-statement) `x += y` эквивалентен `x = operator.iadd(x, y)`. Другими словами, `z = operator.iadd(x, y)` эквивалентно составному оператору `z = x; z += y`.

#### `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.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`

.

Пример: построить словарь, сопоставляющий порядковые номера от `0` до `255` с соответствующими символами.

```python
>>> d = {}
>>> keys = range(256)
>>> vals = map(chr, keys)
>>> map(operator.setitem, [d]*len(keys), keys, vals)   # doctest: +SKIP
```

Модуль `operator` также определяет инструменты для обобщённого поиска атрибутов и элементов. Они полезны для создания быстрых извлекателей полей в качестве аргументов для [`map()`](https://python-all.ru/3.1/library/functions.html#map), [`sorted()`](https://python-all.ru/3.1/library/functions.html#sorted), [`itertools.groupby()`](https://python-all.ru/3.1/library/itertools.html#itertools.groupby) или других функций, которые ожидают аргумент-функцию.

#### `operator.attrgetter(attr[, args...])`

Возвращает вызываемый объект, который извлекает *attr* из своего операнда. Если запрошено более одного атрибута, возвращает кортеж атрибутов. После, `f = attrgetter('name')` вызов `f(b)` возвращает `b.name`. После, `f = attrgetter('name', 'date')` вызов `f(b)` возвращает `(b.name, b.date)`. Эквивалентно:

```python
def attrgetter(*items):
    if len(items) == 1:
        attr = items[0]
        def g(obj):
            return resolve_attr(obj, attr)
    else:
        def g(obj):
            return tuple(resolve_att(obj, attr) for attr in items)
    return g

def resolve_attr(obj, attr):
    for name in attr.split("."):
        obj = getattr(obj, name)
    return obj
```

Имена атрибутов могут также содержать точки; после `f = attrgetter('date.month')` вызов `f(b)` возвращает `b.date.month`.

#### `operator.itemgetter(item[, args...])`

Возвращает вызываемый объект, который извлекает *item* из своего операнда, используя метод [`__getitem__()`](https://python-all.ru/3.1/library/operator.html#operator.__getitem__) операнда. Если указано несколько элементов, возвращает кортеж значений поиска. Эквивалентно:

```python
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__()`](https://python-all.ru/3.1/library/operator.html#operator.__getitem__) операнда. Словари принимают любое хешируемое значение. Списки, кортежи и строки принимают индекс или срез:

```python
>>> itemgetter(1)('ABCDEFG')
'B'
>>> itemgetter(1,3,5)('ABCDEFG')
('B', 'D', 'F')
>>> itemgetter(slice(2,None))('ABCDEFG')
'CDEFG'
```

Пример использования [`itemgetter()`](https://python-all.ru/3.1/library/operator.html#operator.itemgetter) для извлечения определённых полей из записи-кортежа:

```python
>>> 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...])`

Возвращает вызываемый объект, который вызывает метод *name* на своем операнде. Если указаны дополнительные аргументы и/или ключевые аргументы, они также будут переданы методу. После `f = methodcaller('name')` вызов `f(b)` возвращает `b.name()`. После `f = methodcaller('name', 'foo', bar=1)` вызов `f(b)` возвращает `b.name('foo', bar=1)`. Эквивалентно:

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

## 9.9.1. Отображение операторов на функции

В этой таблице показано соответствие абстрактных операций символам операторов в синтаксисе Python и функциям модуля `operator`.

| Операция | Синтаксис | Функция |
| --- | --- | --- |
| Сложение | `a + b` | `add(a, b)` |
| Конкатенация | `seq1 + seq2` | `concat(seq1, seq2)` |
| Проверка вхождения | `obj in seq` | `contains(seq, obj)` |
| Деление | `a / b` | `div(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)` |
| Присваивание по индексу | `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` | `neg(a)` |
| Отрицание (логическое) | `not a` | `not_(a)` |
| Положительный знак | `+ a` | `pos(a)` |
| Сдвиг вправо | `a >> b` | `rshift(a, b)` |
| Повторение последовательности | `seq * i` | `repeat(seq, i)` |
| Присваивание среза | `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)` |