EnglishEnglish العربيةالعربية PortuguêsPortuguês Japanese日本語

Visão Geral dos Operadores

Programação é essencialmente "realizar operações em dados." Na Lição 02 aprendemos sobre variáveis; agora vamos aprender sobre operadores — quais capacidades computacionais o Python oferece. Aritmética, comparação, decisões lógicas, concatenação de strings... Depois desta lição, você resolverá muitos problemas do mundo real com Python.

1. Operadores Aritméticos

Usamos alguns operadores na Lição 02. Aqui está a lista completa:

Operador Nome Exemplo Resultado Observações
+ Adição 5 + 3 8 Também funciona para concatenação de strings
- Subtração 5 - 3 2 Também usado como negação: -5
* Multiplicação 5 * 3 15 Também funciona para repetição de strings
/ Divisão 5 / 3 1.666... Sempre retorna um float
// Divisão inteira 5 // 3 1 Arredonda para baixo, descarta parte fracionária
% Módulo 5 % 3 2 Resto da divisão
** Exponenciação 5 ** 3 125 5 elevado a 3

Dois Operadores que Merecem Atenção

Particularidade do / (Divisão):

PYTHON 
print(4 / 2)    # Saída 2.0, não 2

Muitas pessoas param aqui: 4 dividido por 2 é claramente 2, então por que o Python exibe 2.0? Porque o / do Python sempre retorna um float, mesmo quando a divisão é exata. Isso mantém os resultados previsíveis — você vê / e sabe que o resultado será float.

Armadilha do // (Divisão inteira):

