Matricule-se
Voltar para o blog
Python

Operadores no Python: principais tipos com exemplos

Heitor Catunda

Operadores no Python são símbolos ou palavras que executam operações sobre valores, como +, **, ==, and, is e in. Eles abrangem cálculos, comparações, lógica, atribuição, identidade, pertencimento e operações bit a bit. O resultado e a precedência dependem do operador e dos tipos envolvidos.

Se quiser pode acompanhar esse conteúdo em formato de vídeo ou pode acessar o nosso Canal do YouTube para mais vídeos!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Operadores no Python

Os operadores são uma parte fundamental da programação, e em Python isso não é diferente. Com eles, conseguimos realizar cálculos, manipular variáveis e implementar lógicas no código.

Nesta aula, vamos explorar detalhadamente como cada tipo de operador funciona e como você pode aplicá-los de maneira prática e eficiente para resolver problemas em seus códigos.

Os operadores podem ser símbolos, como + e <=, ou palavras reservadas, como and, is e in. Alguns tipos também personalizam o comportamento de operadores; por exemplo, + soma números e concatena sequências compatíveis.

Mas, afinal, quais são essas operações? Ou melhor, quais tipos de operadores temos no Python? Vamos ver:

  • Operadores aritméticos
  • Operadores de atribuição (assignment)
  • Operadores de comparação
  • Operadores lógicos
  • Operadores de identidade
  • Operadores de pertencimento (in e not in)
  • Operadores bit a bit e de deslocamento

Além dos grupos detalhados a seguir, Python oferece exponenciação (**), operadores bit a bit (&, |, ^, ~) e deslocamentos (<<, >>). O símbolo @ representa multiplicação de matrizes para tipos que implementam essa operação. Consulte a referência oficial de expressões e precedência.

É possível que você já tenha encontrado alguns desses operadores em outras linguagens de programação, pois muitos não são exclusivos do Python! Porém, existem alguns outros que você não vê com tanta frequência!!

Operadores Aritméticos

Os operadores aritméticos no Python são responsáveis por realizar as operações matemáticas fundamentais, como adição e subtração.

Esses operadores são usados em cálculos, análises de dados e inúmeras outras aplicações práticas.

