Capítulo 3: Operadores e Expressões

Capítulo 3: Operadores e Expressões#

ch3

Já vimos como armazenar informações em variáveis e trabalhar com diferentes tipos de dados. Mas de que adianta ter dados se não podemos fazer nada com eles? É aqui que entram os operadores - ferramentas que nos permitem realizar cálculos, comparações e tomar decisões em nossos programas.

Imagine operadores como os símbolos matemáticos que você usa desde a escola: +, -, *, /. Em Python, temos não apenas estes operadores aritméticos, mas também operadores para comparar valores (>, <, ==), combinar condições (and, or) e muito mais.

Neste capítulo, vamos explorar os principais tipos de operadores em Python:

Operadores Aritméticos: para realizar cálculos matemáticos
Operadores Relacionais: para comparar valores
Operadores Lógicos: para combinar condições
Operadores de Atribuição: para armazenar e atualizar valores
Operações com Bits: para manipulação a nível binário

Dominar esses operadores é essencial para escrever programas que resolvam problemas reais, desde uma simples calculadora até sistemas complexos de tomada de decisão.

Operadores Aritméticos#

Os operadores aritméticos são os primeiros que aprendemos em qualquer linguagem de programação, pois trabalham de forma muito similar à matemática que já conhecemos. Eles nos permitem realizar operações matemáticas com números, sejam inteiros ou decimais.

Tabela de Operadores Aritméticos#

Python oferece sete operadores aritméticos básicos. Vamos conhecer cada um deles:

Operador	Símbolo	Descrição	Exemplo	Resultado
Adição	`+`	Soma dois valores	`3 + 5`	`8`
Subtração	`-`	Subtrai o segundo valor do primeiro	`10 - 3`	`7`
Multiplicação	`*`	Multiplica dois valores	`4 * 2`	`8`
Divisão	`/`	Divide o primeiro valor pelo segundo (resultado sempre decimal)	`10 / 2`	`5.0`
Divisão Inteira	`//`	Divide e retorna apenas a parte inteira	`10 // 3`	`3`
Módulo	`%`	Retorna o resto da divisão	`10 % 3`	`1`
Exponenciação	`**`	Eleva o primeiro valor à potência do segundo	`2 ** 3`	`8`

Entendendo Cada Operador#

Vamos explorar alguns desses operadores com mais detalhes:

