Operadores Python: O Guia Completo

Precisando saber tudo sobre os operadores Python?

Então veja nesse post todos os tipos de operadores usados em Python e os detalhes de como funcionam.

Diferença Entre Operador e Operando

Antes de conhecer os operadores usados em Python, é importante entender alguns conceitos, começando pelos exemplos a seguir, que mostram operações simples de adição e multiplicação feitas na linguagem Python.

>>> x = 10
>>> y = 3
>>> z = x + y
>>> z
13
>>> z = x * y
>>> z
30
>>> z = z * 2
>>> z
60
Code language: Python (python)

Nesses exemplos, as variáveis x, y, z e o valor literal 2 são os operandos e os símbolos +, * e = são os operadores.

Mas talvez você ainda tenha uma dúvida…

O que são operadores em programação?

Os operadores são símbolos que servem para manipular valores, atribuir resultados de operações, fazer comparações e tomar decisões lógicas.

Eles são as engrenagens que fazem um programa funcionar.

A união de operadores e operandos para produzir um resultado, como nas linhas 3, 6 e 9, é chamada de expressão.

Observe que os operandos podem ser variáveis, valores literais ou até mesmo outras expressões.

Agora que você já entendeu o que são operadores, operandos e expressões, vai perceber que é comum classificar os operadores de duas formas, pelo número de operandos, ou pelo tipo de operação que executam.

Em relação ao número de operandos, os operadores podem ser classificados em:

Operadores Unários – Aceitam só um operando. Em Python, eles são -, +, ~, not (negação unária, positivo unário, negação bitwise e negação lógica). Observe que a linguagem Python não tem os operadores unários de adição ++ e subtração -- encontrados em outras linguagens, como C e Java.

Operadores Binários – Utilizam dois operandos para formar uma expressão.

Operadores Ternários – Também conhecidos como expressões condicionais ou “if ternário python“, precisam de dois operandos e uma expressão. Têm a forma <operando1> if <expressão> else <operando2>.

Para entender em detalhes como funciona o operador ternário em Python, veja esse post sobre declarações condicionais, que tem uma seção inteira sobre o operador ternário.

Essa classificação parece complicada, mas é fácil de entender. Veja alguns exemplos abaixo.

#  Operadores Unários:
>>> x = True
>>> y = not x  #  O operador “not” inverte o valor booleano de x.
>>> y
False
>>> a = -8
>>> b = -a  #  O operador “-“ inverte o sinal de a.
>>> b
8

#  Operadores Binários:
>>> a = 0.1
>>> b = 2
>>> a / b  #  Os operandos são o dividendo e o divisor.
0.05
>>> x = True
>>> y = False
>>> x or y  #  Operador binário “or”.
True

#  Operador Ternário
>>> a = 10
>>> b = 0
#  O 1o operando é zero, o 2o é a condição (b == 0) e o 3o é (a / b).
#  Se a condição for falsa, a expressão do 3o operando não é executada.
#  Isso evita o erro de divisão por zero.
>>> 0 if b == 0 else a / b
0
>>> b = 5
>>> 0 if b == 0 else a / b
2.0Code language: Python (python)

Em linguagens como C e Java, a condição aparece como 1º operando dos operadores ternários.

Caso essa condição seja verdadeira, o resultado é a expressão do 2º operando. Caso seja falsa, o resultado é a expressão do 3º operando.

Como você viu no último exemplo acima, em Python a sintaxe é diferente, com a troca de posição do 1º operando e da condição.

//  Exemplo em Java:
a = 10
b = 0
b == 0 ? 0 : a / b  //  Operador ternárioCode language: Java (java)

O operador mais simples é o de atribuição “=“. Se você já leu o meu post sobre variáveis , sabe que esse operador atribui a expressão do lado esquerdo à variável do lado direito. Se ainda não leu, sugiro que você leia antes e depois volte aqui para entender os operadores.

