# `operator` — Standard operators as functions

Вихідний код: Lib/operator.py

The `operator` module exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, `operator.add(x, y)` is equivalent to the expression `x+y`. Many function names are those used for special methods, without the double underscores. For backward compatibility, many of these have a variant with the double underscores kept. The variants without the double underscores are preferred for clarity.

Функції поділяються на категорії, які виконують порівняння об’єктів, логічні операції, математичні операції та операції послідовності.

Функції порівняння об’єктів корисні для всіх об’єктів і названі на честь розширених операторів порівняння, які вони підтримують:

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)` is equivalent to `a <= b`, `eq(a, b)` is equivalent to `a == b`, `ne(a, b)` is equivalent to `a != b`, `gt(a, b)` is equivalent to `a > b`, а `ge(a, b)` еквівалентно `a >= b`. Зауважте, що ці функції можуть повертати будь-яке значення, яке може інтерпретуватися як логічне значення. Перегляньте Порівняння для отримання додаткової інформації про розширені порівняння.

Логічні операції також зазвичай застосовуються до всіх об’єктів і підтримують тести істинності, перевірки ідентичності та логічні операції:

operator.not_(obj)
operator.__not__(obj)

  Return the outcome of `not` obj. (Note that there is no `__not__()` method for object instances; only the interpreter core defines this operation. The result is affected by the `__bool__()` and `__len__()` methods.)

operator.truth(obj)

  Повертає `True`, якщо obj має значення true, і `False` в іншому випадку. Це еквівалентно використанню конструктора `bool`.

operator.is_(a, b)

  Повернути `a is b`. Перевіряє ідентичність об’єкта.

operator.is_not(a, b)

  Повернути `a не є b`. Перевіряє ідентичність об’єкта.

operator.is_none(a)

  Return `a is None`. Tests object identity.

  Added in version 3.14.

operator.is_not_none(a)

  Return `a is not None`. Tests object identity.

  Added in version 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`.

  Added in version 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 дорівнює 0,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 в 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)

  Return an estimated length for the object obj. First try to return its actual length, then an estimate using `object.__length_hint__()`, and finally return the default value.

  Added in version 3.4.

The following operation works with callables:

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

  Return `obj(*args, **kwargs)`.

  Added in version 3.11.

The `operator` module also defines tools for generalized attribute and item lookups. These are useful for making fast field extractors as arguments for `map()`, `sorted()`, `itertools.groupby()`, or other functions that expect a function argument.

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)

  Return a callable object that fetches item from its operand using the operand’s `__getitem__()` method. If multiple items are specified, returns a tuple of lookup values. For example:

  - Після `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

  The items can be any type accepted by the operand’s `__getitem__()` method. Dictionaries accept any hashable value. Lists, tuples, and strings accept an index or a slice:

      >>> 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)

  Повертає викликаний об’єкт, який викликає метод ім’я свого операнда. Якщо надано додаткові аргументи та/або ключові аргументи, вони також будуть надані методу. Наприклад:

  - Після `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

## Відображення операторів у функції

This table shows how abstract operations correspond to operator symbols in the Python syntax and the functions in the `operator` module.

Операція | Синтаксис | функція
--- | --- | ---
Доповнення | `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)`
Порозрядне виняткове або | `a ^ b` | `xor(a, b)`
Побітова інверсія | `~ a` | `invert(a)`
Побітове або | `a | b` | `або_(a, b)`
Піднесення до степеня | `a ** b` | `pow(a, b)`
Ідентичність | `a є b` | `is_(a, b)`
Ідентичність | `a не є 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]` | `виділення(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)`
Позитивний | `+ a` | `pos(a)`
Правий Shift | `a >> b` | `rshift(a, b)`
Призначення фрагмента | `seq[i:j] = значення` | `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)`
Тест на правду | `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)`

## Оператори на місці

Багато операцій мають версію «на місці». Нижче наведено функції, які забезпечують примітивніший доступ до операторів на місці, ніж звичайний синтаксис; наприклад, раз (statement) `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`.

  Added in version 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`.