This document is for an old version of Python that is no longer supported. You should upgrade and read the documentação do Python para versão estável atual.

# 9.9. `operator` — Operadores padrão como funções

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`. The function names are those used for special class methods; variants without leading and trailing `__` are also provided for convenience.

The functions fall into categories that perform object comparisons, logical operations, mathematical operations, sequence operations, and abstract type tests.

As funções de comparação de objetos são úteis para todos os objetos e são nomeadas após os operadores de comparação que os mesmos suportam:

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

  Perform “rich comparisons” between a and b. Specifically, `lt(a, b)` is equivalent to `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` and `ge(a, b)` is equivalent to `a >= b`. Note that unlike the built-in `cmp()`, these functions can return any value, which may or may not be interpretable as a Boolean value. See Comparações for more information about rich comparisons.

  Novo na versão 2.2.

As operações lógicas também são geralmente aplicáveis a todos os objetos e suportam testes de verdade, testes de identidade e operações booleanas:

`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 `__nonzero__()` and `__len__()` methods.)

`operator.``truth`(obj)

  Retorna `True` se o obj for True, e `False` caso contrário. Isso é equivalente a utilizar a construção `bool`.

`operator.``is_`(a, b)

  Retorna `a is b`. Testa a identidade do objeto.

  Novo na versão 2.3.

`operator.``is_not`(a, b)

  Retorna `a is not b`. Testa a identidade do objeto.

  Novo na versão 2.3.

As operações matemáticas bit a bit são as mais numerosas:

`operator.``abs`(obj)
`operator.``__abs__`(obj)

  Retorna o valor absoluto de obj.

`operator.``add`(a, b)
`operator.``__add__`(a, b)

  Retorna `a + b`, onde a e b são números

`operator.``and_`(a, b)
`operator.``__and__`(a, b)

  Retornar bit a bit de a e b.

`operator.``div`(a, b)
`operator.``__div__`(a, b)

  Return `a / b` when `__future__.division` is not in effect. This is also known as “classic” division.

`operator.``floordiv`(a, b)
`operator.``__floordiv__`(a, b)

  Retorna `a // b`.

  Novo na versão 2.2.

`operator.``index`(a)
`operator.``__index__`(a)

  Retorna a convertendo para um inteiro. Equivalente a``a.__index__()``.

  Novo na versão 2.5.

`operator.``inv`(obj)
`operator.``invert`(obj)
`operator.``__inv__`(obj)
`operator.``__invert__`(obj)

  Retorna o inverso bit a bit do número obj. Isso equivale a `~obj`.

  Novo na versão 2.0: The names `invert()` and `__invert__()`.

`operator.``lshift`(a, b)
`operator.``__lshift__`(a, b)

  Retorna a deslocado para a esquerda por b.

`operator.``mod`(a, b)
`operator.``__mod__`(a, b)

  Retorna `a % b`.

`operator.``mul`(a, b)
`operator.``__mul__`(a, b)

  Retorna `a * b`, onde a e b são números

`operator.``neg`(obj)
`operator.``__neg__`(obj)

  Retorna obj negado (`-obj`).

`operator.``or_`(a, b)
`operator.``__or__`(a, b)

  Retorna bit a bit de a e b.

`operator.``pos`(obj)
`operator.``__pos__`(obj)

  Retorna obj positivo (`+obj`).

`operator.``pow`(a, b)
`operator.``__pow__`(a, b)

  Retorna `a ** b`, onde a e b são números.

  Novo na versão 2.3.

`operator.``rshift`(a, b)
`operator.``__rshift__`(a, b)

  Retorna a deslocado para a direita por b.

`operator.``sub`(a, b)
`operator.``__sub__`(a, b)

  Retorna `a - b`.

`operator.``truediv`(a, b)
`operator.``__truediv__`(a, b)

  Return `a / b` when `__future__.division` is in effect. This is also known as “true” division.

  Novo na versão 2.2.

`operator.``xor`(a, b)
`operator.``__xor__`(a, b)

  Retorna o OU exclusivo bit a bit de a e b.

Operações que funcionam com sequências (algumas delas com mapas também) incluem:

`operator.``concat`(a, b)
`operator.``__concat__`(a, b)

  Retorna `a + b` para as sequências a e b.

`operator.``contains`(a, b)
`operator.``__contains__`(a, b)

  Retorna o resultado do teste `b in a`. Observe os operandos invertidos.

  Novo na versão 2.0: The name `__contains__()`.

`operator.``countOf`(a, b)

  Retorna o número de ocorrências de b em a.

`operator.``delitem`(a, b)
`operator.``__delitem__`(a, b)

  Remove o valor de a no índice b.

`operator.``delslice`(a, b, c)
`operator.``__delslice__`(a, b, c)

  Delete the slice of a from index b to index c-1.

  Obsoleto desde a versão 2.6: This function is removed in Python 3.x. Use `delitem()` with a slice index.

`operator.``getitem`(a, b)
`operator.``__getitem__`(a, b)

  Retorna o valor de a no índice b.

`operator.``getslice`(a, b, c)
`operator.``__getslice__`(a, b, c)

  Return the slice of a from index b to index c-1.

  Obsoleto desde a versão 2.6: This function is removed in Python 3.x. Use `getitem()` with a slice index.

`operator.``indexOf`(a, b)

  Retorna o índice da primeira ocorrência de b em a.

`operator.``repeat`(a, b)
`operator.``__repeat__`(a, b)

  Obsoleto desde a versão 2.7: Use `__mul__()` instead.

  Return `a * b` where a is a sequence and b is an integer.

`operator.``sequenceIncludes`(...)

  Obsoleto desde a versão 2.0: Use `contains()` instead.

  Alias for `contains()`.

`operator.``setitem`(a, b, c)
`operator.``__setitem__`(a, b, c)

  Define o valor de a no índice b para c.

`operator.``setslice`(a, b, c, v)
`operator.``__setslice__`(a, b, c, v)

  Set the slice of a from index b to index c-1 to the sequence v.

  Obsoleto desde a versão 2.6: This function is removed in Python 3.x. Use `setitem()` with a slice index.

Example use of operator functions:

    >>> # Elementwise multiplication
    >>> map(mul, [0, 1, 2, 3], [10, 20, 30, 40])
    [0, 20, 60, 120]

    >>> # Dot product
    >>> sum(map(mul, [0, 1, 2, 3], [10, 20, 30, 40]))
    200

Many operations have an “in-place” version. The following functions provide a more primitive access to in-place operators than the usual syntax does; for example, the statement `x += y` is equivalent to `x = operator.iadd(x, y)`. Another way to put it is to say that `z = operator.iadd(x, y)` is equivalent to the compound statement `z = x; z += y`.

`operator.``iadd`(a, b)
`operator.``__iadd__`(a, b)

  `a = iadd(a, b)` is equivalent to `a += b`.

  Novo na versão 2.5.

`operator.``iand`(a, b)
`operator.``__iand__`(a, b)

  `a = iand(a, b)` is equivalent to `a &= b`.

  Novo na versão 2.5.

`operator.``iconcat`(a, b)
`operator.``__iconcat__`(a, b)

  `a = iconcat(a, b)` é equivalente a `a += b` onde a e b são sequências.

  Novo na versão 2.5.

`operator.``idiv`(a, b)
`operator.``__idiv__`(a, b)

  `a = idiv(a, b)` is equivalent to `a /= b` when `__future__.division` is not in effect.

  Novo na versão 2.5.

`operator.``ifloordiv`(a, b)
`operator.``__ifloordiv__`(a, b)

  `a = ifloordiv(a, b)` é equivalente a `a //= b`.

  Novo na versão 2.5.

`operator.``ilshift`(a, b)
`operator.``__ilshift__`(a, b)

  `a = ilshift(a, b)` é equivalente a `a <<= b`.

  Novo na versão 2.5.

`operator.``imod`(a, b)
`operator.``__imod__`(a, b)

  `a = imod(a, b)` é equivalente a `a %= b`.

  Novo na versão 2.5.