Divisão (/) vs Divisão Inteira (//)

A diferença entre / e // é importante:

O operador / sempre retorna um número decimal (float), mesmo quando a divisão é exata
O operador // retorna apenas a parte inteira, descartando a parte decimal

print(10 / 2)
print(10 // 2)
print(10 / 3)
print(10 // 3)

Saída:

5.0
5
3.3333333333333335
3

Operador Módulo (%)

O operador módulo é muito útil para diversas situações:

Verificar se um número é par ou ímpar
Determinar se um número é múltiplo de outro
Obter o último dígito de um número
Fazer operações cíclicas (como relógios)

# Verificar se um número é par
numero = 8
if numero % 2 == 0:
    print(f"{numero} é par")
else:
    print(f"{numero} é ímpar")

# Obter o último dígito de um número
valor = 12345
ultimo_digito = valor % 10
print(f"Último dígito: {ultimo_digito}")

Saída:

8 é par
Último dígito: 5

Operador de Exponenciação (**)

O operador ** substitui funções como pow() e torna o código mais legível:

# Calcular área de um círculo: A = π * r²
raio = 5
PI = 3.14159
area = PI * raio ** 2
print(f"Área do círculo: {area:.2f}")

Saída:

Área do círculo: 78.54

Exemplos Práticos#

Vamos ver exemplos que utilizam vários operadores em situações do dia a dia:

Exemplo 1: Calculadora de compras com desconto

preco_original = 150.00
quantidade = 3
desconto_percentual = 10

# Cálculos
subtotal = preco_original * quantidade
desconto = subtotal * (desconto_percentual / 100)
total = subtotal - desconto

print(f"Subtotal: R$ {subtotal:.2f}")
print(f"Desconto ({desconto_percentual}%): R$ {desconto:.2f}")
print(f"Total a pagar: R$ {total:.2f}")

Saída:

Subtotal: R$ 450.00
Desconto (10%): R$ 45.00
Total a pagar: R$ 405.00

Exemplo 2: Conversão de tempo

# Converter segundos totais em horas, minutos e segundos
tempo_total_segundos = 3725

horas = tempo_total_segundos // 3600  # Quantas horas completas
resto_apos_horas = tempo_total_segundos % 3600  # Segundos restantes
minutos = resto_apos_horas // 60  # Quantos minutos completos
segundos = resto_apos_horas % 60  # Segundos restantes

print(f"{tempo_total_segundos} segundos equivalem a:")
print(f"{horas} hora(s), {minutos} minuto(s) e {segundos} segundo(s)")

Saída:

3725 segundos equivalem a:
1 hora(s), 2 minuto(s) e 5 segundo(s)

Precedência dos Operadores Aritméticos#

Assim como na matemática, Python segue uma ordem específica ao avaliar expressões. Essa ordem é chamada de precedência de operadores:

Prioridade	Operadores	Observação
1ª (mais alta)	`**`	Exponenciação
2ª	`*`, `/`, `//`, `%`	Multiplicação, divisões e módulo
3ª (mais baixa)	`+`, `-`	Adição e subtração

Regras importantes:

Operadores com a mesma precedência são avaliados da esquerda para a direita
Use parênteses () para alterar a ordem de avaliação
Quando em dúvida, use parênteses para deixar o código mais claro

Exemplos de precedência:

# Sem parênteses: multiplicação antes da adição
resultado1 = 2 + 3 * 4
print(resultado1)

# Com parênteses: forçamos a adição primeiro
resultado2 = (2 + 3) * 4
print(resultado2)

# Exemplo complexo
resultado3 = 2 ** 3 + 4 * 5 - 10 / 2
print(resultado3)

Saída:

14
20
23.0

Operadores Unários#

Operadores unários são aqueles que atuam sobre um único valor (ao contrário dos operadores binários, que atuam sobre dois valores). Em operações aritméticas, o operador unário mais comum é o de negação (-), que inverte o sinal de um número:

numero_positivo = 10
numero_negativo = -numero_positivo
print(numero_negativo)

# O operador unário tem alta precedência
resultado = -5 + 2 * 3
print(resultado)

Saída:

-10
1

Exemplo prático:

# Cálculo de temperatura com variação
temperatura_inicial = 25
variacao = -3  # Temperatura diminuiu 3 graus
temperatura_final = temperatura_inicial + variacao
print(f"Temperatura inicial: {temperatura_inicial}°C")
print(f"Variação: {variacao}°C")
print(f"Temperatura final: {temperatura_final}°C")

Saída:

Temperatura inicial: 25°C
Variação: -3°C
Temperatura final: 22°C

Nota: Existem outros operadores unários em Python, como o operador de inversão de bits (~), que veremos mais adiante na seção de operações com bits.

Operadores Relacionais#

Agora que sabemos realizar cálculos com operadores aritméticos, precisamos aprender a comparar valores. É aqui que entram os operadores relacionais, também conhecidos como operadores de comparação.

Estes operadores são fundamentais para criar programas que tomam decisões. Por exemplo: verificar se um aluno foi aprovado, se um produto está em estoque, se uma senha está correta, ou se um usuário tem idade suficiente para acessar determinado conteúdo.

O resultado de uma comparação é sempre um valor booleano: True (verdadeiro) ou False (falso).

Tabela de Operadores Relacionais#

Operador	Símbolo	Descrição	Exemplo	Resultado
Igualdade	`==`	Verifica se dois valores são iguais	`5 == 5`	`True`
Diferença	`!=`	Verifica se dois valores são diferentes	`5 != 3`	`True`
Menor que	`<`	Verifica se o primeiro é menor que o segundo	`3 < 5`	`True`
Maior que	`>`	Verifica se o primeiro é maior que o segundo	`3 > 5`	`False`
Menor ou igual	`<=`	Verifica se o primeiro é menor ou igual ao segundo	`3 <= 5`	`True`
Maior ou igual	`>=`	Verifica se o primeiro é maior ou igual ao segundo	`5 >= 5`	`True`

Atenção - Igualdade vs Atribuição

Não confunda o operador de igualdade == (dois sinais de igual) com o operador de atribuição = (um sinal de igual). O primeiro compara valores, o segundo atribui valores!

Exemplos Básicos#

Vamos ver como usar esses operadores na prática:

# Comparando números
nota = 7.5
media = 6.0

print(f"Nota igual à média? {nota == media}")
print(f"Nota diferente da média? {nota != media}")
print(f"Nota maior que a média? {nota > media}")
print(f"Nota maior ou igual a 7? {nota >= 7}")
print(f"Nota menor que 5? {nota < 5}")

Saída:

Nota igual à média? False
Nota diferente da média? True
Nota maior que a média? True
Nota maior ou igual a 7? True
Nota menor que 5? False

Comparação de Strings#

As comparações não funcionam apenas com números. Podemos comparar strings também! A comparação segue a ordem lexicográfica (ordem alfabética), baseada nos valores Unicode dos caracteres.

nome1 = "Ana"
nome2 = "Bruno"
nome3 = "Ana"

print(f"'{nome1}' é igual a '{nome3}'? {nome1 == nome3}")
print(f"'{nome1}' é diferente de '{nome2}'? {nome1 != nome2}")
print(f"'{nome1}' vem antes de '{nome2}'? {nome1 < nome2}")

Saída:

'Ana' é igual a 'Ana'? True
'Ana' é diferente de 'Bruno'? True
'Ana' vem antes de 'Bruno'? True

Pontos importantes sobre comparação de strings:

A comparação é case-sensitive: "Python" != "python"
Letras maiúsculas vêm antes de minúsculas na ordem Unicode
Para ignorar maiúsculas/minúsculas, converta as strings: texto.lower() ou texto.upper()

# Comparação case-sensitive
print("Python" == "python")

# Comparação ignorando maiúsculas/minúsculas
texto1 = "Python"
texto2 = "python"
print(texto1.lower() == texto2.lower())

Saída:

False
True

Exemplos Práticos#

Exemplo 1: Sistema de aprovação de alunos

nota_final = float(input("Digite a nota final do aluno: "))
media_minima = 7.0

if nota_final >= media_minima:
    print(f"Aluno APROVADO com nota {nota_final}")
else:
    print(f"Aluno REPROVADO com nota {nota_final}")

Exemplo de execução:

Digite a nota final do aluno: 8.5
Aluno APROVADO com nota 8.5

Exemplo 2: Validação de idade

idade = int(input("Digite sua idade: "))
idade_minima = 18

if idade >= idade_minima:
    print("Acesso permitido.")
else:
    anos_faltando = idade_minima - idade
    print(f"Acesso negado. Você precisa ter pelo menos {idade_minima} anos.")
    print(f"Faltam {anos_faltando} ano(s).")

Exemplo de execução:

Digite sua idade: 16
Acesso negado. Você precisa ter pelo menos 18 anos.
Faltam 2 ano(s).

Exemplo 3: Validação de login

usuario_correto = "admin"
senha_correta = "1234"

usuario = input("Usuário: ")
senha = input("Senha: ")

if usuario == usuario_correto and senha == senha_correta:
    print("Login realizado com sucesso!")
else:
    print("Usuário ou senha incorretos.")

Exemplo de execução:

Usuário: admin
Senha: 1234
Login realizado com sucesso!

Combinando Comparações#

Os operadores relacionais são frequentemente usados com estruturas condicionais (if, elif, else) e podem ser combinados com operadores lógicos (and, or, not), que veremos na próxima seção.

Os operadores relacionais são a base para criar programas inteligentes que tomam decisões. Eles trabalham em conjunto com as estruturas condicionais para controlar o fluxo do programa baseado em diferentes situações.

Operadores Lógicos#

Vimos que os operadores relacionais nos permitem fazer comparações simples. Mas e quando precisamos verificar múltiplas condições ao mesmo tempo? Por exemplo: “o usuário tem mais de 18 anos E possui carteira de habilitação?” ou “o pagamento foi feito por cartão OU por PIX?”.

Para essas situações, usamos os operadores lógicos. Eles nos permitem combinar várias condições booleanas em uma única expressão, criando lógicas mais complexas e poderosas.

Tabela de Operadores Lógicos#

Operador	Símbolo	Descrição	Exemplo	Resultado	Precedência
E lógico	`and`	Retorna `True` apenas se ambas as condições forem verdadeiras	`True and False`	`False`	Média
Ou lógico	`or`	Retorna `True` se pelo menos uma das condições for verdadeira	`True or False`	`True`	Baixa
Negação	`not`	Inverte o valor booleano	`not True`	`False`	Alta

Entendendo Cada Operador#

Operador and (E lógico)

O operador and exige que todas as condições sejam verdadeiras:

idade = 20
tem_carteira = True

pode_dirigir = (idade >= 18) and tem_carteira
print(pode_dirigir)

Saída:

True

Tabela Verdade do and:

Condição A	Condição B	A and B
`True`	`True`	`True`
`True`	`False`	`False`
`False`	`True`	`False`
`False`	`False`	`False`

Operador or (OU lógico)

O operador or precisa que pelo menos uma condição seja verdadeira:

tem_cartao = False
tem_dinheiro = True

pode_pagar = tem_cartao or tem_dinheiro
print(pode_pagar)

Saída:

True

Tabela Verdade do or:

Condição A	Condição B	A or B
`True`	`True`	`True`
`True`	`False`	`True`
`False`	`True`	`True`
`False`	`False`	`False`

Operador not (Negação)

O operador not inverte o valor booleano:

esta_chovendo = False
sair_para_correr = not esta_chovendo
print(sair_para_correr)

Saída:

True

Tabela Verdade do not:

Condição	not Condição
`True`	`False`
`False`	`True`

Precedência dos Operadores Lógicos#

Quando combinamos múltiplos operadores lógicos, eles são avaliados nesta ordem:

not (mais alta precedência)
and (média precedência)
or (mais baixa precedência)

# Exemplo sem parênteses
resultado1 = True or True and False
print(resultado1)

# Exemplo com parênteses (mudamos a ordem)
resultado2 = (True or True) and False
print(resultado2)

Saída:

True
False

Dica - Clareza no Código

Mesmo quando não é obrigatório, use parênteses para tornar suas expressões mais claras e legíveis!

Exemplos Práticos#

Exemplo 1: Verificando se um número está em um intervalo

nota = float(input("Digite a nota (0-10): "))

# Verificar se a nota está entre 0 e 10
nota_valida = (nota >= 0) and (nota <= 10)

if nota_valida:
    print(f"Nota {nota} é válida!")
else:
    print(f"Nota {nota} é inválida! Digite um valor entre 0 e 10.")

Exemplo de execução:

Digite a nota (0-10): 8.5
Nota 8.5 é válida!

Exemplo 2: Verificando múltiplas formas de pagamento

forma_pagamento = input("Forma de pagamento (cartao/dinheiro/pix): ").lower()

# Aceita qualquer uma das três formas
pagamento_aceito = (forma_pagamento == "cartao") or \
                   (forma_pagamento == "dinheiro") or \
                   (forma_pagamento == "pix")

if pagamento_aceito:
    print("Pagamento aceito!")
else:
    print("Forma de pagamento não aceita.")

Exemplo de execução:

Forma de pagamento (cartao/dinheiro/pix): pix
Pagamento aceito!

Exemplo 3: Sistema de acesso com múltiplas validações

idade = int(input("Digite sua idade: "))
tem_autorizacao = input("Tem autorização dos pais? (sim/nao): ").lower() == "sim"

# Pode entrar se: tem 18+ OU (tem menos de 18 MAS tem autorização)
pode_entrar = (idade >= 18) or (idade < 18 and tem_autorizacao)

if pode_entrar:
    print("Acesso permitido!")
else:
    print("Acesso negado. Menores de 18 precisam de autorização.")

Exemplo de execução:

Digite sua idade: 16
Tem autorização dos pais? (sim/nao): sim
Acesso permitido!

Exemplo 4: Validação de senha forte

senha = input("Digite sua senha: ")

# Critérios para senha forte
tem_minimo_caracteres = len(senha) >= 8
tem_numero = any(char.isdigit() for char in senha)
tem_letra = any(char.isalpha() for char in senha)

# Senha é forte se atende TODOS os critérios
senha_forte = tem_minimo_caracteres and tem_numero and tem_letra

if senha_forte:
    print("Senha forte! Cadastro realizado com sucesso.")
else:
    print("Senha fraca! Use pelo menos 8 caracteres, incluindo letras e números.")

Exemplo de execução:

Digite sua senha: python123
Senha forte! Cadastro realizado com sucesso.

Exemplo 5: Usando not para inverter condições

idade = int(input("Digite sua idade: "))

# Verifica se NÃO é maior de idade
if not (idade >= 18):
    print("Você é menor de idade.")
else:
    print("Você é maior de idade.")

Exemplo de execução:

Digite sua idade: 16
Você é menor de idade.

Simplificando Expressões Lógicas#

Às vezes, podemos simplificar nossas expressões lógicas. Por exemplo:

# Forma mais verbosa
if (x > 0) == True:
    print("Positivo")

# Forma simplificada (melhor)
if x > 0:
    print("Positivo")

# Outro exemplo
# Forma mais verbosa
if not (idade < 18):
    print("Adulto")

# Forma simplificada (melhor)
if idade >= 18:
    print("Adulto")

Combinando Tudo#

Os operadores lógicos são extremamente poderosos quando combinados com operadores relacionais:

# Sistema de desconto em loja
valor_compra = float(input("Valor da compra: R$ "))
eh_cliente_vip = input("É cliente VIP? (sim/nao): ").lower() == "sim"
primeira_compra = input("É a primeira compra? (sim/nao): ").lower() == "sim"

# Desconto de 20% para VIP OU primeira compra com valor acima de R$ 100
tem_desconto = eh_cliente_vip or (primeira_compra and valor_compra > 100)

if tem_desconto:
    valor_final = valor_compra * 0.8  # 20% de desconto
    print(f"Você ganhou 20% de desconto!")
    print(f"Valor final: R$ {valor_final:.2f}")
else:
    print(f"Valor final: R$ {valor_compra:.2f}")

Os operadores lógicos são essenciais para criar programas que tomam decisões complexas baseadas em múltiplas condições. Dominar esses operadores permite escrever código mais sofisticado e resolver problemas do mundo real!

Operador Ternário (Expressão Condicional)#

Quando você precisa escolher entre dois valores dependendo de uma condição, Python oferece o operador ternário, também chamado de expressão condicional. Ele permite escrever em uma única linha o que normalmente faríamos com if/else em várias linhas.

Sintaxe#

valor_se_verdadeiro if condição else valor_se_falso

A leitura é direta: “use valor_se_verdadeiro se a condição for verdadeira, senão use valor_se_falso”.

Exemplo Básico#

Suponha que queremos classificar um número como “par” ou “ímpar”:

numero = 10
classificacao = "par" if numero % 2 == 0 else "ímpar"
print(f"{numero} é {classificacao}")

Saída:

10 é par

A versão equivalente com if/else em bloco seria mais longa:

numero = 10
if numero % 2 == 0:
  classificacao = "par"
else:
  classificacao = "ímpar"
print(f"{numero} é {classificacao}")

As duas formas produzem o mesmo resultado — a ternária apenas condensa a lógica em uma única expressão que produz um valor.

Por Que se Chama “Ternário”?#

A maioria dos operadores que vimos até aqui são binários (atuam sobre dois valores: 2 + 3, x and y). Vimos também operadores unários (atuam sobre um único valor: -x, not x). O operador ternário atua sobre três operandos: o valor retornado quando a condição é verdadeira, a condição em si, e o valor retornado quando a condição é falsa.

Mais Exemplos#

Exemplo 1: Definir um desconto baseado em valor mínimo

valor_compra = 250
desconto = 0.10 if valor_compra > 200 else 0.05
print(f"Desconto: {desconto * 100:.0f}%")

Saída:

Desconto: 10%

Exemplo 2: Mensagem de aprovação/reprovação

nota = 7.5
resultado = "Aprovado" if nota >= 6 else "Reprovado"
print(resultado)

Saída:

Aprovado

Exemplo 3: Valor absoluto sem usar abs()

x = -8
modulo = x if x >= 0 else -x
print(modulo)

Saída:

Aninhamento (com cuidado)#

É possível encadear ternários, mas a legibilidade cai rápido. Quando precisar de mais de duas opções, prefira if/elif/else em bloco (que veremos no próximo capítulo):

nota = 8.5
conceito = "A" if nota >= 9 else "B" if nota >= 7 else "C" if nota >= 5 else "D"
print(conceito)

Saída:

Dica - Quando usar o ternário

Use quando a escolha entre dois valores cabe confortavelmente em uma linha e deixa o código mais direto.
Evite quando a condição ou os valores são longos — o if/else em bloco fica mais legível.
Lembre que o ternário é uma expressão (produz um valor que pode ser atribuído ou passado a uma função), enquanto if/else em bloco é uma instrução (executa código). Essa diferença será importante no próximo capítulo, quando combinarmos ternários com compreensões de listas.

Operadores de Associação#

Até agora, aprendemos a fazer cálculos, comparações e combinar condições. Mas muitas vezes precisamos verificar se um elemento pertence ou não pertence a uma coleção de dados. Por exemplo: verificar se uma letra está em uma palavra, se um nome está em uma lista de aprovados, ou se um produto está disponível no estoque.

Para essas situações, Python oferece os operadores de associação: in e not in.

Tabela de Operadores de Associação#

Operador	Símbolo	Descrição	Exemplo	Resultado
Pertence	`in`	Verifica se um valor está presente na sequência	`'a' in 'python'`	`False`
Não pertence	`not in`	Verifica se um valor não está presente na sequência	`'a' not in 'python'`	`True`

Demonstração visual dos operadores in e not in

Tipos de Sequências Suportadas#

Os operadores de associação funcionam com diversos tipos de coleções:

Strings: verificar se uma letra ou palavra está contida
Listas: verificar se um elemento existe na lista
Tuplas: verificar membros em tuplas
Sets: verificar pertencimento (muito eficiente)
Dicionários: verificar se uma chave existe (não valores!)

Exemplos Básicos#

Verificando em strings:

frase = "Python é incrível"

print('P' in frase)
print('Java' in frase)
print('python' in frase)
print('Python' in frase)

# Ignorando maiúsculas/minúsculas
print('python' in frase.lower())

Saída:

True
False
False
True
True

Verificando em listas:

frutas = ['maçã', 'banana', 'laranja', 'uva']

print('banana' in frutas)
print('melancia' in frutas)
print('melancia' not in frutas)

Saída:

True
False
True

Verificando em dicionários:

estoque = {'arroz': 50, 'feijão': 30, 'macarrão': 40}

# Verifica nas CHAVES (não nos valores)
print('arroz' in estoque)
print('açúcar' in estoque)
print(50 in estoque)

Saída:

True
False
False

Exemplos Práticos#

Exemplo 1: Validação de vogais

letra = input("Digite uma letra: ").lower()
vogais = 'aeiou'

if letra in vogais:
    print(f"'{letra}' é uma vogal.")
else:
    print(f"'{letra}' é uma consoante.")

Exemplo de execução:

Digite uma letra: A
'a' é uma vogal.

Exemplo 2: Menu de opções

opcoes_validas = ['1', '2', '3', '4', 'sair']
opcao = input("Escolha uma opção (1-4 ou 'sair'): ")

if opcao in opcoes_validas:
    print(f"Você escolheu: {opcao}")
else:
    print("Opção inválida! Tente novamente.")

Exemplo de execução:

Escolha uma opção (1-4 ou 'sair'): 2
Você escolheu: 2

Exemplo 3: Lista de permissões (blacklist/whitelist)

usuarios_bloqueados = ['spam_user', 'bot123', 'fake_account']
usuario = input("Digite seu nome de usuário: ").lower()

if usuario in usuarios_bloqueados:
    print("Acesso negado! Usuário bloqueado.")
else:
    print("Bem-vindo!")

Exemplo de execução:

Digite seu nome de usuário: bot123
Acesso negado! Usuário bloqueado.

Exemplo 4: Verificando múltiplas palavras-chave

texto = input("Digite uma frase: ").lower()
palavras_proibidas = ['spam', 'golpe', 'fraude']

# Verificar se alguma palavra proibida está no texto
contem_spam = any(palavra in texto for palavra in palavras_proibidas)

if contem_spam:
    print("Mensagem bloqueada! Contém termos proibidos.")
else:
    print("Mensagem enviada com sucesso!")

Exemplo de execução:

Digite uma frase: Oferta especial sem golpe
Mensagem bloqueada! Contém termos proibidos.

Exemplo 5: Sistema de controle de acesso

# Níveis de acesso por departamento
departamentos_admin = ['TI', 'RH', 'Diretoria']
departamento = input("Digite seu departamento: ")

if departamento in departamentos_admin:
    print(f"Acesso ADMINISTRADOR concedido para {departamento}")
else:
    print(f"Acesso USUÁRIO concedido para {departamento}")

Exemplo de execução:

Digite seu departamento: TI
Acesso ADMINISTRADOR concedido para TI

Diferença Entre `in` em Strings e Listas#

É importante entender como in funciona diferentemente em strings e listas:

# Em strings: verifica substring
print('ana' in 'banana')

# Em listas: verifica elemento completo
print('ana' in ['ba', 'na', 'na'])
print('na' in ['ba', 'na', 'na'])

Saída:

True
False
True

Combinando com Outros Operadores#

Os operadores de associação funcionam bem combinados com operadores lógicos:

# Sistema de classificação de filmes
idade = int(input("Digite sua idade: "))
filme = input("Digite o nome do filme: ")

filmes_adultos = ['Filme A', 'Filme B', 'Filme C']

# Pode assistir se: NÃO é filme adulto OU tem 18+
pode_assistir = (filme not in filmes_adultos) or (idade >= 18)

if pode_assistir:
    print(f"Você pode assistir '{filme}'")
else:
    print(f"Você não pode assistir '{filme}' - classificação 18+")

Exemplo de execução:

Digite sua idade: 16
Digite o nome do filme: Filme Infantil
Você pode assistir 'Filme Infantil'

Observações Importantes#

Case-Sensitive:

A verificação diferencia maiúsculas de minúsculas:

print('Python' in 'python')
print('Python'.lower() in 'python')

Saída:

False
True

Em Dicionários:

O operador in verifica apenas as chaves, não os valores:

dados = {'nome': 'João', 'idade': 25}
print('nome' in dados)
print('João' in dados)
print('João' in dados.values())

Saída:

True
False
True

Strings e Substrings:

Em strings, in encontra substrings, não apenas caracteres individuais:

print('thon' in 'Python')

Saída:

True

Os operadores de associação são extremamente úteis para validações, filtros e verificações de pertencimento, tornando o código mais limpo e legível!

Operadores de Atribuição#

Já vimos o operador de atribuição simples (=) ao declarar variáveis. Mas Python oferece operadores de atribuição combinados que tornam nosso código mais conciso e eficiente. Esses operadores realizam uma operação e atribuem o resultado à variável em uma única etapa.

Tabela de Operadores de Atribuição#

Operador	Descrição	Exemplo	Equivalente a	Resultado
`=`	Atribuição simples	`x = 5`	-	`x` recebe `5`
`+=`	Soma e atribui	`x += 3`	`x = x + 3`	`x` é incrementado em `3`
`-=`	Subtrai e atribui	`x -= 2`	`x = x - 2`	`x` é decrementado em `2`
`*=`	Multiplica e atribui	`x *= 4`	`x = x * 4`	`x` é multiplicado por `4`
`/=`	Divide e atribui	`x /= 2`	`x = x / 2`	`x` é dividido por `2`
`//=`	Divisão inteira e atribui	`x //= 3`	`x = x // 3`	`x` recebe a divisão inteira por `3`
`%=`	Módulo e atribui	`x %= 5`	`x = x % 5`	`x` recebe o resto da divisão por `5`
`**=`	Exponenciação e atribui	`x **= 2`	`x = x ** 2`	`x` é elevado ao quadrado

Por Que Usar Operadores de Atribuição Combinados?#

Os operadores combinados tornam o código:

Mais curto: menos digitação
Mais legível: intenção mais clara
Mais eficiente: em alguns casos, pode ser otimizado pelo interpretador

# Forma tradicional
contador = 0
contador = contador + 1
print(contador)

# Forma com operador combinado (melhor)
contador = 0
contador += 1
print(contador)

Saída:

1
1

Exemplos Básicos#

Incremento e Decremento:

# Incremento
pontos = 10
pontos += 5
print(f"Pontos: {pontos}")

# Decremento
vidas = 3
vidas -= 1
print(f"Vidas restantes: {vidas}")

Saída:

Pontos: 15
Vidas restantes: 2

Operações Matemáticas:

# Multiplicação
preco = 50.0
preco *= 2
print(f"Preço: R$ {preco}")

# Divisão
valor = 100
valor /= 4
print(f"Valor: {valor}")

# Exponenciação
base = 2
base **= 3
print(f"Resultado: {base}")

Saída:

Preço: R$ 100.0
Valor: 25.0
Resultado: 8

Exemplos Práticos#

Exemplo 1: Sistema de pontuação em jogo

pontos = 0
print(f"Pontos iniciais: {pontos}")

# Jogador acerta resposta fácil
pontos += 10
print(f"Acertou questão fácil! Pontos: {pontos}")

# Jogador acerta resposta difícil
pontos += 50
print(f"Acertou questão difícil! Pontos: {pontos}")

# Jogador usa dica (perde metade dos pontos)
pontos //= 2
print(f"Usou dica! Pontos: {pontos}")

Saída:

Pontos iniciais: 0
Acertou questão fácil! Pontos: 10
Acertou questão difícil! Pontos: 60
Usou dica! Pontos: 30

Exemplo 2: Cálculo de juros compostos

capital_inicial = float(input("Capital inicial: R$ "))
taxa_juros = float(input("Taxa de juros (% ao mês): "))
meses = int(input("Número de meses: "))

capital = capital_inicial

for mes in range(1, meses + 1):
    capital *= (1 + taxa_juros / 100)
    print(f"Mês {mes}: R$ {capital:.2f}")

print(f"\nCapital final: R$ {capital:.2f}")
print(f"Lucro: R$ {capital - capital_inicial:.2f}")

Exemplo de execução:

Capital inicial: R$ 1000
Taxa de juros (% ao mês): 5
Número de meses: 3
Mês 1: R$ 1050.00
Mês 2: R$ 1102.50
Mês 3: R$ 1157.63

Capital final: R$ 1157.63
Lucro: R$ 157.63

Exemplo 3: Contador de caracteres

texto = input("Digite um texto: ")

vogais = 0
consoantes = 0
espacos = 0

for caractere in texto.lower():
    if caractere in 'aeiou':
        vogais += 1
    elif caractere.isalpha():
        consoantes += 1
    elif caractere == ' ':
        espacos += 1

print(f"Vogais: {vogais}")
print(f"Consoantes: {consoantes}")
print(f"Espaços: {espacos}")

Exemplo de execução:

Digite um texto: Python é incrível
Vogais: 6
Consoantes: 9
Espaços: 2

Exemplo 4: Calculadora de desconto progressivo

preco_original = float(input("Preço do produto: R$ "))
quantidade = int(input("Quantidade: "))

# Desconto progressivo por quantidade
desconto_percentual = 0

if quantidade >= 10:
    desconto_percentual += 10
if quantidade >= 20:
    desconto_percentual += 5
if quantidade >= 50:
    desconto_percentual += 10

preco_total = preco_original * quantidade
preco_total *= (1 - desconto_percentual / 100)

print(f"\nPreço original: R$ {preco_original * quantidade:.2f}")
print(f"Desconto: {desconto_percentual}%")
print(f"Preço final: R$ {preco_total:.2f}")

Exemplo de execução:

Preço do produto: R$ 50
Quantidade: 25

Preço original: R$ 1250.00
Desconto: 15%
Preço final: R$ 1062.50

Operadores de Atribuição com Strings#

Os operadores += e *= também funcionam com strings:

# Concatenação com +=
mensagem = "Olá"
mensagem += ", mundo!"
print(mensagem)

# Repetição com *=
separador = "-"
separador *= 30
print(separador)

# Construindo texto gradualmente
relatorio = "Relatório:\n"
relatorio += "- Item 1\n"
relatorio += "- Item 2\n"
relatorio += "- Item 3\n"
print(relatorio)

Saída:

Olá, mundo!
------------------------------
Relatório:
- Item 1
- Item 2
- Item 3

Operadores de Atribuição com Listas#

Com listas, os operadores combinados podem adicionar elementos ou concatenar listas:

# Adicionar elementos com +=
numeros = [1, 2, 3]
numeros += [4, 5]
print(numeros)

# Repetir lista com *=
sequencia = [0]
sequencia *= 5
print(sequencia)

Saída:

[1, 2, 3, 4, 5]
[0, 0, 0, 0, 0]

Observações Importantes#

Precedência:

Os operadores de atribuição têm baixa precedência e são avaliados da direita para a esquerda:

x = y = 10
print(f"x = {x}, y = {y}")

Saída:

x = 10, y = 10

Python não tem ++ ou --:

Importante - Operadores de Incremento

Diferente de linguagens como C ou Java, Python não possui operadores de incremento/decremento unários (++ e --). Use += e -= no lugar!

# Errado em Python
# contador++  # Erro!
# contador--  # Erro!

# Correto em Python
contador = 0
contador += 1
print(contador)
contador -= 1
print(contador)

Saída:

1
0

Modificação in-place:

Operadores combinados modificam a variável original:

lista_a = [1, 2, 3]
lista_b = lista_a
lista_a += [4, 5]

print(lista_a)
print(lista_b)

Saída:

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

Quando Usar Operadores de Atribuição Combinados#

Use operadores combinados quando:

Você está atualizando uma variável baseada em seu valor anterior
O código ficará mais claro e conciso
Você está fazendo operações repetitivas (loops, contadores, acumuladores)

# Bom uso: acumulador em loop
soma = 0
for numero in [1, 2, 3, 4, 5]:
    soma += numero
print(f"Soma: {soma}")

# Bom uso: contador
tentativas = 3
while tentativas > 0:
    senha = input(f"Digite a senha ({tentativas} tentativas): ")
    if senha == "1234":
        print("Acesso permitido!")
        break
    tentativas -= 1
else:
    print("Acesso bloqueado!")

Exemplo de saída (com senha correta):

Digite a senha (3 tentativas): 1234
Acesso permitido!

Os operadores de atribuição combinados são ferramentas poderosas que tornam o código mais elegante e expressivo, especialmente em loops e operações repetitivas!

Operações com Bits#

Até agora, trabalhamos com operadores que manipulam números de forma “natural” - somando, subtraindo, comparando. Mas existe um nível ainda mais fundamental: as operações com bits. Essas operações trabalham diretamente com a representação binária dos números (0s e 1s).

Embora pareçam avançadas, as operações com bits são importantes em áreas como:

Criptografia: embaralhar e proteger dados
Compressão de dados: reduzir o tamanho de arquivos
Comunicação com hardware: controlar dispositivos eletrônicos
Otimização de desempenho: operações muito rápidas em sistemas de baixo nível
Manipulação de imagens: processamento de pixels

Representação Binária#

Antes de entender os operadores, vamos relembrar como números são representados em binário:

# Convertendo decimal para binário
numero = 5
binario = bin(numero)
print(f"{numero} em binário: {binario}")

# Convertendo binário para decimal
binario_string = "1101"
decimal = int(binario_string, 2)
print(f"{binario_string} em decimal: {decimal}")

Saída:

5 em binário: 0b101
1101 em decimal: 13

Nota: O prefixo 0b indica que o número está em formato binário.

Outros operadores: Python também oferece o operador de inversão de bits (~), mas este é raramente usado em programação básica e não será abordado neste capítulo.

Operadores de Deslocamento de Bits#

Os operadores de deslocamento movem os bits de um número para a esquerda ou direita. Essas operações são equivalentes a multiplicar ou dividir por potências de 2.

Deslocamento à Esquerda (`<<`)#

Move os bits para a esquerda, preenchendo com zeros à direita. Cada posição deslocada multiplica o número por 2.

numero = 5

# Deslocar 1 posição à esquerda
resultado1 = numero << 1
print(f"{numero} << 1 = {resultado1}")

# Deslocar 2 posições à esquerda
resultado2 = numero << 2
print(f"{numero} << 2 = {resultado2}")

# Deslocar 3 posições à esquerda
resultado3 = numero << 3
print(f"{numero} << 3 = {resultado3}")

Saída:

<< 1 = 10
<< 2 = 20
<< 3 = 40

Fórmula: n << k equivale a n * (2 ** k)

Deslocamento à Direita (`>>`)#

Move os bits para a direita, descartando os bits que “saem”. Cada posição deslocada divide o número por 2 (divisão inteira).

numero = 20

# Deslocar 1 posição à direita
resultado1 = numero >> 1
print(f"{numero} >> 1 = {resultado1}")

# Deslocar 2 posições à direita
resultado2 = numero >> 2
print(f"{numero} >> 2 = {resultado2}")

# Deslocar 3 posições à direita
resultado3 = numero >> 3
print(f"{numero} >> 3 = {resultado3}")

Saída:

>> 1 = 10
>> 2 = 5
>> 3 = 2

Fórmula: n >> k equivale a n // (2 ** k)

Visualizando Deslocamentos#

Vamos ver visualmente o que acontece com os bits:

numero = 12

print(f"Número original: {numero:4d} -> {bin(numero)}")
print(f"Deslocado << 1:  {numero << 1:4d} -> {bin(numero << 1)}")
print(f"Deslocado << 2:  {numero << 2:4d} -> {bin(numero << 2)}")
print()
print(f"Número original: {numero:4d} -> {bin(numero)}")
print(f"Deslocado >> 1:  {numero >> 1:4d} -> {bin(numero >> 1)}")
print(f"Deslocado >> 2:  {numero >> 2:4d} -> {bin(numero >> 2)}")

Saída:

Número original:   12 -> 0b1100
Deslocado << 1:    24 -> 0b11000
Deslocado << 2:    48 -> 0b110000

Número original:   12 -> 0b1100
Deslocado >> 1:     6 -> 0b110
Deslocado >> 2:     3 -> 0b11

Números com Sinal vs Sem Sinal#

Em Python, os inteiros têm precisão arbitrária e são sempre com sinal (podem ser positivos ou negativos). No entanto, é importante entender a diferença conceitual:

Números sem sinal (unsigned): Representam apenas valores não negativos. Todos os bits são usados para o valor.
Números com sinal (signed): O bit mais à esquerda indica o sinal (0 = positivo, 1 = negativo). Python usa esta representação.

# Deslocamento com números negativos
numero_negativo = -8
print(f"Número: {numero_negativo}")
print(f"Binário: {bin(numero_negativo)}")
print(f"Deslocado >> 1: {numero_negativo >> 1}")
print(f"Deslocado << 1: {numero_negativo << 1}")

Saída:

Número: -8
Binário: -0b1000
Deslocado >> 1: -4
Deslocado << 1: -16

Exemplos Práticos#

Exemplo 1: Multiplicação e divisão rápida por potências de 2

# Multiplicar por 2, 4, 8...
valor = 7
print(f"{valor} * 2 = {valor << 1}")
print(f"{valor} * 4 = {valor << 2}")
print(f"{valor} * 8 = {valor << 3}")

print()

# Dividir por 2, 4, 8...
valor = 100
print(f"{valor} / 2 = {valor >> 1}")
print(f"{valor} / 4 = {valor >> 2}")
print(f"{valor} / 8 = {valor >> 3}")

Saída:

* 2 = 14
* 4 = 28
* 8 = 56

/ 2 = 50
/ 4 = 25
/ 8 = 12

Exemplo 2: Verificar se um número é potência de 2

def eh_potencia_de_2(n):
    """
    Um número é potência de 2 se tiver apenas um bit 1.
    Exemplo: 8 = 1000, 16 = 10000
    Truque: n & (n-1) == 0 para potências de 2
    """
    return n > 0 and (n & (n - 1)) == 0

# Testando
numeros = [1, 2, 4, 5, 8, 15, 16, 32, 33]
for num in numeros:
    resultado = "é" if eh_potencia_de_2(num) else "não é"
    print(f"{num} {resultado} potência de 2")

Saída:

é potência de 2
é potência de 2
é potência de 2
não é potência de 2
é potência de 2
não é potência de 2
é potência de 2
é potência de 2
não é potência de 2

Exemplo 3: Converter entre binário e decimal

# Função para exibir conversões
def exibir_conversao(decimal):
    binario = bin(decimal)[2:]
    print(f"Decimal: {decimal:3d} | Binário: {binario:>8s}")

print("Conversões Decimal -> Binário:")
for i in [5, 10, 15, 28, 42, 100]:
    exibir_conversao(i)

print("\nConversões Binário -> Decimal:")
binarios = ["1010", "1111", "10000", "11001"]
for b in binarios:
    decimal = int(b, 2)
    print(f"Binário: {b:>8s} | Decimal: {decimal}")

Saída:

Conversões Decimal -> Binário:
Decimal:   5 | Binário:      101
Decimal:  10 | Binário:     1010
Decimal:  15 | Binário:     1111
Decimal:  28 | Binário:    11100
Decimal:  42 | Binário:   101010
Decimal: 100 | Binário:  1100100

Conversões Binário -> Decimal:
Binário:     1010 | Decimal: 10
Binário:     1111 | Decimal: 15
Binário:    10000 | Decimal: 16
Binário:    11001 | Decimal: 25

Outros Operadores Bitwise#

Embora não tenhamos detalhado neste capítulo introdutório, Python oferece outros operadores para manipulação de bits:

& (AND): Retorna 1 apenas se ambos os bits forem 1
| (OR): Retorna 1 se pelo menos um bit for 1
^ (XOR): Retorna 1 se os bits forem diferentes
~ (NOT): Inverte todos os bits

Esses operadores são extremamente úteis em programação de baixo nível e veremos mais sobre eles em capítulos avançados.

Quando Usar Operações com Bits?#

Na maioria dos casos, você usará operadores aritméticos normais. Use operações com bits quando:

Precisar de performance extrema em cálculos específicos
Trabalhar com protocolos de comunicação de baixo nível
Manipular flags e máscaras de bits
Implementar algoritmos de criptografia ou compressão
Trabalhar com processamento de imagens

Para iniciantes, é mais importante entender o conceito do que dominar todos os detalhes. Conforme avançar em programação, essas operações se tornarão mais relevantes!

Precedência dos Operadores (Resumo)#

Ao longo deste capítulo, vimos diversos tipos de operadores. Quando combinamos vários deles em uma única expressão, Python precisa decidir qual operação executar primeiro. Essa ordem é determinada pela precedência de operadores.

Entender a precedência é crucial para:

Escrever expressões corretas
Ler e entender código de outras pessoas
Evitar bugs sutis em cálculos complexos

Tabela Completa de Precedência#

A tabela abaixo apresenta os operadores em ordem de precedência, da mais alta (executada primeiro) para a mais baixa (executada por último):

Prioridade	Operador(es)	Tipo	Exemplo	Descrição
1ª (Mais alta)	`()`	Parênteses	`(2 + 3) * 4`	Agrupa expressões e força avaliação
2ª	`**`	Exponenciação	`2 ** 3`	Potenciação
3ª	`~`, `+`, `-`	Unários	`-x`, `~5`, `+3`	Negação, inversão de bits, sinal positivo
4ª	`*`, `/`, `//`, `%`	Multiplicativos	`4 * 2`, `10 / 3`, `10 % 3`	Multiplicação, divisão, divisão inteira, módulo
5ª	`+`, `-`	Aditivos	`5 + 3`, `10 - 2`	Adição e subtração
6ª	`<<`, `>>`	Deslocamento de bits	`8 << 1`, `16 >> 2`	Deslocamento à esquerda/direita
7ª	`&`	AND bitwise	`5 & 3`	E bit a bit
8ª	`^`	XOR bitwise	`5 ^ 3`	OU exclusivo bit a bit
9ª	`\|`	OR bitwise	`5 \| 3`	OU bit a bit
10ª	`==`, `!=`, `<`, `<=`, `>`, `>=`	Relacionais	`x > 5`, `a == b`	Comparações
11ª	`in`, `not in`	Associação	`'a' in 'python'`	Pertencimento
12ª	`not`	Negação lógica	`not True`	Inversão lógica
13ª	`and`	E lógico	`True and False`	E lógico
14ª	`or`	OU lógico	`True or False`	OU lógico
15ª (Mais baixa)	`=`, `+=`, `-=`, `*=`, etc.	Atribuição	`x = 5`, `y += 3`	Atribuição de valores

Regras Importantes#

Parênteses são seus amigos

Regra de Ouro - Precedência de Operadores

Quando houver dúvida sobre a ordem de avaliação, use parênteses! Eles tornam o código mais legível e garantem a ordem desejada.

# Sem parênteses - pode confundir
resultado = 10 + 5 * 2 - 3
print(resultado)

# Com parênteses - intenção clara
resultado = 10 + (5 * 2) - 3
print(resultado)

# Mudando a ordem
resultado = (10 + 5) * (2 - 3)
print(resultado)

Saída:

17
17
-15

Mesma precedência: esquerda para direita

Quando operadores têm a mesma precedência, são avaliados da esquerda para a direita:

resultado = 10 - 5 - 2
print(resultado)

resultado = 100 / 10 / 2
print(resultado)

Saída:

3
5.0

Exceção: A exponenciação (**) é avaliada da direita para a esquerda:

resultado = 2 ** 3 ** 2
print(resultado)

Saída:

Atribuição tem precedência mais baixa

Operadores de atribuição são sempre avaliados por último:

x = 5 + 3 * 2
print(x)

Saída:

Exemplos Práticos Passo a Passo#

Exemplo 1: Expressão com múltiplos operadores

resultado = 2 + 3 * 4 ** 2 - 10 / 2
print(resultado)

Ordem de avaliação:

4 ** 2 = 16 (exponenciação - mais alta)
3 * 16 = 48 (multiplicação)
10 / 2 = 5.0 (divisão)
2 + 48 = 50 (adição - esquerda para direita)
50 - 5.0 = 45.0 (subtração)

Saída:

45.0

Exemplo 2: Combinando operadores lógicos e relacionais

idade = 25
tem_carteira = True
resultado = idade >= 18 and tem_carteira or not tem_carteira
print(resultado)

Ordem de avaliação:

idade >= 18 = True (relacional)
not tem_carteira = False (negação lógica)
True and True = True (and - esquerda para direita)
True or False = True (or)

Saída:

True

Exemplo 3: Operações com bits e aritméticas

resultado = 5 + 3 << 2
print(resultado)

Ordem de avaliação:

5 + 3 = 8 (adição tem precedência maior que deslocamento)
8 << 2 = 32 (deslocamento à esquerda)

Saída:

Mas se quisermos deslocar 3 primeiro:

resultado = 5 + (3 << 2)
print(resultado)

Saída:

Exemplo Completo: Expressão Complexa#

Vamos avaliar uma expressão que combina vários tipos de operadores:

a = 10
b = 5
c = 2

resultado = a + b * c ** 2 >= 30 and not b < c or a // b == 2
print(resultado)

Passo a passo:

c ** 2 = 4 (exponenciação - mais alta)
b * 4 = 20 e a // b = 2 (multiplicação e divisão inteira)
a + 20 = 30 (adição)
30 >= 30 = True, b < c = False, 2 == 2 = True (relacionais)
not False = True (negação lógica)
True and True = True (and)
True or True = True (or)

Saída:

True

Dicas para Escrever Código Claro#

Use parênteses generosamente

# Menos claro
x = 10
y = 5
z = 0
if x > 5 and y < 10 or z == 0:
    print("Condição verdadeira")

# Mais claro
if (x > 5 and y < 10) or (z == 0):
    print("Condição verdadeira")

Saída:

Condição verdadeira
Condição verdadeira

Use variáveis intermediárias

# Menos claro
a = 10
b = 5
c = 3
d = 20
e = 100
f = 50
g = 60
h = True

if a + b * c > d and e / f < g or h:
    print("Resultado: Verdadeiro")

# Mais claro
soma_ponderada = a + b * c
razao = e / f
if (soma_ponderada > d and razao < g) or h:
    print("Resultado: Verdadeiro")

Saída:

Resultado: Verdadeiro
Resultado: Verdadeiro

Regra de Ouro - Precedência de Operadores

A precedência de operadores é uma ferramenta poderosa, mas não abuse dela! Código claro é melhor que código “inteligente”. Quando em dúvida:

Use parênteses
Quebre expressões complexas
Adicione comentários explicativos

Com a prática, você naturalmente internalizará essas precedências e escreverá código mais eficiente e legível!

Exercícios#

“Antes de começar os exercícios, é importante notar que para testes com múltiplas entradas em uma mesma linha, é útil utilizar o método .split(). Este método divide a string recebida pelo input() em substrings, utilizando espaços em branco como delimitadores. Ele retorna uma lista contendo as substrings resultantes.

Por exemplo, para uma entrada: 1 1 6 6 4 4

entrada = input().split()
print(entrada)

Ao executar o código acima com a entrada 1 1 6 6 4 4, a saída será:

['1', '1', '6', '6', '4', '4']

Dada a expressão matemática: \(a = 4 * (2 + 3) - 7\). Crie uma variável chamada a e atribua a ela o resultado dessa expressão. Em seguida, crie uma variável chamada b e atribua a ela o valor de a multiplicado por 2. Por fim, imprima os valores de a e b.

# Teste 1
Entrada: Sem entrada
Saída:
O valor de 'a' é: 13
O valor de 'b' é: 26

Escreva um programa que solicita ao usuário um número inteiro positivo entre 100 e 1000. Em seguida, o programa deve calcular o resto da divisão desse número por 5, armazenar o resultado em uma variável chamada resto e imprimir este valor.

Certifique-se de que o programa lide adequadamente com entradas inválidas. Caso o usuário insira um número negativo ou fora do intervalo especificado, exiba a seguinte mensagem de erro: “Por favor, insira um número inteiro positivo entre 100 e 1000.”

# Teste 1
Entrada: 172
Saída: O resto da divisão de 172 por 5 é 2.

# Teste 2
Entrada: -10
Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.

# Teste 3
Entrada: 2000
Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.

# Teste 4
Entrada: 500
Saída: O resto da divisão de 500 por 5 é 0.

Escreva um programa que converta uma temperatura de Celsius para Fahrenheit. Utilize a fórmula: \(F = \frac{9}{5} * C + 32\).

Solicite ao usuário que digite a temperatura em Celsius.
Em seguida, converta a temperatura digitada para Fahrenheit utilizando a fórmula fornecida.
Por fim, exiba na tela o resultado da conversão para o usuário, formatado com 2 casas decimais.

# Teste 1
Entrada: 20.5
Saída: A temperatura em Fahrenheit é: 68.90

# Teste 2
Entrada: 0.75
Saída: A temperatura em Fahrenheit é: 33.35

Escreva um programa que recebe na entrada um número inteiro entre 10 e 20. O programa deverá converter esse número para sua representação binária, removendo o prefixo '0b' da conversão. Em seguida, cada bit dessa representação binária será salvo em uma lista, onde cada posição da lista conterá um dos bits. Por fim, o programa deverá imprimir o resultado.

# Teste 1
Entrada: 10
Saída: ['1', '0', '1', '0']

# Teste 2
Entrada: 16
Saída: ['1', '0', '0', '0', '0']

# Teste 3
Entrada: 34
Saída: O número inserido não está dentro do intervalo permitido.

Utilizando tuplas, você deve receber as coordenadas de um retângulo no plano cartesiano, onde (x_min, y_min) representa o canto inferior esquerdo e (x_max, y_max) representa o canto superior direito. Além disso, você tem um ponto representado por um par de coordenadas (x, y).

Sua tarefa é escrever um programa que determine se o ponto está dentro, tocando na borda ou fora do retângulo. O programa deve imprimir uma mensagem na saída padrão indicando o resultado da verificação.

Veja o exemplo didático do desenho ASCII para o Teste 1:

O + representa os cantos do retângulo.
O . representa o ponto.
As coordenadas do retângulo são (x_min, y_min) = (1,1) e (x_max, y_max) = (6,6).
As coordenadas do ponto são (x, y) = (4,4).

|          
|   +--------------+ (6,6)
|   |              |
|   |       .(4,4) |
|   |              |
|   |              |
|   +--------------+
| (1,1)        
  -+--+--+--+--+--+--+--+
1  2  3  4  5  6  7

# Teste 1
Entrada: 1 1 6 6 4 4
Saída: O ponto está dentro do retângulo.

# Teste 2
Entrada: 1 1 6 6 6 6
Saída: O ponto está tocando a borda do retângulo.

# Teste 3
Entrada: 1 1 6 6 0 1
Saída: O ponto está fora do retângulo.

# Teste 4
Entrada: 1 1 6 6 1 7
Saída: O ponto está fora do retângulo.

# Teste 5
Entrada: 1 1 6 6 6 1
Saída: O ponto está tocando a borda do retângulo.

# Teste 6
Entrada: 1 1 6 6 4 6
Saída: O ponto está tocando a borda do retângulo.

Desenvolva um sistema de autenticação que utilize um dicionário chamado usuarios_senhas para armazenar os nomes e as senhas de dois usuários. O programa deve solicitar que o usuário insira seu nome de usuário e senha. Em seguida, o sistema deve verificar se as credenciais inseridas correspondem às armazenadas no dicionário. Se as credenciais estiverem corretas, o programa deve exibir uma mensagem de “Login bem-sucedido! Bem-vindo, usuário.”. Caso contrário, deve informar ao usuário “Acesso negado. Credenciais inválidas.”.

Obs: Serão armazenados apenas três usuários.

# Teste 1
Entrada: usuario1 senha123 usuario2 abc456 usuario3 123456 usuario1 senha123
Saída: >> Login bem-sucedido! Bem-vindo, usuario1.

# Teste 2
Entrada: usuario1 senha143 usuario2 abc452 usuario3 654321 usuario2 123abc
Saída: >> Acesso negado. Credenciais inválidas.

Você é um biólogo trabalhando em um parque natural e está encarregado de monitorar três espécies de aves migratórias. Cada espécie tem um conjunto de ilhas preferidas para nidificação durante a temporada de migração. As preferências das espécies são as seguintes:

Espécie 1: Prefere as ilhas com IDs de 1 a 10.
Espécie 2: Prefere as ilhas com IDs de 6 a 17.

Algumas ilhas são compartilhadas entre as espécies, o que pode levar à competição por recursos. Seu trabalho é identificar quais ilhas são compartilhadas para implementar medidas de conservação. Dessa forma, dada uma entrada do usuário correspondente ao ID de uma das ilhas, verifique se essa ilha específica é uma área de competição ou se é exclusiva de uma das espécies.

# Teste 1
Entrada: 2
Saída: Ilha 2 é exclusiva da Espécie 1. 
Portanto, não é compartilhada com outras espécies.

# Teste 2
Entrada: 6
Saída: Ilha 6 é compartilhada entre espécie(s):1 2.

# Teste 3
Entrada: 10
Saída: Ilha 10 é compartilhada entre espécie(s):1 2.

# Teste 4
Entrada: 17
Saída: 
Ilha 17 é exclusiva da Espécie 2. 
Portanto, não é compartilhada com outras espécies.

Auxiliando o Hacker Neo a Desvendar a Verdade Sobre a Realidade.

História da Matrix: Neo, um hacker talentoso, vive uma vida dupla. No mundo que ele conhece, ele é um programador comum. Mas, e se existisse uma realidade escondida, uma verdade que ele nunca imaginou?

Após ser contatado por Morpheus, Neo se depara com uma escolha crítica: tomar a pílula vermelha e desvendar a verdade, ou tomar a pílula azul e continuar vivendo sua vida como sempre.

Fases do Programa:

Fase 1: A Escolha ● ●

Neo deve escolher entre a pílula vermelha e a pílula azul. A escolha é feita através de um input do usuário:
- Se o usuário digitar “vermelha”, Neo avança para a fase 2.
- Se o usuário digitar “azul”, Neo continua vivendo sua vida normal e o programa termina.

Fase 2: Desvendando a Realidade

Neo precisa questionar a realidade em que vive. Ele deve responder a três perguntas:
- A realidade que você conhece é real? (Sim ou Não)
- Existe uma realidade escondida? (Sim ou Não)
- Você quer desvendar a verdade? (Sim ou Não)

Fase 3: Explorando a Verdade

Se Neo responder “Sim” a todas as perguntas da fase 2, ele terá acesso a informações sobre a verdade, e o programa termina com uma mensagem de sucesso.
Se Neo responder “Não” a qualquer uma das perguntas da fase 2, ele continua vivendo sua vida normal, e o programa termina com uma mensagem de que a escolha é dele.

Exemplos de Teste:

# Teste 1
Entrada: Vermelha Sim Não Sim
Saída: A escolha é sua, Neo continua vivendo sua vida normal.

# Teste 2
Entrada: Azul
Saída: Neo continua vivendo sua vida normal.

# Teste 3
Entrada: Vermelha Não Sim Sim 
Saída: A escolha é sua, Neo continua vivendo sua vida normal.

# Teste 4
Entrada: Vermelha Sim Sim Sim
Saída: Neo terá acesso a informações sobre a verdade.

Você é um fotógrafo profissional. Durante um trabalho, você se depara com um lago cristalino cercado por imensas montanhas. Seu objetivo é capturar uma foto aérea épica do lago, utilizando um drone. Para garantir a melhor perspectiva, você precisa determinar a altura ideal de voo do drone. Para isso, será necessário saber a distância horizontal entre você e a margem do lago, bem como a altura vertical que deseja alcançar com o drone.

A hipotenusa, que representa a distância diagonal percorrida pelo drone, pode ser calculada utilizando o Teorema de Pitágoras:

\( Hipotenusa = \sqrt(CatetoAdjacente^2 + CatetoOposto^2) \)

Seu programa receberá como entrada, em metros, o comprimento do cateto adjacente e do cateto oposto, e calculará a hipotenusa correspondente.

Exemplos de Teste:

# Teste 1
Entrada: 50 30
Saída: 58.00 metros

# Teste 2
Entrada: 40 20
Saída: 44.72 metros

# Teste 3
Entrada: 70 50
Saída: 86.02 metros

Um artesão está trabalhando em duas peças: um cone de metal e um paralepípedo de madeira. Para ajudá-lo em seu projeto, você precisa desenvolver um programa que receba as informações de dimensões em cm desses objetos e calcule seus volumes e massas.

Receber na entrada as seguintes informações para o cone: Altura e Raio.
Em seguida, receber as informações para o paralepípedo: Altura, Largura e Comprimento.

Considerando as fórmulas matemáticas adequadas para calcular o volume de cada objeto:

Volume do Cone: \(V_{\text{cone}} = \frac{1}{3} \pi r^2 h\)

Volume do Paralepípedo: \( V_{\text{paralel}} = l \times w \times h \)

Calcule a massa de cada objeto, considerando que a densidade do metal é de 8 g/cm³ e a densidade da madeira é de 0,5 g/cm³. Qual dos dois objetos, cone ou paralepípedo, é mais pesado? Considere que eles possuem o mesmo peso se a diferença entre as massas for menor do que 5g.

Exemplos de Teste:

# Teste 1
Entrada: 10 5 19 8 6
Saída: O cone é mais pesado com 2094.4g.

# Teste 2
Entrada: 4 2 10 8 8
Saída: O paralelepípedo é mais pesado com 320.0g.

# Teste 3
Entrada: 10 2.44 10 10 10
Saída: O paralepípedo e o cone possuem o mesmo peso.

# Teste 4
Entrada: 20 4.886 20 20 20
Saída: O paralepípedo e o cone possuem o mesmo peso.

Capítulo 3: Operadores e Expressões

Contents

Capítulo 3: Operadores e Expressões#

Operadores Aritméticos#

Tabela de Operadores Aritméticos#

Entendendo Cada Operador#

Exemplos Práticos#

Precedência dos Operadores Aritméticos#

Operadores Unários#

Operadores Relacionais#

Tabela de Operadores Relacionais#

Exemplos Básicos#

Comparação de Strings#

Exemplos Práticos#

Combinando Comparações#

Operadores Lógicos#

Tabela de Operadores Lógicos#

Entendendo Cada Operador#

Precedência dos Operadores Lógicos#

Exemplos Práticos#

Simplificando Expressões Lógicas#

Combinando Tudo#

Operador Ternário (Expressão Condicional)#

Sintaxe#

Exemplo Básico#

Por Que se Chama “Ternário”?#

Mais Exemplos#

Aninhamento (com cuidado)#

Operadores de Associação#

Tabela de Operadores de Associação#

Tipos de Sequências Suportadas#

Exemplos Básicos#

Exemplos Práticos#

Diferença Entre in em Strings e Listas#

Combinando com Outros Operadores#

Observações Importantes#

Operadores de Atribuição#

Tabela de Operadores de Atribuição#

Por Que Usar Operadores de Atribuição Combinados?#

Exemplos Básicos#

Exemplos Práticos#

Operadores de Atribuição com Strings#

Operadores de Atribuição com Listas#

Observações Importantes#

Quando Usar Operadores de Atribuição Combinados#

Operações com Bits#

Representação Binária#

Operadores de Deslocamento de Bits#

Deslocamento à Esquerda (<<)#

Deslocamento à Direita (>>)#

Visualizando Deslocamentos#

Números com Sinal vs Sem Sinal#

Exemplos Práticos#

Outros Operadores Bitwise#

Quando Usar Operações com Bits?#

Precedência dos Operadores (Resumo)#

Tabela Completa de Precedência#

Regras Importantes#

Exemplos Práticos Passo a Passo#

Exemplo Completo: Expressão Complexa#

Dicas para Escrever Código Claro#

Exercícios#

Diferença Entre `in` em Strings e Listas#

Deslocamento à Esquerda (`<<`)#

Deslocamento à Direita (`>>`)#