Operadores Aritméticos e Lógicos em Python

1
2
3
4
5

print(7 / 2)   # 3.5 (sempre float)
print(7 // 2)  # 3   (divisão inteira)
print(7 % 2)   # 1   (resto)
print(2 ** 3)  # 8   (potência)
print(-7 // 2) # -4  (arredonda para baixo!)

Salve, salve Pythonista!

Nesse post vamos falar de Operadores em Python: Operadores Lógicos, Operadores Aritméticos, Operadores de Associação, Operadores de Comparação, Operadores de Identidade e Operadores de Atribuição!

Wow, é muito Operador!

Se você já programa em Python, já se deparou com esses operadores em algum momento: is, is not, ==, in, not in, and, or ou %=.

Nesse post, você vai dominar TODOS esses Operadores e aprender como utilizá-los em seus programas Python!

Está pronto, então vamos aprender sobre Operadores!

Vá Direto ao Assunto…

• Operadores em Python
• Operadores Aritméticos
• O que faz // em Python (divisão inteira)
• O que faz % em Python (resto da divisão)
• O que faz ** em Python (potência)
• Operadores de Comparação
• Operadores de Atribuição
• Operadores Lógicos
• Operadores de Identidade
• Operadores de Associação
• Precedência de operadores em Python
• Tabela-resumo de todos os operadores Python
• Erros comuns
• Exercícios resolvidos

Operadores em Python

Operadores em Python são símbolos especiais (como +, ==, and ou +=) que realizam operações sobre um ou mais valores - fazendo contas, comparando dados ou combinando testes lógicos. Eles permitem que o desenvolvedor transcreva a lógica para código.

Python organiza esses operadores em seis famílias: aritméticos (contas), de comparação (relações entre valores), lógicos (and, or, not), de atribuição (=, +=…), de identidade (is) e de associação (in). Dominá-los é essencial para quem quer se tornar um verdadeiro Pythonista!

Veremos todos em detalhes agora, começando pelos Operadores Aritméticos!

Operadores Aritméticos

Os operadores aritméticos em Python realizam contas matemáticas - soma (+), subtração (-), multiplicação (*), divisão (/), divisão inteira (//), módulo (%) e exponenciação (**).

A lista completa, com as regras para int, float e complex, está na documentação oficial dos tipos numéricos. Veja quais estão disponíveis no Python:

Veja agora a utilização de cada operador aritmético mencionado acima:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

quatro = 4
dois = 2

soma = quatro + dois
print(soma)  # Resultado: 6

subtracao = quatro - dois
print(subtracao)  # Resultado: 2

multiplicacao = quatro * dois
print(multiplicacao)  # Resultado: 8

divisao = quatro / dois
print(divisao)  # Resultado: 2.0

divisao_interna = quatro // dois
print(divisao_interna)  # Resultado: 2

modulo = quatro % dois
print(modulo)  # Resultado: 0

exponenciacao = quatro ** dois
print(exponenciacao)  # Resultado: 16

Casos de borda da divisão e do módulo

Dois detalhes pegam muita gente de surpresa:

1. A divisão / SEMPRE retorna um float, mesmo quando o resultado é exato - diferente da divisão inteira //, que devolve int quando os dois operandos são inteiros:

1
2

print(4 / 2)   # 2.0  (float, mesmo "dividindo certinho")
print(4 // 2)  # 2    (int)

2. Com números negativos, // arredonda para baixo (em direção a -∞) e o % acompanha para manter a relação matemática:

1
2

print(-7 // 3)  # -3  (e não -2: arredonda para baixo)
print(-7 % 3)   # 2   (o resto tem o sinal do divisor)

Esse comportamento é coerente: em Python, (a // b) * b + (a % b) sempre reconstrói o a original.

O que faz // em Python (divisão inteira)

O operador // faz a divisão inteira (em inglês, floor division): divide e arredonda o resultado para baixo, para o inteiro mais próximo em direção ao menos infinito. Com dois int, o resultado é int; se algum operando for float, o resultado é um float sem parte decimal.

1
2
3
4
5

print(7 // 2)     # 3
print(10 // 4)    # 2
print(7.5 // 2)   # 3.0  (float, porque 7.5 é float)
print(7 // 2.0)   # 3.0
print(-7 // 2)    # -4   (e não -3!)

O caso que mais confunde é o do número negativo. -7 / 2 dá -3.5, e arredondar para baixo leva a -4. Isso é diferente de simplesmente “cortar” a parte decimal, que é o que int() faz:

1
2
3
4
5
6

import math

print(-7 // 2)        # -4  (arredonda para baixo, igual a math.floor)
print(math.floor(-3.5))  # -4
print(int(-7 / 2))    # -3  (int() trunca: só descarta o decimal)
print(math.trunc(-3.5))  # -3

Para números positivos, // e int(a / b) dão o mesmo resultado; com negativos, não. Se você precisa do quociente e do resto de uma vez, use a função embutida divmod():

1
2

print(divmod(17, 5))   # (3, 2)  -> 17 // 5 e 17 % 5
print(divmod(-7, 2))   # (-4, 1)

O que faz % em Python (resto da divisão)

O operador % (chamado de módulo) devolve o resto da divisão inteira entre dois números. 7 % 2 dá 1 porque 7 dividido por 2 dá 3 e sobra 1. É o operador por trás de vários truques clássicos:

1
2
3
4
5

print(10 % 3)     # 1
print(8 % 2)      # 0 -> 8 é par (resto zero na divisão por 2)
print(7 % 2)      # 1 -> 7 é ímpar
print(1234 % 10)  # 4 -> último dígito do número
print(7.5 % 2)    # 1.5 (também funciona com float)

Com negativos, o resultado de % sempre tem o sinal do divisor (o número da direita). É o par exato do // arredondando para baixo:

1
2
3

print(-7 % 3)   # 2
print(7 % -3)   # -2
print(-7 % 2)   # 1

Em código mais antigo você vai ver % com strings, como '%s tem %d anos' % ('Ana', 30), que resulta em Ana tem 30 anos. Aí ele não é resto de divisão: é a formatação de texto no estilo antigo. Hoje prefira as f-strings no Python.

/, // ou %: qual usar?

Essa comparação cai muito em prova (as famosas questões de “relacione a coluna A com a coluna B”):

O que faz ** em Python (potência)

O operador ** calcula a potência (exponenciação): a ** b é “a elevado a b”. Funciona com expoentes negativos e fracionários, então também serve para tirar raízes:

1
2
3
4
5

print(2 ** 10)    # 1024
print(4 ** 2)     # 16
print(2 ** -1)    # 0.5  (expoente negativo = 1 / 2)
print(9 ** 0.5)   # 3.0  (raiz quadrada)
print(pow(2, 10)) # 1024 (a função pow() faz o mesmo)

Dois detalhes do ** pegam muita gente:

1
2
3

print(-2 ** 2)     # -4  -> vira -(2 ** 2), pois ** vem antes do sinal de menos
print((-2) ** 2)   # 4   -> com parênteses, eleva o número negativo
print(2 ** 3 ** 2) # 512 -> associativo à direita: 2 ** (3 ** 2) = 2 ** 9

Fora das contas, ** aparece em outros dois lugares: em def funcao(**kwargs), para receber argumentos nomeados (veja *args e **kwargs no Python), e em {**a, **b}, para juntar dicionários. Nesses casos ele não é potência, é desempacotamento.

Operadores de Comparação

Os operadores de comparação em Python comparam dois valores e devolvem sempre um booleano (True ou False). São a base das estruturas condicionais no Python, como o if.

Vamos ver exemplos da utilização de cada operador de comparação mencionado acima.

Para facilitar o entendimento, todas as operações estão retornando um valor igual a True, para que você entenda como cada condição é aceita:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

var = 5

if var == 5:
    print('Os valores são iguais')

if var != 7:
    print('O valor não é igual a 7')

if var > 2:
    print('O valor da variável é maior de 2')

if var >= 5:
    print('O valor da variável é maior ou igual a 5')

if var < 7:
    print('O valor da variável é menor que 7')

if var <= 5:
    print('O valor da variável é menor ou igual a 5')

Resultado do código acima:

1
2
3
4
5
6

Os valores são iguais
O valor não é igual a 7
O valor da variável é maior de 2
O valor da variável é maior ou igual a 5
O valor da variável é menor que 7
O valor da variável é menor ou igual a 5

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Operadores de Atribuição

Os operadores de atribuição em Python guardam um valor em uma variável - e os compostos (como +=) ainda aplicam uma conta antes de guardar, funcionando como atalho. Para relembrar como variáveis funcionam, veja tipos de variáveis no Python.

Veja quais Operadores de Atribuição estão disponíveis em Python:

Exemplo da utilização de cada operador de atribuição mencionado acima:

Operador +=:

1
2
3
4

numero = 5

numero += 7
print(numero)  # Resultado será 12

Operador -=:

1
2
3
4

numero = 5

numero -= 3
print(numero)  # Resultado será 2

Operador *=:

1
2
3
4

numero = 5

numero *= 2
print(numero)  # Resultado será 10

Operador /=:

1
2
3
4

numero = 5

numero /= 4
print(numero)  # Resultado será 1.25

Operador %=:

1
2
3
4

numero = 5

numero %= 2
print(numero)  # Resultado será 1

Obs: O operador % é chamado módulo e nada mais é que o resto da divisão. No exemplo acima: 5 dividido por 2 dá 2 de resultado e sobra 1. Por isso numero %= 2 será 1!

Python não tem ++ nem --. Para somar 1 a um contador, escreva contador += 1.

Diferença entre = e ==

O = atribui (guarda um valor numa variável) e o == compara (pergunta se dois valores são iguais e devolve True ou False). Trocar um pelo outro é um dos erros mais comuns de quem está começando:

1
2
3
4
5
6

idade = 18           # atribuição: idade passa a valer 18
print(idade == 18)   # comparação: True
print(idade == 21)   # comparação: False

if idade == 18:      # no if, sempre ==
    print("Acabou de fazer 18!")

Saída:

1
2
3

True
False
Acabou de fazer 18!

Se você escrever if idade = 18:, o Python recusa o código com SyntaxError (veja em Erros comuns). E ainda existe um terceiro “igual”, o is, que tem outro papel:

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Operadores Lógicos

Os operadores lógicos em Python combinam ou invertem condições booleanas para montar os famosos testes lógicos. São três: and, or e not.

Vamos ver mais sobre eles agora!

Exemplo da utilização de cada um:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

num1 = 7
num2 = 4

# Exemplo and
if num1 > 3 and num2 < 8:
    print("As Duas condições são verdadeiras")

# Exemplo or
if num1 > 4 or num2 <= 8:
    print("Uma ou duas das condições são verdadeiras")

# Exemplo not
if not (num1 < 30 and num2 < 8):
    print('Inverte o resultado da condição entre os parênteses')

Resultado do código acima:

1
2

As Duas condições são verdadeiras
Uma ou duas das condições são verdadeiras

Repare que a terceira mensagem não aparece: num1 < 30 and num2 < 8 é True, e o not inverte para False, então o if não executa. Para ver esses testes em ação dentro de programas, confira as estruturas de repetição, onde and, or e not controlam quando um while deve parar.

and e or retornam um dos operandos (curto-circuito)

and e or não devolvem necessariamente True ou False: eles devolvem um dos operandos, e param de avaliar assim que já sabem a resposta. Isso se chama avaliação em curto-circuito, e está descrito na documentação das operações booleanas:

• x or y: se x for verdadeiro, devolve x (nem olha para y); senão, devolve y.
• x and y: se x for falso, devolve x (nem olha para y); senão, devolve y.

Valores “falsos” em Python são False, None, 0, 0.0, "", [], {} e outras coleções vazias. Todo o resto é “verdadeiro”.

1
2
3
4
5
6
7

print(3 and 5)        # 5   (3 é verdadeiro, então devolve o segundo)
print(0 and 5)        # 0   (0 é falso, para aqui)
print(0 or "padrão")  # padrão
print([] or [1])      # [1]

nome = ""
print(nome or "Anônimo")  # Anônimo (valor padrão quando a string está vazia)

O curto-circuito também protege contra erros. No exemplo abaixo, a divisão nunca é executada quando x é zero, porque o and para no primeiro False:

1
2

x = 0
print(x != 0 and 10 / x > 1)  # False (sem ZeroDivisionError)

Operadores de Identidade

Estes Operadores são utilizados para comparar objetos, verificando se os objetos testados referenciam o mesmo objeto (is) ou não (is not).

Agora vamos aos exemplos de como utilizar cada operador de identidade mencionado acima:

Exemplo do operador is:

1
2
3
4
5
6
7
8
9

lista = [1, 2, 3]
outra_lista = [1, 2, 3]
recebe_lista = lista

# Recebe True, pois são o mesmo objeto
print(f"São o mesmo objeto? {lista is recebe_lista}")

# Retorna False, pois são objetos diferentes
print(f"São o mesmo objeto? {lista is outra_lista}")

Resultado do código acima:

1
2

São o mesmo objeto? True
São o mesmo objeto? False

Exemplo do operador is not:

1
2
3
4
5

lista = [1, 2, 3]
outra_lista = [1, 2, 3]

print(f"Os objetos são diferentes? {outra_lista is not lista}")
print(f"Os valores são iguais? {outra_lista == lista}")

Resultado do código acima:

1
2

Os objetos são diferentes? True
Os valores são iguais? True

Diferença entre is e ==

Muitas vezes programadores Python ficam na dúvida em quando utilizar o operador de igualdade == ou o operador de identidade is.

Mas agora que você já conhece os dois sabe que o operador == verifica os valores testados, enquanto o operador is testa a referência dos valores testados!

Antipadrão: nunca use is para comparar números (ou strings). Para comparar valores, use sempre ==. O is parece funcionar com inteiros pequenos porque o Python mantém em cache os valores de -5 a 256, mas isso quebra com números maiores:

1
2
3
4
5
6
7
8
9

a = int("256")
b = int("256")
print(a == b)  # True  (valores iguais)
print(a is b)  # True  (mesmo objeto em cache)

c = int("257")
d = int("257")
print(c == d)  # True  (valores iguais)
print(c is d)  # False (objetos diferentes!)

Repare: c == d é True, mas c is d é False. Por isso, reserve o is para checar identidade de verdade - como em if x is None:.

Operadores de Associação

Por último, temos os Operadores de Associação.

Eles servem para verificar se determinado objeto está associado ou pertence a determinada estrutura de dados.

Exemplo da utilização de cada operador de associação mencionado acima:

1
2
3
4
5
6
7

lista = ["Python", 'Academy', "Operadores", 'Condições']

# Verifica se existe a string dentro da lista
print('Python' in lista)  # Saída: True

# Verifica se não existe a string dentro da lista
print('SQL' not in lista) # Saída: True

Antes de fechar com a tabela de precedência, vale lembrar: operadores bem entendidos são a base de qualquer lógica em Python. Se você quer construir esse alicerce com aulas práticas e suporte de professor, a Jornada Python é pra isso:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Precedência de operadores em Python

Quando uma expressão mistura vários operadores, o Python segue uma ordem fixa de precedência: parênteses, depois **, depois o sinal (-x), depois *, /, // e %, depois + e -, depois as comparações e, por último, not, and e or. Operadores do mesmo nível são avaliados da esquerda para a direita, com exceção do **, que vai da direita para a esquerda.

Os operadores bit a bit ficam entre as somas e as comparações; a tabela completa está na documentação oficial de precedência de operadores. Na prática, veja como a ordem muda o resultado:

1
2
3
4
5
6
7
8

print(2 + 3 * 4)       # 14  (multiplicação antes da soma)
print((2 + 3) * 4)     # 20  (parênteses primeiro)
print(-2 ** 2)         # -4  (** antes do sinal: -(2 ** 2))
print((-2) ** 2)       # 4
print(2 ** 3 ** 2)     # 512 (** da direita para a esquerda: 2 ** 9)
print(10 - 4 - 3)      # 3   (esquerda para a direita: (10 - 4) - 3)
print(True or False and False)  # True (and antes de or)
print(not True == False)        # True (== antes de not: not (True == False))

Dica: comparações podem ser encadeadas, como na matemática. 1 < 2 < 3 é True e equivale a 1 < 2 and 2 < 3. Na dúvida sobre a ordem, use parênteses: deixam o código mais legível e não custam nada.

Tabela-resumo de todos os operadores Python

Para consultar rápido (todos os resultados foram conferidos no Python 3.10; nas linhas de atribuição, considere x = 4 antes de cada exemplo):

Erros comuns

1. Usar = no lugar de == dentro do if

1
2
3

x = 5
if x = 5:
    print("cinco")

1

SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

O = só atribui; para comparar, use ==: if x == 5:. (Em versões anteriores ao Python 3.10 a mensagem é apenas SyntaxError: invalid syntax.)

2. Escrever if cor == "azul" or "verde" (condição sempre verdadeira)

Não dá erro, mas o resultado está errado: a cor é vermelha e mesmo assim entra no if.

1
2
3
4

cor = "vermelho"

if cor == "azul" or "verde":
    print("Cor fria!")  # imprime "Cor fria!", mesmo sendo vermelho

Como == tem precedência maior que or, o Python lê (cor == "azul") or "verde". O primeiro lado é False, então o or devolve "verde", uma string não vazia, que conta como verdadeira. A correção é repetir a comparação ou usar in:

1
2
3
4
5
6
7

cor = "vermelho"

if cor == "azul" or cor == "verde":
    print("Cor fria!")

if cor in ("azul", "verde"):  # forma mais pythônica
    print("Cor fria!")

Agora nada é impresso, como esperado.

3. Dividir por zero com /, // ou %

1

print(10 / 0)

1

ZeroDivisionError: division by zero

Com // ou % a mensagem muda para ZeroDivisionError: integer division or modulo by zero. Teste o divisor antes (ou trate a exceção com try/except):

1
2
3
4
5
6

divisor = 0

if divisor != 0:
    print(10 / divisor)
else:
    print("Não dá para dividir por zero")  # é isso que aparece

4. Fazer conta com o valor do input() sem converter

1
2

idade = "30"  # é isso que o input() devolve: sempre uma string
print(idade + 1)

1

TypeError: can only concatenate str (not "int") to str

Com strings, + concatena em vez de somar. Converta antes: print(int(idade) + 1) mostra 31. Esse erro é tão comum que tem seção própria no post sobre input e print no Python.

5. Tentar usar ++ para incrementar

1
2

contador = 0
contador++

1

SyntaxError: invalid syntax

Python não tem ++ nem -- (comuns em C, Java e JavaScript). Use o operador de atribuição composta: contador += 1.

Exercícios resolvidos

Tente resolver cada um antes de abrir a solução. Todas as saídas foram conferidas executando o código.

Exercício 1. Sem rodar o código, diga o que é impresso por print(17 / 5), print(17 // 5) e print(17 % 5).

1
2
3

print(17 / 5)
print(17 // 5)
print(17 % 5)

Exercício 2 (estilo prova). Relacione as operações de Python da coluna A com as suas funções da coluna B:

• Coluna A: a. // b. % c. /
• Coluna B: 1. resto da divisão 2. divisão inteira 3. divisão com decimais

Assinale a alternativa correta:

a) a-1, b-2, c-3
b) a-2, b-1, c-3
c) a-3, b-2, c-1
d) a-2, b-3, c-1

1
2
3

print(7 // 2)  # divisão inteira
print(7 % 2)   # resto da divisão
print(7 / 2)   # divisão com decimais

Exercício 3. Escreva um programa que percorra os números de 1 a 5 e diga se cada um é par ou ímpar.

1
2
3
4
5

for n in range(1, 6):
    if n % 2 == 0:
        print(n, "é par")
    else:
        print(n, "é ímpar")

1
2
3
4
5

1 é ímpar
2 é par
3 é ímpar
4 é par
5 é ímpar

Exercício 4. Converta 3725 segundos para o formato Xh Ymin Zs usando apenas // e %.

1
2
3
4
5
6
7

total = 3725

horas = total // 3600
minutos = (total % 3600) // 60
segundos = total % 60

print(f"{horas}h {minutos}min {segundos}s")

Exercício 5 (estilo prova). Qual o valor impresso por print(2 + 3 * 2 ** 2)?

a) 100
b) 14
c) 20
d) 64

1
2
3
4
5

print(2 + 3 * 2 ** 2)
# passo a passo:
# 2 ** 2      -> 4   (potência primeiro)
# 3 * 4       -> 12  (depois multiplicação)
# 2 + 12      -> 14  (por último a soma)

Exercício 6 (estilo prova). Quais os valores de -7 // 2 e -7 % 2 em Python?

a) -3 e -1
b) -4 e 1
c) -3 e 1
d) -4 e -1

1
2
3

print(-7 // 2)
print(-7 % 2)
print((-7 // 2) * 2 + (-7 % 2))  # confere: volta a -7

Exercício 7 (estilo prova). Sobre operadores de comparação em Python, marque V (verdadeiro) ou F (falso):

• ( ) O operador == é usado para comparar se dois valores são iguais.
• ( ) = e == podem ser usados um no lugar do outro dentro de um if.
• ( ) O operador is é a forma recomendada de comparar dois números.
• ( ) A expressão 5 != 5.0 retorna True, porque um é int e o outro é float.

a) V, F, F, F
b) V, V, F, F
c) V, F, V, F
d) F, F, V, V

1
2
3
4
5

x = 5
print(x == 5)      # afirmação 1: == compara valores
print(5 == 5.0)    # int e float com o mesmo valor
print(5 != 5.0)    # afirmação 4
print(x is None)   # is é para identidade, não para comparar números

Exercício 8. Um ano é bissexto se for divisível por 4 e não for divisível por 100, ou se for divisível por 400. Escreva uma função que implemente essa regra e teste com 1900, 2000, 2024 e 2026.

1
2
3
4
5

def eh_bissexto(ano):
    return (ano % 4 == 0 and ano % 100 != 0) or ano % 400 == 0

for ano in (1900, 2000, 2024, 2026):
    print(ano, eh_bissexto(ano))

1
2
3
4

1900 False
2000 True
2024 True
2026 False

Conclusão

Vimos nesse post os diversos tipos de Operadores que o Python disponibiliza para que possamos desenvolver nossos scripts na Linguagem!

Agora que você já sabe como utilizá-los, você deu um passo importante para conhecer a fundo a linguagem Python! O próximo passo natural é usar esses operadores para tomar decisões com as estruturas condicionais e repetir tarefas com as estruturas de repetição.

Se quiser praticar tudo isso com exercícios e projetos guiados, do básico ao avançado, conheça o nosso curso de Python completo, a Jornada Python.

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 18/07/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes:

• 
•