# Como usar operadores Python

Operadores Python ajudam você a trabalhar com valores e operandos. Eles também auxiliam a alterá-los e ligá-los uns aos outros. Operadores podem ser lógicos ou aritméticos.

## O que são operadores Python e como eles funcionam?

Um operador é um **caractere de uma operação**. Operadores costumam ser usados para ligar diversos operandos, com a finalidade de formar um novo valor. A aplicação de um operador a um único operando faz com que este seja modificado.

O exemplo mais simples de operadores Python deve ser, provavelmente, o processo de somar dois números por meio da utilização de um **operador de adição**, representado pelo símbolo de mais, posicionado entre dois números. O Python avalia a expressão e retorna o valor correspondente:

```python
1 + 1
```

O Python é especial, porque palavras curtas em inglês, como *and* (e), *or* (ou), *is* (é), *not* (não) e *in* (em), são usadas como operadores, além dos caracteres já conhecidos. A **combinação de operadores e operandos** resulta em uma expressão, como:

```python
1 + 1 == 2
```

### Quais são os operadores Python?

A linguagem Python compreende diversas classes de operadores. Eles **operam com diferentes tipos de operandos** e retornam um determinado tipo de resultado. A tabela abaixo dá um panorama dos diferentes tipos de operadores Python:

<table>
  <thead>
    <tr>
      <th><strong>Classes de operadores Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Operandos</strong></th>
      <th><strong>Resultado</strong></th>
      <th><strong>Panorama</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Operadores aritméticos</td>
      <td>Combinar dois números para formar um novo número</td>
      <td>Números</td>
      <td>Números</td>
      <td>+, -, *, /, //, %,* \*, @</td>
    </tr>
    <tr>
      <td>Operadores de comparação</td>
      <td>Comparar duas expressões</td>
      <td>Expressões</td>
      <td>Booleano</td>
      <td>&lt;, &gt;, ==, !=, &lt;=, &gt;=</td>
    </tr>
    <tr>
      <td>Operadores lógicos</td>
      <td>Combinar expressões em um contexto booleano</td>
      <td>Expressões</td>
      <td>Última expressão avaliada / Booleano</td>
      <td>*and*, *or*, *not*</td>
    </tr>
    <tr>
      <td>Operadores *bitwise*</td>
      <td>Manipular inteiros como sequências binárias</td>
      <td>Números</td>
      <td>Número</td>
      <td>&lt;&lt;, &gt;&gt;, &amp;, |, ^, ~</td>
    </tr>
    <tr>
      <td>Operadores de atribuição</td>
      <td>Atribuir valor a um nome</td>
      <td>*Lvalue*, *Rvalue*</td>
      <td>- / Expressão avaliada</td>
      <td>=, :=, +=, -=, \*= etc.</td>
    </tr>
    <tr>
      <td>Operadores de identidade</td>
      <td>Determinar se dois nomes se referem ao mesmo objeto</td>
      <td>Objetos</td>
      <td>Booleano</td>
      <td>*is*, *is not*</td>
    </tr>
    <tr>
      <td>Operador condicional</td>
      <td>Retornar um de dois valores, a depender da condição</td>
      <td>Expressão, condição, alternativa</td>
      <td>Expressão / Alternativa</td>
      <td>… *if*… *else* …</td>
    </tr>
    <tr>
      <td>Operadores de conjunto</td>
      <td>Ligar dois conjuntos / comparar conjuntos</td>
      <td>Quantidades</td>
      <td>Quantidade / Booleano</td>
      <td>&amp;, |, ^, -, &lt;, &gt;, &lt;=, &gt;=</td>
    </tr>
    <tr>
      <td>Operadores de associação</td>
      <td>Testar se um iterável contém um objeto específico</td>
      <td>Objeto, Iterável</td>
      <td>Booleano</td>
      <td>*in*, *not in*</td>
    </tr>
    <tr>
      <td>Operador de concatenação</td>
      <td>Encadear sequências</td>
      <td>*Strings* / Listas / Tuplas</td>
      <td>*String* / Lista / Tupla</td>
      <td>+</td>
    </tr>
    <tr>
      <td>Operadores de indexação e fatiamento</td>
      <td>Retornar um ou mais elementos de um iterável</td>
      <td>Iterável, Índice / Fatia</td>
      <td>*String* / Lista / Tupla</td>
      <td>\[\], \[::\]</td>
    </tr>
  </tbody>