Dentro do Python, temos os seguintes operadores aritméticos:

  • Soma (+)
  • Subtração (-)
  • Divisão (/)
  • Multiplicação (*)
  • Exponenciação (**)
  • Módulo (%)
  • Divisão por piso (//)

Soma (+)

Acho que esse é o operador mais comum, e é bem intuitivo, com o símbolo (+), que serve para somar valores dentro do Python. Lembrando que isso se aplica tanto a valores quanto a variáveis que armazenam esses valores!

Subtração (-)

A subtração usa o sinal -. Da mesma forma que a soma, podemos fazer esses cálculos tanto com valores quanto com variáveis dentro do Python.

Divisão(/)

A divisão já pode ser uma novidade para algumas pessoas e tem o símbolo (/) para indicar que estamos dividindo uma informação por outra, seja ela variável ou valor!

Multiplicação (*)

A multiplicação usa *. Para elevar um número a uma potência, use **: por exemplo, 2 ** 3 resulta em 8.

Mod (%)

O operador módulo % retorna o resto compatível com a divisão por piso. Com operandos positivos, 10 % 3 resulta em 1.

Ele é lido como “10 módulo 3”. Em Python, vale a relação x == (x // y) * y + (x % y), inclusive quando há operandos negativos.

Python
num1 = 10
num2 = 3

print("Resto da divisão:")
print(num1%num2)
Mod (%)

Esse operador é muito comum quando queremos identificar se um número é ímpar ou par. Se fizermos qualquer número mod 2, e o resto for 0, isso indica que a divisão é exata, ou seja, é um número par. Caso contrário, o número será ímpar!

Divisão por piso (//)

Apesar do nome informal “parte inteira”, // faz divisão por piso: arredonda o quociente para baixo, em direção ao infinito negativo. Assim, 10 // 3 resulta em 3, mas -10 // 3 resulta em -4, e não -3.

Esse operador é bem interessante para alguns cálculos, e você já pode tê-lo visto, por exemplo, em conversões de hora.

Python
num1 = 10
num2 = 3

print("Divisão por piso:")
print(num1 // num2)
Divisão por piso (//)

Exemplo prático

Podemos utilizar os operadores aritméticos para realizar cálculos dentro do nosso código, como calcular o lucro de uma empresa.

Python
faturamento = 400
custo = 150

lucro = faturamento - custo

print("O lucro foi de:")
print(lucro)
Calculando lucro com Python

Operadores de atribuição (assignment)

A atribuição simples usa =. As atribuições aumentadas combinam uma operação com a atribuição, como +=, -= e **=; quando o tipo permite, algumas delas podem atualizar o objeto existente em vez de criar outro.

Os operadores de atribuição são muito comuns em estruturas de repetição, ou seja, quando temos um for ou while, por exemplo.

Esses operadores são muito úteis, principalmente para facilitar a escrita do código, pois você escreve menos e torna o código mais legível.

As formas de atribuição aumentada são +=, -=, *=, @=, /=, //=, %=, **=, >>=, <<=, &=, ^= e |=. Já := é uma expressão de atribuição, explicada adiante.

Operador =

O sinal = vincula um nome a um valor. Em lucro = 1000, o nome lucro passa a referenciar o objeto inteiro 1000.

Operador +=

Esse é outro operador muito comum e amplamente utilizado em estruturas de repetição. Imagine que você tenha uma estrutura de repetição e, ao final dela, precise adicionar 1 ao seu contador. Como você faria isso?

Python
i = 0

for item in lista:
    i = i + 1

Podemos atualizar a variável com o valor atual mais 1. Com +=, o código fica mais direto:

Python
i = 0

for item in lista:
    i += 1

Para inteiros, i += 1 produz o mesmo valor que i = i + 1. A equivalência não é absoluta para todos os tipos: uma atribuição aumentada pode fazer uma operação in-place quando o objeto a implementa.

Ícone PythonPython Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agoraSeta para a direita
Fundo PythonTelas Python
Luz Python
Python
i = 0

while i < 5:
    print("Se inscreve no canal")
    i += 1
Operador +=

Operadores -=, *=, /=

Assim como temos o operador += para soma, podemos utilizá-lo com outras operações como subtração, multiplicação e divisão.

Essas formas aparecem com frequência quando uma variável precisa acumular, reduzir, escalar ou transformar seu próprio valor.

Por exemplo, saldo -= saque, total *= taxa e media /= quantidade combinam a operação indicada com uma nova atribuição ao nome da esquerda.

Operador := (operador walrus)

Disponível desde o Python 3.8, := é conhecido como operador walrus e cria uma expressão de atribuição.

Esse operador permite atribuir um valor a uma variável ao mesmo tempo em que a utiliza em uma expressão. Isso torna o código mais compacto e eficiente, especialmente em loops e condições.

Normalmente, atribuímos um valor em uma instrução e o usamos depois. Com :=, a atribuição acontece dentro de uma expressão; use o recurso quando ele realmente evitar repetição sem prejudicar a leitura.

Python
print(qtde := 10)
Operador := (operador walrus)

Em print(qtde := 10), o valor 10 é atribuído a qtde e também se torna o resultado da expressão passada a print().

A princípio, esse operador pode parecer confuso, mas ele oferece uma maneira eficiente de atribuir e utilizar valores de forma compacta.

Se quiser saber mais sobre ele, temos um artigo sobre o Operador Walrus que explica detalhadamente como ele funciona: Operador Walrus em Python – O que é e Como Usar?

Operadores de Comparação

Os operadores de comparação são indispensáveis em qualquer linguagem de programação. Eles são usados para comparar dois valores e retornam um resultado booleano (True ou False).

Esses operadores permitem que você tome decisões com base na relação entre os valores, sendo fundamentais para o controle de fluxo em estruturas como if, while e for.

No Python, você encontrará operadores como ==, !=, >, <, >= e <=, que ajudam a verificar igualdade, diferença e relações de magnitude entre os valores.

Operador ==

O operador de igualdade verifica se dois valores são iguais. Se forem, ele retorna True; caso contrário, retorna False.

Python
a = 5
b = 5

print("a é igual a b:")
print(a == b)
Operadores de Comparação ==

Operador !=

Esse operador verifica se dois valores são diferentes. Ele retorna True se os valores forem distintos.

Python
a = 5
b = 3

print("a é diferente de b:")
print(a != b)
Operador !=

Operadores >, <, >=, <=

Esses operadores comparam grandezas entre dois valores:

  • > verifica se o valor à esquerda é maior que o valor à direita.
  • < verifica se o valor à esquerda é menor que o valor à direita.
  • >= e <= verificam se o valor à esquerda é maior ou igual ou menor ou igual ao valor à direita, respectivamente.
Python
a = 7
b = 5

print("a é maior que b:")
print(a > b)

print("a é menor ou igual a b:")
print(a <= b)
Operadores >, <, >=, <=

Operadores Lógicos

Os operadores lógicos and, or e not usam o valor de verdade dos objetos. Os dois primeiros fazem avaliação de curto-circuito e podem retornar um dos operandos, não necessariamente True ou False.

Esses operadores são amplamente utilizados em validações e estruturas de controle, principalmente aquelas que envolvem múltiplas condições e critérios ao mesmo tempo. Eles ajudam a escrever códigos mais claros e eficientes.

Operador and

x and y avalia x primeiro: se x for falso, retorna x sem avaliar y; caso contrário, retorna y. Quando os operandos já são comparações, como no exemplo, o resultado é booleano.

Python
a = 4
b = 8

print("a é maior que 3 E b é menor que 15:")
print(a > 3 and b < 15)
print("a é maior que 3 E b é maior que 15:")
print(a > 3 and b > 15)
Operador and

Operador or

x or y retorna x se x for verdadeiro; caso contrário, avalia e retorna y. Por isso, expressões como nome_digitado or "Anônimo" podem definir um valor padrão.

Python
a = 5
b = 10
print("a é maior que 7 OU b é menor que 15:")
print(a > 7 or b < 15)
print("a é maior que 7 OU b é maior que 15:")
print(a > 7 or b > 15)
Operador or

Operador not

O operador not nega o valor de verdade do operando e sempre retorna um booleano: True ou False.

Por exemplo, not (valor > 5) verifica que valor não é maior que 5. Os parênteses deixam a intenção explícita.

Python
a = 5

print("a NÃO É maior que 3:")
print(not a > 3)
print("a NÃO É maior que 7:")
print(not a > 7)
Operador not

Exemplo Prático

Podemos combinar esses operadores lógicos para fazer uma verificação mais completa. Por exemplo, vamos analisar o lucro, custo e faturamento de uma empresa para definir se essa empresa é uma “Excelente empresa” ou uma “Empresa normal”.

Python
lucro = 800
faturamento = 900
custo = 100


if lucro > 500 or (custo < 200 and faturamento > 800):
    print("Excelente empresa!")
else:
    print("A empresa precisa melhorar")
Operadores Lógicos

Nesse exemplo, verificamos se o lucro é maior que 500 OU se o custo é menor que 200 E o faturamento é maior que 800. Por isso, toda a segunda expressão é colocada entre parênteses para garantir a ordem correta das operações.

Operador de Identidade – Operador is

O operador is verifica identidade de objeto: o resultado é verdadeiro somente quando os dois operandos são o mesmo objeto. A linguagem não define essa regra em termos de um endereço de memória que o programa deva observar.

Não confunda is com ==. Em geral, == compara valores conforme a regra do tipo, enquanto is compara a identidade. Para verificar o singleton nulo, a forma recomendada é valor is None; não use is para comparar números ou textos pelo valor.

O exemplo abaixo mostra a diferença: duas listas podem ter valores iguais sem serem o mesmo objeto.

Python
a = [1, 2, 3]
b = a
c = [1, 2, 3]

print("a e b são o mesmo objeto:")
print(a is b)
print("a e c são o mesmo objeto:")
print(a is c)
Operador de Identidade – Operador is

Como fizemos b = a, b passa a referenciar a mesma lista que a. Já c referencia outro objeto, embora a == c seja verdadeiro por causa dos elementos iguais.

Operador de Pertencimento (Membership) – Operador in

Os operadores de pertencimento são in e not in. Eles verificam se um valor pertence a um contêiner, como lista, tupla, conjunto, string ou dicionário.

in retorna True quando encontra o item; not in nega o teste. Em dicionários, o teste padrão procura chaves, não valores: "nome" in pessoa verifica se a chave "nome" existe.

Por exemplo, ele pode ser usado para verificar se determinados funcionários estão incluídos na lista de vendedores de uma empresa.

Python
lista_vendedores = ["Lira", "João", "Amanda", "Alon", "Larissa"]

print("O Alon é um vendedor:")
print("Alon" in lista_vendedores)

print("O Diego é um vendedor:")
print("Diego" in lista_vendedores)
Operador de Pertencimento (Membership) – Operador in

Nesse exemplo, "Alon" in lista_vendedores retorna True, enquanto "Diego" in lista_vendedores retorna False. A expressão "Diego" not in lista_vendedores retornaria True.

Conclusão – Operadores no Python

Compreender aritmética, atribuição, comparação, lógica, identidade e pertencimento evita erros como confundir is com == ou tratar // como simples descarte das casas decimais.

Ao combinar operadores, confira a precedência ou use parênteses para tornar a intenção clara. A lista completa de tokens e regras está na documentação oficial de operadores do Python.

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Quer aprender mais sobre Python com um minicurso básico gratuito?

Posts mais recentes de Python

Posts mais recentes da Hashtag Treinamentos

Heitor Catunda

Autor do artigo

Heitor Catunda

Gerente de Operações e Especialista em Excel

Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.

Ver mais posts