Nas seções a seguir, os operadores são classificados quanto ao tipo de operação que executam, sem considerar o número de operandos.

Quais São os Operadores Aritméticos em Python?

Alguns dos operadores aritméticos em Python são semelhantes aos usados na Matemática básica. Por isso, são os mais familiares.

Tabela de operadores aritméticos em Python:

Operador	Descrição	Exemplos
+	Adição. Retorna o resultado da soma de dois operandos.	x + y
-(binário)	Subtração. Diminui o valor do 2º operando do valor do 1º e retorna o resultado.	x - y
-(unário)	Negação. Retorna o mesmo valor do operando, mas com o sinal invertido. (Também existe o operador unário +, mas ele retorna o valor do operando sem alteração.)	-x
*	Multiplicação. Retorna o resultado da multiplicação de dois operandos.	x * y
/	Divisão. Divide o 1º operando (dividendo) pelo 2º (divisor). Sempre retorna um número do tipo float, mesmo que a divisão seja exata.	x / y
//	Divisão inteira. Divide o 1º operando (dividendo) pelo 2º (divisor) e retorna um número inteiro sempre arredondado para baixo.	x // y 11 // 3 11 // -3
**	Exponenciação. Retorna o resultado do 1º operando elevado à potência do 2º.	x ** y
%	Módulo. Retorna o resto da divisão inteira do 1º operando (dividendo) pelo 2º (divisor). Em Python, o operador Módulo sempre retorna o resultado com o mesmo sinal do divisor.	x % y 11 % 3 -11 % 3 11 % -3

Veja a seguir os resultados da execução dos exemplos da tabela acima no interpretador Python.

>>> x = 11
>>> y = 3
>>> x + y  #  Adição
14
>>> x - y  #  Subtração
8
>>> -x  #  Negação
-11
>>> x * y  #  Multiplicação
33
>>> x / y  #  Divisão
3.6666666666666665
>>> x // y  #  Divisão inteira
3
>>> x // - y  #  Divisão inteira com um operando negativo
-4
>>> x ** y  #  Exponenciação
1331
>>> x % y  #  Módulo
2Code language: Python (python)

Como eu disse lá no início, a linguagem Python não tem os operadores unários de adição ++ e subtração --.

>>> y = 3
>>> y++
  File "<stdin>", line 1
    y++
      ^
SyntaxError: invalid syntaxCode language: Python (python)

No entanto, em Python você pode simplificar o seu código com os operadores de atribuição aumentada, que você vai ver mais adiante nesse post.

Quais São os Operadores Relacionais em Python?

Os operadores relacionais também são conhecidos como operadores de comparação.

A principal característica dos operadores relacionais é que todos são binários, já que relacionam (ou comparam) dois operandos, sempre retornando verdadeiro ou falso.

Por esse motivo, é comum serem usados em estruturas de controle do fluxo do programa, como if e while.

Mas atenção:

Ao contrário dos operadores aritméticos, os operadores relacionais não devem ser confundidos com os operadores usados na Matemática básica.

Por exemplo, em programação, a expressão 10 < 3 (dez é menor que três?) funciona como um teste e sempre retorna falso. Em Matemática, dizer que 10<3 (dez é menor que três) é uma afirmação incorreta, porque contraria os princípios matemáticos dos números inteiros.

Tabela de operadores relacionais em Python:

Operador	Descrição	Exemplos
==	Igualdade. Compara se os valores de dois operandos são iguais. Retorna True se forem iguais e False se não forem. Esse operador não compara se dois operandos se referem ao mesmo objeto. Para isso, veja o operador is abaixo. Além disso, não confunda o operador de igualdade com o operador de atribuição “=”.	x == y x == 10 10 == 3 10 = 3 # Erro!
!=	Desigualdade. Compara se os valores de dois operandos são diferentes. Retorna True se forem diferentes e False se não forem. Esse operador não compara se dois operandos se referem a objetos diferentes. Para isso, veja o operador is not abaixo.	x != y x != 10 10 != 3
>	Maior que. Retorna True se o operando à esquerda for maior que o operando à direita e False se for menor ou igual.	x > y x > 10 10 > 3
>=	Maior que ou igual. Retorna True se o operando à esquerda for maior ou igual ao operando à direita e False se for menor.	x >= y x >= 10
<	Menor que. Retorna True se o operando à esquerda for menor que o operando à direita e False se for maior ou igual.	x < y x < 10 10 < 3
<=	Menor que ou igual. Retorna True se o operando à esquerda for menor ou igual ao operando à direita e False se for maior.	x <= y x <= 10
is	Identidade. Retorna True se os dois operandos se referem ao mesmo objeto.	a is b
is not	Negação de identidade. Retorna `True se os dois operandos se referem a objetos diferentes.	a is not b

Veja a seguir os resultados da execução dos exemplos da tabela acima no interpretador Python.

>>> x = 10
>>> y = 3
>>> x == y
False
>>> x == 10
True
>>> 10 == 3
False
>>> 10 = 3 # Erro!
  File "<stdin>", line 1
SyntaxError: can''t assign to literal
>>> x != y
True
>>> x != 10
False
>>> 10 != 3
True
>>> x > y
True
>>> x > 10
False
>>> 10 > 3
True
>>> x >= y
True
>>> x >= 10
True
>>> x < y
False
>>> x < 10
False
>>> 10 < 3
False
>>> x <= y
False
>>> x <= 10
True
#  Identidade
>>> a = 500
>>> b = 499 + 1
>>> a
500
>>> b
500
>>> a is b
False
>>> a is not b
True
>>> a = b
>>> a is b
TrueCode language: Python (python)

Se você leu o meu post sobre tipos de dados primitivos em Python, sabe que as operações de ponto-flutuante podem produzir resultados aproximados em alguns casos.

Dessa forma, tenha cuidado quando comparar números do tipo float, ou pode ter um resultado inesperado. Por exemplo:

>>> valor = 1.2 - 0.1 - 0.1
>>> valor == 1.0
False
>>> valor
0.9999999999999999Code language: Python (python)

Uma solução seria sempre arredondar o valor após o cálculo, já que os erros nas operações de ponto-flutuante são pequenos e os valores produzidos são próximos dos esperados.

Mas preste atenção ao número de casas decimais, ou a função round() vai arredondar o valor para o número inteiro mais próximo.

>>> valor = round(1.2 - 0.1 - 0.1, 2)  #  Duas casas decimais
>>> valor == 1.0
TrueCode language: Python (python)

Outra característica da linguagem Python é que não é necessário comparar as expressões relacionais com True, pois esse é o comportamento padrão.

Essa sintaxe abreviada é usada nas condições if:

>>> (x == 10) == True  #  Desnecessário
True
>>> x == 10
True
>>> if x == 10:  #  Não é preciso escrever if (x == 10) == True:
...     y = 20
...
>>> y
20Code language: Python (python)

Quais São os Operadores Lógicos em Python?

Os operadores lógicos também são chamados de operadores booleanos. Eles são a base da lógica booleana.

Por esse motivo, há tanto para dizer sobre os operadores lógicos, que seria necessário um post inteiro só sobre esse assunto.

No entanto, vou resumir nessa seção o que você precisa saber para começar a usar esses operadores nos seus programas em Python.

Tabela de operadores lógicos em Python:

Operador	Descrição	Exemplos
and	E lógico. Retorna verdadeiro apenas se ambos os operandos forem verdadeiros e falso se ao menos um dos operandos for falso.	x and y False and True
or	OU lógico. Retorna verdadeiro se ao menos um dos operandos for verdadeiro e falso se ambos os operandos forem falsos.	x or y False or True
not	Não lógico. Operador unário que retorna o valor do operando invertido logicamente.	not x not True not False

Para ficar mais fácil de entender essas definições, veja a seguir a tabela verdade para cada um desses operadores. Essas tabelas mostram o resultado para cada combinação de operandos.

Tabela verdade para E lógico:

x	y	x and y
True	True	True
True	False	False
False	True	False
False	False	False

Tabela verdade para OU lógico:

x	y	x or y
True	True	True
True	False	True
False	True	True
False	False	False

Tabela verdade para NÃO lógico:

x	not x
True	False
False	True

Veja a seguir os resultados da execução dos exemplos acima no interpretador Python.

>>> x = True
>>> y = False
>>> x and y
False
>>> False and True
False
>>> x or y
True
>>> False or True
True
>>> not x
False
>>> not True
False
>>> not False
TrueCode language: Python (python)

Os operadores lógicos em Python funcionam no método de avaliação de curto-circuito.

Nesse método, os operandos são avaliados da esquerda para a direita e a avaliação é interrompida quando for possível determinar o resultado.

Na prática, isso significa que se o primeiro operando de um E lógico for negativo, o resultado será falso e o segundo operando nem será avaliado.

Da mesma forma, se o primeiro operando de um OU lógico for verdadeiro, o resultado será verdadeiro e o segundo operando nem será avaliado.

Isso é muito útil em situações onde você quer testar uma condição antes de executar uma expressão. Veja o exemplo a seguir, onde o operador and é usado para evitar uma divisão por zero.

>>> a = 10
>>> b = 0
>>> (b != 0) and (a / b)
FalseCode language: Python (python)

O operando (b != 0) retorna False e por isso a divisão não é executada.

E como você viu, a linguagem Python sempre testa se o resultado de uma expressão lógica é verdadeiro, então você nem precisa usar o operador relacional de desigualdade != nessa primeira expressão.

>>> a = 10
>>> b = 0
>>> b and (a / b)  # Se b está em uma expressão lógica, ele é comparado com True
0Code language: Python (python)

Mas, nesse caso, em vez de False, o valor de b (zero) é retornado, ao ser avaliado como falso.

Por que isso acontece?

Observe que os operandos das expressões lógicas precisam sempre ser avaliados como True ou False.

Então, com variáveis do tipo booleano ou expressões que retornam um valor booleano, como x <= 10, fica fácil de entender os operadores lógicos.

Mas… e para os demais tipos de dados, como números, caracteres e objetos?

Como regra, os objetos em Python podem ser considerados verdadeiros.

Mas há algumas exceções.

Os seguintes objetos embutidos na linguagem Python são considerados falsos:

• Constantes falsas: None e False (essa é meio óbvia, não é?).
• Qualquer tipo numérico com valor zero: 0 (int), 0.0 (float), 0j (complex), decimal.Decimal(0), fractions.Fraction(0, 1)
• Strings, coleções e sequências vazias: '', (), [], {}, set(), range(0)
• Qualquer objeto que tenha um método __bool__() que retorne falso ou um método __len__() que retorne zero (não precisa se preocupar com esses casos agora).

Na dúvida, para saber se um objeto é verdadeiro ou falso em Python, você pode usar a função bool().

>>> bool('a')
True
>>> bool(0.0)
False
>>> bool([])
False
>>> bool([0])  #  Testa se a lista é vazia. Não é, pois tem um elemento 0.
True
>>> bool(None)
FalseCode language: Python (python)

Isso explica porque o valor zero de b foi considerado falso no exemplo b and (a / b).

Mas ainda faltou explicar por que foi retornado o valor de b (zero), em vez de False.

Uma coisa que você deve levar em consideração quando for usar operadores lógicos com qualquer tipo de objeto, é que o retorno não é True ou False.

Em vez disso, a avaliação da expressão retorna o último operando avaliado, dependendo do resultado.

O código a seguir deixa claro como isso funciona.

>>> 'a' and 'b' # 'a' é verdadeiro, então 'b' é avaliado
'b'
>>> '' and 'b' # '' é falso, então 'b' não é avaliado
''
>>> 'a' or 'b' # 'a' é verdadeiro, então 'b' não é avaliado
'a'
>>> '' or 'b' # '' é falso, então 'b' é avaliado
'b'Code language: Python (python)

E não precisa se preocupar com esses retornos literais, porque eles também são interpretados pela linguagem Python como se fossem valores booleanos.

>>> if '' and 'b':
...     print('Não vai entrar aqui.')
... else:
...     print("Eu sei que string vazia '' é False!")
...
Eu sei que string vazia '' é False!Code language: Python (python)

Quais São os Operadores Bitwise (bit a bit) em Python?

Os operadores bitwise atuam sobre cada bit dos operandos, daí o seu nome.

Por isso, as operações sobre bits só fazem sentido em números inteiros.

Afinal de contas, não daria certo interferir no código binário de um objeto e esperar um resultado íntegro, não é?

Em sistemas sujeitos a radiação, descargas eletromagnéticas ou grandes variações de temperatura, como foguetes espaciais, existe um controle rígido de erros da memória, para evitar que um bit flip produza um resultado catastrófico.

Então não pense que os operadores bitwise vão fazer de você um hacker que vai manipular bits de forma indiscriminada. Cada vez que o seu código altera algum bit, o máximo que ele faz é mudar o valor de um número.

Tabela de operadores bitwise (bit a bit) em Python:

Operador	Descrição	Exemplos
&	E bit a bit. Retorna um número onde cada bit é o resultado da comparação “E lógico” entre os bits dos operandos na mesma posição, ou seja, 1 se ambos os bits forem 1 e 0 se ao menos um dos bits for 0.	x & y
|	OU bit a bit. Retorna um número onde cada bit é o resultado da comparação “OU lógico” entre os bits dos operandos na mesma posição, ou seja, 1 se ao menos um dos bits for 1 e 0 se ambos os bits forem 0.	x | y
~	Negação bit a bit. Retorna um número onde cada bit do operando é invertido, ou seja, se for 0, se torna 1 e se for 1, se torna 0.	~x
^	OU exclusivo bit a bit (XOR). Retorna um número onde cada bit é o resultado da comparação “OU exclusivo lógico (XOR)” entre os bits dos operandos na mesma posição, ou seja, 1 se os bits forem diferentes e 0 se os bits forem iguais.	x ^y
>>	Deslocamento à direita. Retorna um número com os bits deslocados n posições à direita. O valor de n deve ser positivo. Um deslocamento à direita é a mesma coisa que multiplicar o operando por 2n.	x >> n
<<	Deslocamento à esquerda. Retorna um número com os bits deslocados n posições à esquerda. O valor de n deve ser positivo. Um deslocamento à esquerda é a mesma coisa que fazer a divisão inteira do operando por 2n.	x << n

Veja a seguir os resultados da execução dos exemplos acima no interpretador Python.

>>> x = 0b01010111  # Número em binário
>>> x
87
>>> y = 0b11100010
>>> y
226
>>> x & y
66
>>> '0b{:08b}'.format(x & y)  #  Sintaxe para formatar como binário.
'0b01000010'
>>> '0b{:08b}'.format(x | y)
'0b11110111'

>>> #  Demonstração dos resultados:
>>> #  01010111
... # &11100010
... #  01000010
...
>>> #  01010111
... # |11100010
... #  11110111

>>> '0b{:08b}'.format(x ^ y)
'0b10110101'
>>> '0b{:08b}'.format(~y)
'0b-11100011'
>>> x = 32
>>> n = 4
>>> fator = 2 ** n
>>> x << n
512
>>> x * fator
512
>>> x >> n
2
>>> x // fator
2Code language: Python (python)

Apesar de não parecerem comuns, os operadores bitwise são muito úteis em algumas situações.

Por exemplo, imagine um sistema que controla permissões de usuários. Cada permissão pode ser representada por um bit em um número inteiro.

Se o bit está ligado (1), o usuário tem aquela permissão. Se está desligado (0), o usuário não tem a permissão. Para atribuir as permissões a um usuário, bastaria fazer um OU bit a bit “|” das permissões atuais do usuário com a permissão correspondente. Por exemplo:

>>> PERM_CONSULTA = 0b00000001  #  Número 1 em binário mostrando 8 bits
>>> PERM_CRIAR    = 0b00000010
>>> PERM_APAGAR   = 0b00000100
>>> permUsuario   = 0b00000000  #  Começa sem permissão alguma

>>> permUsuario = permUsuario | PERM_CONSULTA | PERM_APAGAR
>>> f'0b{permUsuario:08b}'  #  Sintaxe para imprimir o número em binário.
'0b00000101'Code language: Python (python)

De forma semelhante, para verificar se um usuário tem uma permissão, basta fazer um E bit a bit “&”. O resultado será 0 (False) se o usuário não tiver a permissão e 1 (True) se ele tiver.

>>> permUsuario & PERM_CRIAR
0
>>> permUsuario & PERM_CONSULTA
1Code language: Python (python)

A vantagem desse código é que o usuário pode ter qualquer combinação de permissões sem que você tenha que fazer vários ifs para verificar cada combinação possível.

Além disso, essas operações são muito rápidas.

Quais São os Operadores de Atribuição Aumentada em Python?

Os operadores aritméticos em Python não permitem que você incremente ou decremente uma variável numérica usando a sintaxe simplificada da linguagem C.

Isso significa que os operadores unários ++ e -- não estão disponíveis em Python.

No entanto, há um outro tipo de simplificação que você pode usar para tornar seu código mais legível e que se aplica aos operadores aritméticos e bitwise.

Eu estou falando dos operadores de atribuição aumentada. Eles funcionam de forma semelhante ao operador de atribuição “=”, mas incluem um outro operador que é usado durante essa atribuição.

Em uma atribuição comum, o valor da expressão do lado direito é avaliado e atribuído à variável do lado esquerdo:

>>> x = 10
>>> x = x + 3
>>> x
13
>>> y = 6 + 1
>>> x = x * y
>>> x
70Code language: Python (python)

Como você pode ver nos exemplos acima, a expressão atribuída à variável pode conter variáveis ou valores literais.

Os operadores de atribuição aumentada são usados quando a própria variável que recebe o novo valor faz parte da expressão do lado direito.

Os exemplos acima poderiam ser escritos dessa forma:

>>> x = 10
>>> x += 3  #  Mesmo que x = x + 3
>>> x
13
>>> y = 6 + 1
>>> x *= y  #  Mesmo que x = x * y
>>> x
70Code language: Python (python)

Os operadores de atribuição aumentada só têm correspondentes para operadores aritméticos e bitwise binários.

Tabela de operadores de atribuição aumentada em Python:

Operador	Descrição	Exemplos
+=	Igual ao operador aritmético de Adição.	x += y
-=	Igual ao operador aritmético de Subtração.	x -= y
*=	Igual ao operador aritmético de Multiplicação.	x *= y
/=	Igual ao operador aritmético de Divisão.	x /= y
//=	Igual ao operador aritmético de Divisão inteira.	x //= y
**=	Igual ao operador aritmético de Exponenciação.	x **= y
%=	Igual ao operador aritmético de Módulo.	x %= y
&=	Igual ao operador bitwise E bit a bit.	x &= y
|=	Igual ao operador bitwise OU bit a bit.	x |= y
^=	Igual ao operador bitwise OU exclusivo bit a bit (XOR).	x ^= y
>>=	Igual ao operador bitwise Deslocamento à direita.	x >>= n
<<=	Igual ao operador bitwise Deslocamento à esquerda.	x <<= n

Veja a seguir os resultados da execução dos exemplos acima no interpretador Python.

>>> x = 10
>>> y = 3
>>> x += y
>>> x
13
>>> x, y = 10, 3 # Para facilitar. Não faça isso na vida real!
>>> x -= y
>>> x
7
>>> x, y = 10, 3
>>> x *= y
>>> x
30
>>> x, y = 10, 3
>>> x /= y
>>> x
3.3333333333333335
>>> x, y = 10, 3
>>> x //= y
>>> x
3
>>> x, y = 10, 3
>>> x **= y
>>> x
1000
>>> x, y = 10, 3
>>> x %= y
>>> x
1
>>> x, y = 10, 3
>>> x &= y
>>> x
2
>>> x, y = 10, 3
>>> x |= y
>>> x
11
>>> x, y = 10, 3
>>> x ^= y
>>> x
9
>>> x, y = 10, 3
>>> x >>= y
>>> x
1
>>> x, y = 10, 3
>>> x <<= y
>>> x
80Code language: Python (python)

Qual é a Ordem de Precedência de Operadores em Python?

Se você encontrar a expressão x = 100 – 10 / 5 em um programa, na hora vai saber que o valor de x é 98 e não 18.

Isso porque a execução dessas operações segue o mesmo padrão das operações matemáticas, às quais você está acostumado.

Nesse exemplo, a divisão tem precedência sobre a subtração.

Mas e se você encontrar uma expressão como essa:

>>> x, y = 10, 3
>>> x = x // y & -x  #  Qual operador executa primeiro?Code language: Python (python)

Qual é o valor de x depois da avaliação da expressão?

Para responder a essa pergunta, é preciso conhecer a ordem de precedência de operadores em Python.

A tabela a seguir define a ordem de precedência dos operadores, da maior precedência para a menor. Seguindo as instruções dessas tabela, você descobre que o resultado do exemplo acima é 2.

Operadores com maior precedência são executados primeiro. Depois, os de precedência menor, até o fim da lista.

Operadores com a mesma precedência, mostrados em uma mesma linha da tabela, são executados da esquerda para a direita.

Tabela de precedência de operadores em Python:

Operadores	Descrição
**	Exponenciação.
-, +, ~	Negação unária, positivo unário e negação bitwise.
*, /, //, %	Multiplicação, divisão, divisão inteira e módulo.
+, -	Adição e subtração (binários).
<<, >>	Deslocamento à esquerda, deslocamento à direita.
&	E bit a bit.
^	OU exclusivo bit a bit (XOR).
|	OU bit a bit.
==, !=, <, <=, >, >=, is, is not	Todos os operadores relacionais e de identidade.
not	Não lógico.
and	E lógico.
or	OU lógico.

Você pode usar parênteses “()” para interferir na ordem de execução dos operadores da tabela acima.

Nesse caso, se o meu exemplo inicial fosse escrito x = (100 – 10) / 5, o resultado seria 18.

Na prática, sempre é melhor escrever a expressão com todos os parênteses, já indicando a ordem de execução das operações.

Assim, quem for fazer manutenção no seu código já sabe de imediato qual é a sequência de operações esperada.

Afinal, ninguém é obrigado a ficar decorando tabela de precedência de operadores…

Conclusão

Nesse post você viu o que são operadores, operandos, expressões e quais são os operadores usados na linguagem Python.

Viu também que eles podem ser unários, binários ou ternários, dependendo do número de operandos e que são diferenciados pelo tipo de operação que executam.

Depois de ler esse post, espero que você tenha percebido que conhecer o funcionamento dos operadores é fundamental para programar em qualquer linguagem.

E que, apesar de existirem algumas diferenças na sintaxe dos operadores entre linguagens de programação, a forma de pensar e executar operações é sempre a mesma.

Ou seja, mais uma vez eu quis deixar claro que aprender a pensar como um programador é mais importante do que aprender a sintaxe de uma linguagem de programação.

Por isso, pratique bastante o uso dos operadores e nunca fique sem entender algum conceito.

Não esqueça de comentar a sua experiência aqui embaixo e dizer como eu posso melhorar esse post!