</table>

Operadores são classificados de acordo com sua aridade, juntamente com o tipo de operandos e o valor retornado. O termo diz respeito à **quantidade de operandos que um operador combina**. Na maioria dos casos, operadores binários, com dois operandos, são usados. Também há operadores unários, com apenas um operando, bem como operadores ternários, que conectam três operandos:

<table>
  <thead>
    <tr>
      <th><strong>Aridade do operador</strong></th>
      <th><strong>Número de operandos</strong></th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Unário</td>
      <td>Um operando</td>
      <td>*not single\_value*</td>
    </tr>
    <tr>
      <td>Binário</td>
      <td>Dois operandos</td>
      <td>*left\_operand + right\_operand*</td>
    </tr>
    <tr>
      <td>Ternário</td>
      <td>Três operandos</td>
      <td>*some\_value if condition else other\_value*</td>
    </tr>
  </tbody>
</table>

### O que é precedência de operadores?

Entender o que é precedência de operadores é fundamental quando se aprende sobre operadores Python. O conceito vem da aritmética: **PEMDAS**, que indica a sequência correta de etapas a serem executadas em um cálculo. Recordemos: a expressão 3 *8 + 2 deve ser interpretada como (3* 8) + 2, e não como 3 *(8 + 2). Assim como ocorre com os sinais de adição e de multiplicação, existem regras de precedência que regem todos os operadores Python. Observe, abaixo, um exemplo de expressão com os operadores lógicos* and\*,\* or \*e *not*:

```python
if is_user and is_user_logged_in or is_admin and not login_blocked:
    ...
```

Sem conhecer as regras de precedência dos operadores Python, é impossível entender como os termos individuais devem se relacionar. A situação fica mais complicada quando múltiplos operadores são usados em uma só expressão. Em geral, o melhor a se fazer é **não depender de uma compreensão perfeita das regras implícitas**. Ao invés disso, explicite, com o uso de parênteses, como os termos de uma expressão devem se relacionar:

```python
if (is_user and is_user_logged_in) or (is_admin and not login_blocked):
    ...
```

Os **mesmos termos, agrupados de um jeito diferente,** resultam em uma declaração também diferente:

```python
if (is_user and is_user_logged_in or is_admin) and not login_blocked:
    ...
```

### O que é sobrecarga de operadores, métodos Dunder e função *operator* em Python?

Alguns operadores Python são usados **para mais de uma operação**. Um bom exemplo é o sinal de soma (mais): ele funciona tanto como operador de adição para números, quanto como operador de concatenação para sequências de *strings* e listas. Podemos somar dois números com o operador de adição:

```python
8 + 3 == 11
```

Também podemos concatenar **duas *strings*** usando o mesmo operador:

```python
"Walter" + "White" == "WalterWhite"
```

Ainda é possível concatenar **listas** com esse operador:

```python
['Jack', 'Jim'] + ['John'] == ['Jack', 'Jim', 'John']
```

A multifuncionalidade do sinal de soma como operador reflete um conceito comum na ciência da computação: **sobrecarga de operadores**. Você já deve ter ouvido falar nesta expressão, que se refere a um único operador que desempenha operações diferentes, dependendo do tipo de dado do operando.

Em Python, sobrecarga de operadores se dá desta forma: um operador e seus operandos são interpretados como **referências à função correspondente**. O método Dunder do primeiro operando é habilitado e recebe os outros operandos como argumentos. “Dunder” abrevia o termo *double underscore* (sublinhado duplo, em português). Assim sendo, o operador de soma corresponde ao método Dunder *\_\_add\_\_()*. Objetos que implementam um método *\_\_add\_\_()* podem ser conectados usando o operador de soma. O que exatamente constitui a ligação depende do objeto em questão.