PYTHON 
print(7 // 3)     # Saída 2 (7 ÷ 3 = 2.333, arredondado para baixo = 2)
print(-7 // 3)    # Saída -3 ← pode não ser o que você espera

-7 // 3 resulta em -3, não -2. O // do Python é divisão de piso (arredonda em direção ao infinito negativo), não "truncamento em direção a zero." Na reta numérica, -2.333 arredondado para baixo é -3. Se você quiser truncamento em direção a zero, use int(-7 / 3), que resulta em -2.

💡 Dica: Pense em // como "divisão de piso" em vez de "divisão inteira" — "divisão inteira" implica truncamento, o que não vale para números negativos.

Exemplo: Conversão de Polegadas e Centímetros (Dificuldade ⭐)

PYTHON 
# Polegadas para centímetros: 1 polegada = 2.54 cm

# Comprimento de uma régua padrão
inches = 12

# Converter usando multiplicação
cm = inches * 2.54

# Saída (observe que cm é automaticamente float)
print(f"{inches} polegadas = {cm} cm")

# Reverso: cm → polegadas (usando divisão)
cm_value = 30
inches_value = cm_value / 2.54
print(f"{cm_value} cm = {inches_value:.2f} polegadas")

# Tente divisão inteira e módulo — quantos segmentos de 5 polegadas em 12 polegadas?
count = 12 // 5   # Piso: 2
remainder = 12 % 5  # Módulo: 2 polegadas restantes
print(f"12 polegadas podem ser divididas em {count} segmentos de 5 polegadas, com {remainder} polegadas restantes")
▶ Experimente

Saída:

TEXT 
12 polegadas = 30.48 cm
30 cm = 11.81 polegadas
12 polegadas podem ser divididas em 2 segmentos de 5 polegadas, com 2 polegadas restantes

2. Operadores de Comparação

Operadores de comparação avaliam relações entre valores e sempre retornam um booleano (True ou False). Eles são a base da lógica condicional.

Operador Nome Exemplo Resultado
== Igual a 5 == 3 False
!= Diferente de 5 != 3 True
> Maior que 5 > 3 True
< Menor que 5 < 3 False
>= Maior ou igual 5 >= 5 True
<= Menor ou igual 5 <= 3 False
PYTHON 
age = 18
print(age == 18)     # True (exatamente 18)
print(age != 18)     # False (não "diferente")
print(age > 21)      # False (não tem idade para beber nos EUA)
print(age >= 18)     # True (exatamente maior de idade, atende à condição)

Comparações Encadeadas

Python suporta uma sintaxe concisa rara em outras linguagens:

PYTHON 
x = 15
print(10 < x < 20)   # True (equivalente a 10 < x and x < 20)
print(0 < x < 10)    # False

Isso é lido de forma mais natural que 10 < x and x < 20, como notação matemática.

is e is not (Comparação de Identidade)

A rigor, is não é um operador de comparação, mas é frequentemente comparado com ==:

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

print(a == b)     # True (mesmo conteúdo)
print(a is b)     # False (mas não é o mesmo objeto)
print(a is c)     # True (c é apenas um apelido para a)

No desenvolvimento diário, 99% das vezes você usa ==. A convenção é usar is apenas ao verificar None: if result is None:.

Exemplo: Classificação por Grupo de Corrida (Dificuldade ⭐)

PYTHON 
# Regras de agrupamento de corrida de 100 metros
# Idade 12–15 → Grupo Juvenil
# Idade 16–20 → Grupo Jovem

participant_age = 14

# Use operadores de comparação para determinar o grupo
is_teen_group = 12 <= participant_age <= 15    # Comparação encadeada
is_youth_group = participant_age >= 16 and participant_age <= 20

print(f"Idade do participante: {participant_age}")
print(f"Grupo Juvenil (12-15): {is_teen_group}")
print(f"Grupo Jovem (16-20): {is_youth_group}")

# Usando == e !=
age_verified = True
print(f"Idade verificada: {age_verified == True}")
print(f"Idade não verificada: {age_verified != True}")
▶ Experimente

Saída:

TEXT 
Idade do participante: 14
Grupo Juvenil (12-15): True
Grupo Jovem (16-20): False
Idade verificada: True
Idade não verificada: False

3. Operadores Lógicos

Operadores lógicos combinam múltiplas condições, e o resultado também é um booleano. Eles são usados em toda parte em condições if e laços.

Operador Nome Exemplo Resultado Observações
and E lógico True and False False Verdadeiro apenas se ambos são verdadeiros
or OU lógico True or False True Verdadeiro se pelo menos um é verdadeiro
not NÃO lógico not True False Negação
PYTHON 
age = 20
has_id_card = True

# and: ambas as condições devem ser atendidas
print(age >= 18 and has_id_card)   # True (adulto e tem documento)

# or: pelo menos uma condição
print(age >= 18 or has_id_card)    # True (na verdade ambas são atendidas)

# not: negação
print(not has_id_card)             # False (não True = False)

Tabela Verdade

a b a and b a or b not a
True True True True False
True False False True False
False True False True True
False False False False True

Avaliação de Curto-Circuito

Os operadores lógicos do Python têm uma característica importante: avaliação de curto-circuito.

PYTHON 
# Para and: se o lado esquerdo é False, o lado direito nunca é avaliado
def say_yes():
    print("say_yes foi chamada")
    return True

print(False and say_yes())   # Saída False — say_yes nunca executou
print(True and say_yes())    # Saída "say_yes foi chamada" e True

# Para or: se o lado esquerdo é True, o lado direito não é avaliado
print(True or say_yes())     # Saída True — say_yes nunca executou

Isso é muito útil na prática:

PYTHON 
# Só obtém username se usuário existe — evita erro None.get()
user = None
username = user and user.get("name")   # user é None (falsy), curto-circuito, username = None
print(username)                        # None

user = {"name": "João Silva"}
username = user and user.get("name")   # user é truthy, avalia lado direito, username = "João Silva"
print(username)                        # João Silva
💡 Dica: A avaliação de curto-circuito não só melhora o desempenho mas também previne erros. O padrão user and user.get("name") é comum em Python — ele garante "acesso seguro": se o lado esquerdo é falsy, retorna-o diretamente sem avaliar o lado direito potencialmente problemático.

Exemplo: Verificar se um Número é "Especial" (Dificuldade ⭐⭐)

Combine operadores de comparação e lógicos para verificar se um número atende certas "condições especiais."

PYTHON 
# Verifica se um número é "especial"
# Definição: entre 10-99, e é múltiplo de 7 ou contém o dígito 7

num = 49

# Condição 1: entre 10-99 (comparação encadeada)
in_range = 10 <= num <= 99

# Condição 2: múltiplo de 7 (módulo + comparação)
multiple_of_7 = num % 7 == 0

# Condição 3: contém dígito 7 (dígito das dezenas = 7 ou dígito das unidades = 7)
tens_digit = num // 10    # Extrai dígito das dezenas
ones_digit = num % 10     # Extrai dígito das unidades
contains_7 = (tens_digit == 7) or (ones_digit == 7)

# Combina todas as condições com operadores lógicos
is_special = in_range and (multiple_of_7 or contains_7)

print(f"Número: {num}")
print(f"No intervalo (10-99): {in_range}")
print(f"Múltiplo de 7: {multiple_of_7}")
print(f"Contém dígito 7: {contains_7}")
print(f"É especial: {is_special}")     # True — 49 é múltiplo de 7

# Verifica curto-circuito — se a primeira condição falhar, o resto não executa
num2 = 200  # Fora do intervalo
is_special2 = (10 <= num2 <= 99) and (num2 % 7 == 0)
print(f"\nNúmero {num2}: primeira condição é False, segunda não executa — {is_special2}")
▶ Experimente

Saída:

TEXT 
Número: 49
No intervalo (10-99): True
Múltiplo de 7: True
Contém dígito 7: False
É especial: True

Número 200: primeira condição é False, segunda não executa — False

4. Operadores de Atribuição

Além do = básico, Python fornece operadores de atribuição compostos:

PYTHON 
x = 10         # Atribuição básica
x += 3         # Equivalente a x = x + 3, resultado: 13
x -= 2         # Equivalente a x = x - 2, resultado: 11
x *= 2         # Equivalente a x = x * 2, resultado: 22
x /= 4         # Equivalente a x = x / 4, resultado: 5.5
x //= 2        # Equivalente a x = x // 2, resultado: 2.0
x %= 2         # Equivalente a x = x % 2, resultado: 0.0
x = 3        # Equivalente a x = x  3, resultado: 0.0

Observe que x = 10 é um inteiro, mas após x /= 4 ele se torna 5.5 (float), porque / sempre retorna um float. Use //= se precisar de um resultado inteiro.

PYTHON 
# Incremento típico em um laço
score = 0
score += 10      # Adiciona 10 pontos
score += 20      # Adiciona mais 20
score += 15      # Adiciona mais 15
print(f"Pontuação final: {score}")   # 45

# Strings também funcionam com atribuição composta
message = "Hello"
message += " "   # Adiciona um espaço
message += "World"
print(message)               # "Hello World"
💡 Dica: x += 1 é a forma do Python para "incrementar em 1." Outras linguagens escrevem x++. Python não tem operador ++; use += 1.

5. Operadores de String

Strings têm suas próprias "operações" — não exatamente matemáticas, mas usando os mesmos símbolos.

Operador Propósito Exemplo Resultado
+ Concatenação "Hello" + " " + "World" "Hello World"
* Repetição "Ha" * 3 "HaHaHa"
in Pertencimento "Py" in "Python" True
not in Não pertencimento "xyz" not in "Python" True
PYTHON 
# Concatenação de strings
first_name = "João"
last_name = "Silva"
full_name = first_name + " " + last_name
print(full_name)              # Saída "João Silva"

# Repetição de strings — ótimo para desenhar linhas separadoras
line = "=" * 30
print(line)                   # Saída 30 sinais de igual

# Verificação de pertencimento (in / not in)
text = "Hello, Python!"
print("Python" in text)       # True — "Python" faz parte do texto
print("Java" in text)         # False — texto não contém "Java"
print("Java" not in text)     # True — de fato "não está lá"
⚠️ Observação: + funciona apenas entre duas strings, não entre string e número. "Age: " + 25 dará erro. Converta o número primeiro: "Age: " + str(25). * funciona apenas entre string e inteiro — "AB" * 3 funciona, "AB" * "CD" não.

Exemplo: Gerar um Cartão de Visita com Operações de String (Dificuldade ⭐⭐)

PYTHON 
# Gera um cartão de visita simples usando operações de string

name = "João Silva"
title = "Engenheiro Python"
company = "Tech Co., Ltd."

# Concatena conteúdo do cartão com +
card_line1 = "Nome: " + name
card_line2 = "Cargo: " + title
card_line3 = "Empresa: " + company

# Gera separador com *
separator = "-" * 25

# Combina em cartão completo
business_card = separator + "\n" + card_line1 + "\n" + card_line2 + "\n" + card_line3 + "\n" + separator

print("Cartão de Visita Gerado:")
print(business_card)

# Verifica se contém informação específica com in
search_term = "Python"
print(f"\nO cartão contém \"{search_term}\"? {search_term in business_card}")

# Exclui certa informação com not in
print(f"Cartão não contém \"Gerente\": {\"Gerente\" not in business_card}")
▶ Experimente

Saída:

TEXT 
Cartão de Visita Gerado:
-------------------------
Nome: João Silva
Cargo: Engenheiro Python
Empresa: Tech Co., Ltd.
-------------------------

O cartão contém "Python"? True
Cartão não contém "Gerente": True

6. Precedência de Operadores

Assim como a matemática tem "multiplicação antes de adição," Python tem precedência de operadores.

Prioridade Categoria Operadores Observações
Alta Exponenciação ** Associativo à direita
↓ Unário +x, -x, not Positivo/negativo, NÃO lógico
↓ Aritmético *, /, //, % Multiplicação, divisão, piso, módulo
↓ Aritmético +, - Adição, subtração
↓ Comparação ==, !=, >, <, >=, <= Comparações
↓ Lógico not NÃO lógico
↓ Lógico and E lógico
↓ Lógico or OU lógico
Baixa Atribuição =, +=, etc. Atribuição
PYTHON 
# Multiplicação antes de adição
result = 2 + 3 * 4
print(result)                # 14 (3*4=12, depois +2)

# Comparação tem precedência menor que aritmética
print(2 + 3 * 4 > 10)        # True (14 > 10)

# Lógico tem a menor precedência — faça comparações primeiro, depois combine logicamente
age = 20
print(age > 18 and age < 60)  # True (primeiro age>18 e age<60, depois and)

# Exponenciação é associativa à direita
print(2  3  2)            # 512 (primeiro 3²=9, depois 2⁹=512)
print((2  3)  2)          # 64 (com parênteses, primeiro 2³=8, depois 8²=64)

# Parênteses mudam a precedência — como na matemática
result = (2 + 3) * 4
print(result)                 # 20 (primeiro 2+3=5, depois ×4)

Exemplo: Calculadora de Hipoteca (Dificuldade ⭐⭐)

PYTHON 
# Calcula pagamento mensal de hipoteca (pagamento igual)
# Fórmula: mensal = empréstimo × taxa_mensal × (1 + taxa_mensal)^meses ÷ [(1 + taxa_mensal)^meses - 1]

# Suponha 1.000.000 de empréstimo, 4,5% taxa anual, 30 anos
loan_amount = 1_000_000    # Total do empréstimo (sublinhados são para legibilidade, Python 3.6+)
annual_rate = 0.045        # Taxa de juros anual
years = 30
months = years * 12        # Número de pagamentos
monthly_rate = annual_rate / 12   # Taxa de juros mensal

# Divida passo a passo
rate_power = (1 + monthly_rate) ** months         # (1 + taxa mensal)^meses
numerator = loan_amount * monthly_rate * rate_power   # Numerador
denominator = rate_power - 1                          # Denominador

monthly_payment = numerator / denominator

print(f"Valor do empréstimo: {loan_amount:,} reais")
print(f"Taxa anual: {annual_rate * 100}%")
print(f"Prazo: {years} anos")
print(f"Pagamento mensal: {monthly_payment:.2f} reais")
print(f"Total a pagar: {monthly_payment * months:,.2f} reais")
print(f"Total de juros: {monthly_payment * months - loan_amount:,.2f} reais")
▶ Experimente

Saída:

TEXT 
Valor do empréstimo: 1,000,000 reais
Taxa anual: 4.5%
Prazo: 30 anos
Pagamento mensal: 5,066.85 reais
Total a pagar: 1,824,066.95 reais
Total de juros: 824,066.95 reais
💡 Dica: Os sublinhados em 1_000_000 são apenas para legibilidade humana — Python os ignora. Este é um recurso do Python 3.6+ para separação visual de números. Não lembra a precedência? Use parênteses — a fórmula acima é clara para qualquer um com parênteses.

7. Problemas de Precisão de Ponto Flutuante

Todo programador encontra isso:

PYTHON 
print(0.1 + 0.2)                     # Saída 0.30000000000000004
print(0.3)                           # Saída 0.3
print(0.1 + 0.2 == 0.3)              # Saída False ← não são iguais!

Isso não é um bug do Python — é uma limitação fundamental de armazenar floats em binário. Assim como decimal não pode representar precisamente 1/3 = 0.33333..., binário não pode representar precisamente 0.1.

Quando se Preocupar

PYTHON 
# Forma correta de comparar floats
result = 0.1 + 0.2
epsilon = 1e-10     # Um número muito pequeno, cerca de 0.0000000001
print(abs(result - 0.3) < epsilon)   # Saída True
PYTHON 
print(f"{0.1 + 0.2:.2f}")   # Saída 0.30
PYTHON 
# Exemplo real: somar 0.1 dez vezes
total = 0.0
for i in range(10):
    total += 0.1
print(f"Resultado acumulado: {total}")          # 0.9999999999999999
print(f"Exatamente 1.0: {total == 1.0}")          # False
print(f"Formatado: {total:.2f}")               # 1.00 — exibição é ok
⚠️ Observação: Para aprendizado diário, a precisão de ponto flutuante não afetará seu entendimento da lógica de programação. Apenas lembre-se de duas regras: "não use == para comparar floats diretamente" e "use o módulo decimal para dinheiro."

8. Conversão de Tipos Numéricos

Python fornece várias funções para converter entre tipos numéricos:

PYTHON 
# int → float
print(float(3))             # Saída 3.0

# float → int (trunca em direção a zero, não arredonda)
print(int(3.14))            # Saída 3
print(int(-2.8))            # Saída -2 (truncamento em direção a zero)

# string → número (apenas se a string realmente representa um número)
print(int("42"))            # Saída 42
print(float("3.14"))        # Saída 3.14

# número → string
print(str(3.14))            # Saída "3.14"

# int() também pode especificar base
print(int("FF", 16))        # Saída 255 (hexadecimal FF para decimal)
print(int("1010", 2))       # Saída 10 (binário 1010 para decimal)

Exemplo: Conversão de Tipo na Prática (Dificuldade ⭐)

PYTHON 
# Fluxo de trabalho completo: entrada → converter → calcular → saída
user_input = "25"       # Nota: isto é uma string, não um número

# O que acontece sem conversão?
# print(user_input + 5)  ← descomente para ver o erro

# Abordagem correta: converta com int() primeiro
age = int(user_input)

# Agora a aritmética funciona normalmente
age_next_year = age + 1
print(f"Você digitou: {user_input} (tipo: {type(user_input)})")
print(f"Após conversão: {age} (tipo: {type(age)})")
print(f"No próximo ano você terá {age_next_year} anos")

# Reverso: converta resultado de volta para string para exibição
output_message = "Você tem " + str(age) + " anos"
print(output_message)
▶ Experimente

Saída:

TEXT 
Você digitou: 25 (tipo: <class 'str'>)
Após conversão: 25 (tipo: <class 'int'>)
No próximo ano você terá 26 anos
Você tem 25 anos

Casos de Uso Comuns

❓ Perguntas Frequentes

P: Qual a diferença entre == e is? Quando devo usar cada um? R: == compara valores ("o conteúdo é o mesmo?"), is compara identidade ("são o mesmo objeto?"). Exemplo: a = [1, 2]; b = [1, 2]; c = a — a == b é True (mesmos valores), mas a is b é False (objetos lista diferentes); a is c é True (c é apenas um apelido). No desenvolvimento diário, 99% das vezes use ==. Para verificar None, a convenção é is: if result is None:. ⚠️ P: Quais armadilhas a avaliação de curto-circuito de and/or tem na prática? R: A armadilha mais comum: user_input = input() or "default" — se input() retornar uma string vazia (falsy), or faz curto-circuito e usa o padrão. Isso é comum mas pode ser confuso para iniciantes. Outra armadilha: colocar uma chamada de função no lado direito de and — se o lado esquerdo for falsy, a função não será executada, potencialmente pulando operações importantes. Boa prática: se a expressão da direita tem efeitos colaterais, não dependa do comportamento de curto-circuito; escreva declarações separadas. P: Quando devo usar / vs //? R: Se você precisa de um resultado decimal preciso (ex.: 7 ÷ 3 = 2.333...), use /. Se você precisa apenas de um resultado inteiro (ex.: dividir 7 maçãs entre 3 pessoas — 2 cada, sobra 1), use // com %. Se você é iniciante e não tem certeza, use / por padrão — pelo menos você não perderá precisão. Mude para // quando precisar especificamente de resultados inteiros. P: O que significa ser associativo à direita? Por que foi projetado assim? R: Associativo à direita significa que 2 3 2 é interpretado como 2 (3 2), ou seja, primeiro calcula 3² = 9, depois 2⁹ = 512. Da esquerda para a direita daria (2³)² = 8² = 64, um resultado completamente diferente. Isso segue a convenção matemática: a^b^c é interpretado começando do canto superior direito. Use parênteses para forçar a ordem: (2 3) ** 2 resulta em 64.

📖 Resumo

📝 Atividades

  1. Básico (Dificuldade ⭐): Defina a=10, b=3, c=20. Calcule e exiba: a + b * c, (a + b) * c, a ** b, a // b, c % a, a > b and c > 15. Primeiro adivinhe os resultados, depois verifique.

  2. Intermediário (Dificuldade ⭐⭐): Dado year = 2026, determine se é um ano bissexto. Regra do ano bissexto: divisível por 4 mas não por 100, ou divisível por 400. Dica: year % 4 == 0 verifica divisibilidade por 4.

  3. Desafio (Dificuldade ⭐⭐⭐): Escreva um sistema simples de alarme de temperatura. Dado current_temp = 38, high_alarm = 37, low_alarm = 5. Dispare um alarme se a temperatura atual exceder o limite máximo ou cair abaixo do limite mínimo. Se a temperatura estiver próxima do limite (dentro de ±2 graus), emita um "aviso" em vez de "alarme." Use apenas operadores aritméticos, de comparação e lógicos. Dica: abs(current_temp - high_alarm) <= 2 verifica se está próximo do limite máximo.

100%