`operator.``imul`(a, b)
`operator.``__imul__`(a, b)

  `a = imul(a, b)` é equivalente a `a *= b`.

  Novo na versão 2.5.

`operator.``ior`(a, b)
`operator.``__ior__`(a, b)

  `a = ior(a, b)` é equivalente a `a |= b`.

  Novo na versão 2.5.

`operator.``ipow`(a, b)
`operator.``__ipow__`(a, b)

  `a = ipow(a, b)` é equivalente a `a **= b`.

  Novo na versão 2.5.

`operator.``irepeat`(a, b)
`operator.``__irepeat__`(a, b)

  Obsoleto desde a versão 2.7: Use `__imul__()` instead.

  `a = irepeat(a, b)` is equivalent to `a *= b` where a is a sequence and b is an integer.

  Novo na versão 2.5.

`operator.``irshift`(a, b)
`operator.``__irshift__`(a, b)

  `a = irshift(a, b)` é equivalente a `a >>= b`.

  Novo na versão 2.5.

`operator.``isub`(a, b)
`operator.``__isub__`(a, b)

  `a = isub(a, b)` é equivalente a `a -= b`.

  Novo na versão 2.5.

`operator.``itruediv`(a, b)
`operator.``__itruediv__`(a, b)

  `a = itruediv(a, b)` is equivalent to `a /= b` when `__future__.division` is in effect.

  Novo na versão 2.5.

`operator.``ixor`(a, b)
`operator.``__ixor__`(a, b)

  `a = ixor(a, b)` é equivalente a `a ^= b`.

  Novo na versão 2.5.

The `operator` module also defines a few predicates to test the type of objects; however, these are not all reliable. It is preferable to test abstract base classes instead (see `collections` and `numbers` for details).

`operator.``isCallable`(obj)

  Obsoleto desde a versão 2.0: Use `isinstance(x, collections.Callable)` instead.

  Returns true if the object obj can be called like a function, otherwise it returns false. True is returned for functions, bound and unbound methods, class objects, and instance objects which support the `__call__()` method.

`operator.``isMappingType`(obj)

  Obsoleto desde a versão 2.7: Use `isinstance(x, collections.Mapping)` instead.

  Returns true if the object obj supports the mapping interface. This is true for dictionaries and all instance objects defining `__getitem__()`.

`operator.``isNumberType`(obj)

  Obsoleto desde a versão 2.7: Use `isinstance(x, numbers.Number)` instead.

  Returns true if the object obj represents a number. This is true for all numeric types implemented in C.

`operator.``isSequenceType`(obj)

  Obsoleto desde a versão 2.7: Use `isinstance(x, collections.Sequence)` instead.

  Returns true if the object obj supports the sequence protocol. This returns true for all objects which define sequence methods in C, and for all instance objects defining `__getitem__()`.

O módulo `operator` também define ferramentas para procura de itens e atributos generalizados. Estes são úteis para fazer extração de campo rapidamente como argumentos para a função `map()`, `sorted()`, `itertools.groupby()`, ou outra função que espera um argumento de função.

`operator.``attrgetter`(attr)
`operator.``attrgetter`(*attrs)

  Retorna um objeto invocável que pode buscar o attr do seu operando. Caso seja solicitado mais de um atributo, retorna uma tupla de atributos. Os nomes dos atributos também podem conter pontos. Por exemplo:

  - Depois de `f = attrgetter('name')`, a chamada a `f(b)` retorna `b.name`.

  - Depois de `f = attrgetter('name', 'date')`, a chamada a `f(b)` retorna``(b.name, b.date)``.

  - Depois de `f = attrgetter('name.first', 'name.last')`, a chamada a `f(b)` retorna `(b.name.first, b.name.last)`.

  Equivalente a:

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

  Novo na versão 2.4.

  Alterado na versão 2.5: Added support for multiple attributes.

  Alterado na versão 2.6: Added support for dotted attributes.