Além dos métodos Dunder, o [módulo *operator*](https://docs.python.org/pt-br/3/library/operator.html "operator: Operadores padrões como funções — Documentação de Python 3.10.4") contém **funções que incluem funcionalidades de operadores Python**. Por exemplo, *operator.add(a, b)* habilita o método Dunder *a.\_\_add\_\_(b)*, que é equivalente à expressão *a + b*. Na medida do possível, listaremos a função *operator* de cada operação apresentada por este artigo. O nome da função *operator* corresponde ao nome do respectivo método Dunder. Você pode usar a tabela abaixo como referência para implementar sua própria funcionalidade:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Método Dunder</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>a + b</td>
      <td>operator.add(a, b)</td>
      <td>a.<strong>add</strong>(b)</td>
    </tr>
  </tbody>
</table>

Operadores usam a **notação infixa**, que insere o operador entre os operandos. Já funções usam a notação prefixa. Ambas as notações são equivalentes:

<table>
  <thead>
    <tr>
      <th><strong>Notação</strong></th>
      <th><strong>Uso</strong></th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Infixa</td>
      <td>Operadores</td>
      <td>a + b</td>
    </tr>
    <tr>
      <td>Prefixa</td>
      <td>Funções</td>
      <td>+ a b / add(a, b)</td>
    </tr>
  </tbody>
</table>

Acompanhe o exemplo abaixo. Nele, **definimos dois números e os adicionamos** ao operador, à função *operator* e ao método Dunder correspondente:

```python
import operator
a = 42
b = 69
assert a + b == operator.add(a, b) == a.__add__(b)
```

Expressões mais complexas também podem ser escritas com funções *operator*. A combinação dos operadores Python de soma e de igualdade em uma notação prefixa funciona da seguinte maneira:

```python
import operator
assert 'Py' + 'thon' == 'Python' 
 
assert operator.eq(operator.add('Py', 'thon'), 'Python')
```

## Panorama de operadores Python

Conheça, agora, os **11 tipos diferentes de operadores Python**.

### Operadores aritméticos

**Operadores Python aritméticos atuam com números**, para criar um novo número. Todos constituem operadores binários, com exceção dos símbolos de “mais” e de “menos”, que são unários, como mostra a tabela:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>+</td>
      <td>Adição / “mais” unário</td>
      <td>add(a, b) / pos(a)</td>
      <td>5 + 3 == 8 / +8 == 4 + 4</td>
    </tr>
    <tr>
      <td>-</td>
      <td>Subtração / “menos” unário</td>
      <td>sub(a, b) / neg(a)</td>
      <td>7 - 2 == 5 / -4 == 2 - 6</td>
    </tr>
    <tr>
      <td>\*</td>
      <td>Multiplicação</td>
      <td>mul(a, b)</td>
      <td>2\* 3 == 6</td>
    </tr>
    <tr>
      <td>/</td>
      <td>Divisão (real)</td>
      <td>truediv(a, b)</td>
      <td>8 / 2 == 4.0, 7 / 2 == 3.5</td>
    </tr>
    <tr>
      <td>//</td>
      <td>Divisão inteira (com arredondamento para o próximo inteiro mais baixo)</td>
      <td>floordiv(a, b)</td>
      <td>8 // 2 == 4, 7 // 2 == 3</td>
    </tr>
    <tr>
      <td>%</td>
      <td>Módulo: resto de uma divisão de número inteiro</td>
      <td>mod(a, b)</td>
      <td>8 % 2 == 0, 7 % 2 == 1</td>
    </tr>
    <tr>
      <td>\*\*</td>
      <td>Exponenciação</td>
      <td>pow(a, b)</td>
      <td>2\*\* 3 == 8, 10 \*\* -1 == 0.1</td>
    </tr>
    <tr>
      <td>@</td>
      <td>Multiplicação de matriz</td>
      <td>matmul(a, b)</td>
      <td>-</td>
    </tr>
  </tbody>
</table>

O **operador módulo** é usado por padrão para determinar se um número é par, já que um número par dividido por dois tem resto zero. Observe uma função Python com o operador módulo:

```python
def is_even(number):
    return number % 2 == 0
# test
assert is_even(8) and not is_even(7)
```

**Multiplicações** de matriz requerem o uso de um pacote, como NumPy.

### Operadores de comparação

Operadores Python de comparação indicam **como dois elementos podem ser ordenados entre eles**. O valor resultante é booleano e costuma ser usado para organizar algoritmos:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>&lt;</td>
      <td>Menor que</td>
      <td>lt(a, b)</td>
      <td>3 &lt; 1, ‘a’ &lt; ‘z’</td>
    </tr>
    <tr>
      <td>&gt;</td>
      <td>Maior que</td>
      <td>gt(a, b)</td>
      <td>4 &gt; 2, ‘z’ &gt; ‘a’</td>
    </tr>
    <tr>
      <td>==</td>
      <td>Igual a</td>
      <td>eq(a, b)</td>
      <td>‘a’ == ‘a’</td>
    </tr>
    <tr>
      <td>!=</td>
      <td>Diferente de</td>
      <td>ne(a, b)</td>
      <td>1 ! = 2, ‘Jim’ != ‘Jack’</td>
    </tr>
    <tr>
      <td>&lt;=</td>
      <td>Menor ou igual a</td>
      <td>le(a, b)</td>
      <td>9 &lt;= 10, 10 &lt;= 10</td>
    </tr>
    <tr>
      <td>&gt;=</td>
      <td>Maior ou igual a</td>
      <td>ge(a, b)</td>
      <td>11 &gt;= 10, 10 &gt;= 10</td>
    </tr>
  </tbody>
</table>

### Operadores lógicos

Os operadores Python lógicos *and* e *or* **ligam múltiplos operandos, seguindo a lógica booleana**. Como resultado, os dois operadores retornam o último objeto avaliado. O operador lógico *not* interpreta um objeto em um contexto booleano e nega seu valor verdadeiro:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>*and*</td>
      <td>“AND” lógico</td>
      <td>sem correspondência direta</td>
      <td>True and False == False, ‘name’ and … == …</td>
    </tr>
    <tr>
      <td>*or*</td>
      <td>“OR” lógico</td>
      <td>sem correspondência direta</td>
      <td>False or True == True, a = ‘’ or ‘Default’; assert a == ‘Default’.</td>
    </tr>
    <tr>
      <td>*not*</td>
      <td>Negação</td>
      <td>not\_(a)</td>
      <td>not True == False</td>
    </tr>
  </tbody>
</table>

Visualizar o **efeito das operações lógicas** em uma tabela pode ajudar na compreensão. Analise, abaixo, a lógica *AND*:

<table>
  <thead>
    <tr>
      <th><strong>and</strong></th>
      <th><strong>True</strong></th>
      <th><strong>False</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><strong>True</strong></td>
      <td>True</td>
      <td>False</td>
    </tr>
    <tr>
      <td><strong>False</strong></td>
      <td>False</td>
      <td>False</td>
    </tr>
  </tbody>
</table>

e a lógica *OR*:

<table>
  <thead>
    <tr>
      <th><strong>or</strong></th>
      <th><strong>True</strong></th>
      <th><strong>False</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><strong>True</strong></td>
      <td>True</td>
      <td>True</td>
    </tr>
    <tr>
      <td><strong>False</strong></td>
      <td>True</td>
      <td>False</td>
    </tr>
  </tbody>
</table>

Operandos de operadores Python booleanos não se limitam a variáveis booleanas. Isso quer dizer que qualquer objeto de Python pode ser interpretado em um contexto booleano. Os **objetos a seguir são avaliados como falsos no contexto booleano** e, portanto, chamados de *falsy*:

<table>
  <thead>
    <tr>
      <th><strong>Objeto</strong></th>
      <th><strong>Explicação</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>False, None</td>
      <td>Constantes falsas (False), de acordo com a definição</td>
    </tr>
    <tr>
      <td>0, 0.0, Decimal(0), Fraction(0, 1), etc.</td>
      <td>Número que representa zero</td>
    </tr>
    <tr>
      <td>‘’, (), \[\], {}, set(), range(0), etc.</td>
      <td>Sequência ou coleção vazia</td>
    </tr>
  </tbody>
</table>

### Operadores *bitwise*

Operadores Python *bitwise* **operam com inteiros, que são interpretados como sequências de bits**. Todos são operadores binários, com exceção do operador *bitwise* *NOT*:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>&lt;&lt;</td>
      <td>Deslocar sequência de bits para a esquerda</td>
      <td>lshift(a, b)</td>
      <td>5 &lt;&lt; 3 == 5 *2* \* 3</td>
    </tr>
    <tr>
      <td>&gt;&gt;</td>
      <td>Deslocar sequência de bits para a direita</td>
      <td>rshift(a, b)</td>
      <td>1 &gt;&gt; 1 == 0, 8 &gt;&gt; 1 == 4</td>
    </tr>
    <tr>
      <td>&amp;</td>
      <td>Combinar duas sequências de bits com *AND*</td>
      <td>and\_(a, b)</td>
      <td>`` </td></tr><tr><td>|</td><td>Concatenar duas sequências de bits com *OR*</td><td>or\_(a, b) </td><td>`` </td></tr><tr><td>^</td><td>Ligar duas sequências de bits com *XOR*</td><td>xor(a, b) </td><td>`` </td></tr><tr><td>~</td><td>Inverter a sequência de bits com *NOT*</td><td>invert(a) </td><td>``</td>
    </tr>
  </tbody>
</table>

Operadores *bitwise* são **adequados para operações matemáticas otimizadas**. O deslocamento para a esquerda corresponde a uma multiplicação por uma potência de dois:

<table>
  <thead>
    <tr>
      <th><strong>Expressão</strong></th>
      <th><strong>23 = 8</strong></th>
      <th><strong>22 = 4</strong></th>
      <th><strong>21 = 2</strong></th>
      <th><strong>20 = 1</strong></th>
      <th><strong>Decimal</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>b = 6</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>0</td>
      <td>6</td>
    </tr>
    <tr>
      <td>b &lt;&lt; 1</td>
      <td>1</td>
      <td>1</td>
      <td>0</td>
      <td>0</td>
      <td>12</td>
    </tr>
    <tr>
      <td>b &gt;&gt; 1</td>
      <td>0</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>3</td>
    </tr>
  </tbody>
</table>

Criamos uma **tabela de bits individuais** para ilustrarmos as operações *bitwise* *AND*, *OR* e *NOT*. Elas são aplicadas a um número em representação binária, usando uma máscara de bits:

<table>
  <thead>
    <tr>
      <th><strong>Expressão</strong></th>
      <th><strong>23 = 8</strong></th>
      <th><strong>22 = 4</strong></th>
      <th><strong>21 = 2</strong></th>
      <th><strong>20 = 1</strong></th>
      <th><strong>Decimal</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>bits = 6</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>0</td>
      <td>6</td>
    </tr>
    <tr>
      <td>mask = 5</td>
      <td>0</td>
      <td>1</td>
      <td>0</td>
      <td>1</td>
      <td>5</td>
    </tr>
    <tr>
      <td>bits &amp; mask</td>
      <td>0</td>
      <td>1</td>
      <td>0</td>
      <td>0</td>
      <td>4</td>
    </tr>
    <tr>
      <td>bits | mask</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>1</td>
      <td>7</td>
    </tr>
    <tr>
      <td>bits ^ mask</td>
      <td>0</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>3</td>
    </tr>
  </tbody>
</table>

O **operador *bitwise* *NOT* inverte a sequência de bits**. Ele transforma todo 1 em 0 e vice-versa. Além disso, o sinal do número também é invertido:

<table>
  <thead>
    <tr>
      <th><strong>Expressão</strong></th>
      <th><strong>23 = 8</strong></th>
      <th><strong>22 = 4</strong></th>
      <th><strong>21 = 2</strong></th>
      <th><strong>20 = 1</strong></th>
      <th><strong>Decimal</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>b = 6</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
      <td>0</td>
      <td>6</td>
    </tr>
    <tr>
      <td>~ b</td>
      <td>1</td>
      <td>0</td>
      <td>0</td>
      <td>1</td>
      <td>-7</td>
    </tr>
  </tbody>
</table>

### Operadores de atribuição

Em grande parte das linguagens de programação, atribuições são declarações básicas. Operadores Python de atribuição **atribuem um valor ao nome de uma variável**. Existe, ainda, o novo operador *walrus*, que permite criar uma atribuição dentro de uma expressão. Também há diversas declarações de atribuição estendidas, que combinam uma atribuição com outra operação:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>=</td>
      <td>Declaração de atribuição</td>
      <td>sem correspondência direta</td>
      <td>name = ‘Walter’</td>
    </tr>
    <tr>
      <td>:=</td>
      <td>Expressão de atribuição (operador *walrus*)</td>
      <td>sem correspondência direta</td>
      <td>\[ half for x in range(10) if (half := x / 2) &lt; 5 \]</td>
    </tr>
    <tr>
      <td>+=</td>
      <td>Atribuição de adição avançada</td>
      <td>iadd(a, b)</td>
      <td>x = 1; x += 4; assert x == 5</td>
    </tr>
  </tbody>
</table>

A linguagem Python reconhece operadores de atribuição estendidos para operações *bitwise* e aritméticas. Não os listaremos individualmente aqui. Exibiremos apenas o **padrão geral, usando a atribuição estendida de concatenação como exemplo**. Primeiramente, mostramos um código que anexa uma nova parte a uma *string* existente:

```python
name = 'Walter'
name = name + 'White'
assert name == 'WalterWhite'
```

Um exemplo equivalente usando o operador estendido de concatenação *+=* produz o mesmo resultado, mas seu código é mais conciso e expressivo:

```python
name = 'Walter'
name += 'White'
assert name == 'WalterWhite'
```

### Operadores de identidade

O operador Python *is* testa **se duas variáveis se referem ao mesmo objeto armazenado**. A identidade do objeto contrasta com a igualdade do objeto, que é testada pelo operador de comparação *==*. Em Python, *is* corresponde ao operador de igualdade estrita *===*, do JavaScript. Phyton também tem um teste de identidade negada, usando o operador *is not*:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>*is*</td>
      <td>Teste de identidade</td>
      <td>is\_(a, b)</td>
      <td>a = 42; b = a; assert a is b</td>
    </tr>
    <tr>
      <td>*is not*</td>
      <td>Teste de identidade negado</td>
      <td>is\_not(a, b)</td>
      <td>assert \[42\] is not \[42\]</td>
    </tr>
  </tbody>
</table>

Acompanhe nossos exemplos abaixo. Criamos uma referência para um objeto armazenado. Depois, criamos outra referência com um alias. O operador retorna como verdadeiro quando **as duas variáveis apontam para o mesmo objeto armazenado**:

```python
# assign value to name 
a = [42] 
# reference existing object 
b = a 
# if this holds 
assert a is b 
# so will this 
assert a == b
```

No exemplo a seguir, criamos duas **referências na memória para objetos independentes**. Embora os objetos sejam os mesmos, suas identidades são distintas. Por isso, o operador retorna como falso:

```python
# assign the same value to different names 
a = [42]
b = [42]
# `a`, `b` are two different objects 
assert a is not b 
# that contain the same value 
assert a == b
```

### Operador condicional

O operador Python condicional pode ser usado no lugar dos termos *if-else*. Ele é bastante utilizado para **diferenciar dois valores possíveis em atribuições** e é conhecido como um operador ternário, já que combina uma condição e duas expressões.

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>*… if … else …*</td>
      <td>Expressão condicional</td>
      <td>sem correspondência direta</td>
      <td>name = ‘Jim’ if age == 42 else ‘Jack’</td>
    </tr>
  </tbody>
</table>

Primeiramente, observe um exemplo usando a [declaração *if-else* no Python](https://www.ionos.com/digitalguide/websites/web-development/python-if-else/ "Python: if-else"). O código a seguir define Celsius ou Fahrenheit como **unidade de medida de temperatura**, a depender do sistema escolhido:

```python
if system == 'metric':
    unit = 'C' 
else: 
    unit = 'F
```

O código pode ser simplificado a uma única atribuição, **por meio de um operador condicional**:

```python
unit = 'C' if system == 'metric' else 'F'.
```

### Operadores de conjunto

Além de *strings*, tuplas, listas e dicionários, o Python oferece suporte padrão a **conjuntos como um tipo composto de dados**. A sobrecarga de operadores é definida para as operações usuais com conjuntos:

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>&amp;</td>
      <td>União de dois conjuntos</td>
      <td>and\_(a, b)</td>
      <td>{‘a’, ‘b’} &amp; {‘a’, ‘c’} == {‘a’}</td>
    </tr>
    <tr>
      <td>|</td>
      <td>Interseção de dois conjuntos</td>
      <td>or\_(a, b)</td>
      <td>{‘a’, ‘b’} | {‘a’, ‘c’} == {‘a’, ‘c’, ‘b’}</td>
    </tr>
    <tr>
      <td>^</td>
      <td>Diferença de forma simétrica de dois conjuntos</td>
      <td>xor(a, b)</td>
      <td>{‘a’, ‘b’} ^ {‘a’, ‘c’} == {‘c’, ‘b’}</td>
    </tr>
    <tr>
      <td>-</td>
      <td>Diferença de dois conjuntos</td>
      <td>sub(a, b)</td>
      <td>{‘a’, ‘b’} - {‘a’} == {‘b’}</td>
    </tr>
    <tr>
      <td>&gt;</td>
      <td>Testa se a quantidade é um superconjunto verdadeiro</td>
      <td>gt(a, b)</td>
      <td>assert {‘a’, ‘b’} &gt; {‘a’}</td>
    </tr>
    <tr>
      <td>&gt;=</td>
      <td>Testa se o conjunto é um superconjunto</td>
      <td>ge(a, b)</td>
      <td>assert {‘a’} &gt;= {‘a’}</td>
    </tr>
    <tr>
      <td>&lt;</td>
      <td>Testa se a quantidade é um subconjunto verdadeiro</td>
      <td>lt(a, b)</td>
      <td>assert {‘a’} &lt; {‘a’, ‘b’}</td>
    </tr>
    <tr>
      <td>&lt;=</td>
      <td>Testa se a quantidade é um subconjunto</td>
      <td>le(a, b)</td>
      <td>assert {‘a’} &lt;= {‘a’}</td>
    </tr>
  </tbody>
</table>

### Operadores de associação

Os operadores Python de associação *in* e *not in* indicam se um **objeto está incluído em uma coleção**.

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>*in*</td>
      <td>Testa se um objeto está incluído em um iterável</td>
      <td>contains(a, b)</td>
      <td>‘y’ in ‘Python’</td>
    </tr>
    <tr>
      <td>*not in*</td>
      <td>Negação do operador *in*</td>
      <td>not contains(a, b)</td>
      <td>‘x’ not in ‘Python’</td>
    </tr>
  </tbody>
</table>

Operadores de associação trabalham com **iteráveis** e realizam uma **verificação de igualdade** para determinar se o objeto em foco está presente na coleção:

```python
'Py' in 'Python'
'Px' not in 'Python'
'Jack' in ['Jim', 'Jack']
```

A utilização do operador *in* facilita a escrita de códigos da seguinte forma:

```python
def my_in(target, collection):
    for element in collection:
        if element == target:
            return true
    return False
# test
word = 'Python'
letter = 'y'
assert (my_in(letter, word)) == (letter in word)
```

### Operador de concatenação

Operadores Python de concatenação são usados para **concatenar sequências do mesmo tipo**. O símbolo do operador é o sinal de mais.

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>+</td>
      <td>Liga duas sequências</td>
      <td>add(a, b)</td>
      <td>\[‘Jim’\] + \[‘Jack’, ‘John’\]</td>
    </tr>
  </tbody>
</table>

Observe os exemplos a seguir. No primeiro, concatenamos **duas *strings*, duas listas e duas tuplas**:

```python
assert "Walter" + "White" == 'WalterWhite'
assert ['a', 'b'] + ['c'] == ['a', 'b', 'c']
assert ('q', 'r') + ('s', 't') == ('q', 'r', 's', 't')
```

Python é usado como [linguagem de programação web](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web"). Assim sendo, operadores de concatenação podem ser usados, por exemplo, para criar [*tags* HTML](https://www.ionos.com/digitalguide/websites/web-development/html-tags/ "Tags HTML"):

```python
site_title = 'Bem-vindo'
print('&lt;h1&gt;' + site_title + '&lt;/h1&gt;')
```

Operadores de concatenação são diferentes em [Python e PHP](https://www.ionos.com/digitalguide/websites/web-development/php-vs-python/ "PHP vs. Python"). O PHP usa o ponto final (“.”) como símbolo. Segue, abaixo, exemplo em **PHP**:

```php
$siteTitle = 'Bem-vindo';
echo '&lt;h1&gt;' . $siteTitle . '&lt;/h1&gt;';
```

### Operadores de indexação e fatiamento

O operador Python de indexação é usado para **extrair** um elemento específico de uma coleção, ao passo que o operador de fatiamento é usado para extrair uma subsequência.

<table>
  <thead>
    <tr>
      <th><strong>Operador Python</strong></th>
      <th><strong>Função</strong></th>
      <th><strong>Função *operator</strong>*</th>
      <th><strong>Exemplo</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>iterable\[index\]</td>
      <td>Retorna o elemento de um iterável localizado sob o *index*</td>
      <td>getitem(iterable, index)</td>
      <td>‘Python’\[1\] == ‘y’</td>
    </tr>
    <tr>
      <td>sequence\[start:stop:step\]</td>
      <td>Retorna uma fatia (*slice*) de uma sequência</td>
      <td>getitem(iterable, slice(start, stop, step))</td>
      <td>‘Python’\[0:1\] == ‘Py’, ‘Python’\[0:-1:2\] == ‘Pto’</td>
    </tr>
  </tbody>
</table>

Operadores Python de indexação e fatiamento recorrem ao método Dunder *\_\_getitem\_\_()*, por meio de um *index* numérico ou de uma fatia (*slice*) do objeto:

```python
names = ['Jim', 'Jack', 'John']
names[0] == names.\_\_getitem\_\_(0)
names[0:2] == names.\_\_getitem\_\_(slice(0, 2))
```

O operador de fatiamento é prático, pois permite **extrair uma subsequência** sem que seja necessário o uso de um [Python *loop for*](https://www.ionos.com/digitalguide/websites/web-development/python-for-loop/ "Python loop for") ou de um [Python *loop while*](https://www.ionos.com/digitalguide/websites/web-development/python-while-loop/ "Python loop while"). Isso permite que programadores escrevam um código mais conciso. Observe:

```python
word = 'Python'
start, stop, step = 0, 5, 2
index, substring = start, ''
while index in range(start, stop, step):
    substring += word[index]
    index += step
# test
assert substring == word[start:stop:step]
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-python/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-python/) for AI/LLM consumption.