`operator.``itemgetter`(item)
`operator.``itemgetter`(*items)

  Retorna um objeto chamável que busca item de seu operando usando o operando do método `__getitem__()`. Se múltiplo itens são especificados, retorna uma tupla de valores da pesquisa. Por exemplo:

  - Depois de `f = itemgetter(2)`, a chamada a `f(r)` retorna `r[2]`.

  - Depois de `g = itemgetter(2, 5, 3)`, a chamada a `g(r)` retorna `(r[2], r[5], r[3])`.

  Equivalente a:

      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

  Os itens podem ser qualquer tipo aceito pelo método `__getitem__()`. Os dicionários aceitam qualquer valor hashable. Listas, tuplas e strings aceitam um índice ou uma fatia:

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

  Novo na versão 2.4.

  Alterado na versão 2.5: Added support for multiple item extraction.

  Exemplo de uso `itemgetter()` para recuperar campos específicos de um registro de tupla:

      >>> inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
      >>> getcount = itemgetter(1)
      >>> map(getcount, inventory)
      [3, 2, 5, 1]
      >>> sorted(inventory, key=getcount)
      [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]

`operator.``methodcaller`(name[, args...])

  Retorna um objeto chamável que invoca o método name em seu operando. Se argumentos adicionais e/ou argumentos de keyword forem fornecidos, os mesmos serão passados para o método. Por exemplo:

  - Depois de `f = methodcaller('name')`, a chamada a `f(b)` retorna `b.name()`.

  - Depois de `f = methodcaller('name', 'foo', bar=1)`, a chamada `f(b)` retorna `b.name('foo', bar=1)`.

  Equivalente a:

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

  Novo na versão 2.6.

## 9.9.1. Mapeando os Operadores para suas Respectivas Funções

Esta tabela mostra como as operações abstratos correspondem aos símbolos do operador na sintaxe Python e as funções no módulo `operator`.

Operação | Sintaxe | Função
--- | --- | ---
Adição | `a + b` | `add(a, b)`
Concatenação | `seq1 + seq2` | `concat(seq1, seq2)`
Teste de Contenção | `obj in seq` | `contains(seq, obj)`
Divisão | `a / b` | `div(a, b)` (without `__future__.division`)
Divisão | `a / b` | `truediv(a, b)` (with `__future__.division`)
Divisão | `a // b` | `floordiv(a, b)`
E Bit a Bit | `a & b` | `and_(a, b)`
Ou Exclusivo Bit a Bit | `a ^ b` | `xor(a, b)`
Inversão Bit a Bit | `~ a` | `invert(a)`
Ou Bit a Bit | `a | b` | `or_(a, b)`
Exponenciação | `a ** b` | `pow(a, b)`
Identidade | `a is b` | `is_(a, b)`
Identidade | `a is not b` | `is_not(a, b)`
Atribuição Indexada | `obj[k] = v` | `setitem(obj, k, v)`
Eliminação Indexada | `del obj[k]` | `delitem(obj, k)`
Indexação | `obj[k]` | `getitem(obj, k)`
Left Shift | `a << b` | `lshift(a, b)`
Módulo | `a % b` | `mod(a, b)`
Multiplicação | `a * b` | `mul(a, b)`
Negação (Aritmética) | `- a` | `neg(a)`
Negação (Lógica) | `not a` | `not_(a)`
Positivo | `+ a` | `pos(a)`
Right Shift | `a >> b` | `rshift(a, b)`
Sequence Repetition | `seq * i` | `repeat(seq, i)`
Atribuição de Fatiamento | `seq[i:j] = values` | `setitem(seq, slice(i, j), values)`
Remoção de Fatiamento | `del seq[i:j]` | `delitem(seq, slice(i, j))`
Fatiamento | `seq[i:j]` | `getitem(seq, slice(i, j))`
Formatação de Strings | `s % obj` | `mod(s, obj)`
Subtração | `a - b` | `sub(a, b)`
Teste Verdadeiro | `obj` | `truth(obj)`
Ordenação | `a < b` | `lt(a, b)`
Ordenação | `a <= b` | `le(a, b)`
Igualdade | `a == b` | `eq(a, b)`
Diferença | `a != b` | `ne(a, b)`
Ordenação | `a >= b` | `ge(a, b)`
Ordenação | `a > b` | `gt(a, b)`