# Uma linha ja e um programa completo.
print("Olá, mundo!")
print("Manual de Experimentos com Python")

# Comentario de linha: tudo apos o # e ignorado.
print("Executando")  # comentario no fim da linha

def area_circulo(raio):
    """Retorna a área de um círculo de raio informado."""
    return 3.14159 * raio ** 2

print(area_circulo(2))
print(area_circulo.__doc__)

temperatura = 31

if temperatura > 30:
    print("Dentro do bloco: está calor")
    print("Ainda dentro do bloco")

print("Fora do bloco: executa sempre")

if 10 > 5:
print("faltou recuar esta linha")

# Ponto e virgula no fim da linha nao e necessario.
nome = "Python"

# Forma preferida: quebrar dentro de parenteses.
total = (10 + 20 + 30 +
         40 + 50)

# Alternativa com barra invertida (use com moderacao).
media = 10 + 20 \
        + 30

print(nome, total, media)

print("Olá", "mundo", 2026)
print(42)
print("Soma:", 2 + 3)

print("A", "B", "C", sep="-")
print("2026", "07", "22", sep="/")

print("Esta linha", end=" ")
print("continua aqui.")

print("Sem quebra no fim", end="")
print(" | e o resto vem junto")

nome = input("Digite seu nome: ")
idade = input("Digite sua idade: ")

print("Olá,", nome)
print("Tipo do que foi digitado:", type(idade))

idade = int(input("Idade: "))
altura = float(input("Altura em metros: "))

print("No ano que vem você terá", idade + 1)
print("Altura em centímetros:", altura * 100)

nome = "Maria"
idade = 25
preco = 29.9

print(f"Nome: {nome}")
print(f"{nome} tem {idade} anos e no ano que vem terá {idade + 1}")
print(f"Preço: R$ {preco:.2f}")

valor = 1234.5678
taxa = 0.0725
item = "Cabo"

print(f"Moeda:      {valor:,.2f}")
print(f"Percentual: {taxa:.2%}")
print(f"Científico: {valor:.3e}")
print(f"Zeros:      {42:05d}")
print(f"Alinhado:   |{item:<10}|{item:>10}|{item:^10}|")
print(f"Depuração:  {valor=}")

nome, idade = "João", 30

print("Nome: {}, Idade: {}".format(nome, idade))
print("Trocando a ordem: {1} anos, {0}".format(nome, idade))
print("Com nomes: {n} ganha R$ {s:.2f}".format(n=nome, s=3500.5))

nome, idade, nota = "Ana", 28, 8.75

print("Nome: %s" % nome)
print("%s tem %d anos e nota %.1f" % (nome, idade, nota))
print("Largura fixa: |%10s|%3d|" % (nome, idade))

nome = input("Aluno: ")
n1 = float(input("Nota 1: "))
n2 = float(input("Nota 2: "))

media = (n1 + n2) / 2
situacao = "Aprovado" if media >= 7 else "Reprovado"

print()
print(f"{'RESULTADO':^28}")
print("-" * 28)
print(f"{'Aluno:':<12}{nome}")
print(f"{'Média:':<12}{media:.2f}")
print(f"{'Situação:':<12}{situacao}")

idade = 25            # int
altura = 1.78         # float
nome = "Python"       # str
ativo = True          # bool

print(idade, type(idade))
print(altura, type(altura))
print(nome, type(nome))
print(ativo, type(ativo))

a, b, c = 1, 2, 3
x = y = z = 100

print(a, b, c, x, y, z)

# Troca sem variavel auxiliar (bem pythonico)
a, b = b, a
print("Depois da troca:", a, b)

# Nome descartavel por convencao
_, sobrenome = "Ramon Martins".split()
print(sobrenome)

a, b = 15, 4

print("soma          ", a + b)
print("subtração     ", a - b)
print("multiplicação ", a * b)
print("divisão       ", a / b)    # sempre float
print("divisão inteira", a // b)  # descarta a parte fracionaria
print("resto         ", a % b)
print("potência      ", a ** b)

x = 10
x += 5      # x = x + 5
x *= 2      # x = x * 2
x -= 4
print("x =", x)

print(abs(-7.5), round(3.14159, 2), pow(2, 10))
print(min(3, 9, 1), max(3, 9, 1), sum([3, 9, 1]))
print(divmod(17, 5))   # quociente e resto de uma vez

import math

a = 0.1 + 0.2
print(a)
print("a == 0.3?", a == 0.3)
print("próximo o bastante?", math.isclose(a, 0.3))

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))

print(int("42") + 8)
print(float("19.99"))
print(str(2026) + "/2")
print(int(8.75))        # trunca, nao arredonda
print(round(8.75))      # arredonda
print(int("1010", 2))   # base 2

# Conversao que falha
# int("abc")  ->  ValueError: invalid literal for int()

nota, frequencia = 8.5, 85

aprovado = nota >= 7 and frequencia >= 75
print("Aprovado:", aprovado)
print("Não aprovado:", not aprovado)
print("Recuperação possível:", nota >= 4 or frequencia >= 90)

# True e False sao inteiros disfarcados
print(True + True, int(False))

vazios = [0, 0.0, "", [], {}, set(), None]
cheios = [1, -3, "texto", [0], {"a": 1}, {0}]

for v in vazios:
    print(f"{repr(v):>8} -> {bool(v)}")

print("---")
print("todos verdadeiros?", all(bool(v) for v in cheios))

valor = 3.14

print(type(valor))
print(type(valor) == float)
print(isinstance(valor, float))
print(isinstance(valor, (int, float)))   # aceita varios tipos

def dobrar(x):
    if isinstance(x, (int, float)):
        return x * 2
    return "Erro: não é número"

print(dobrar(10), dobrar("abc"))

resultado = None          # ausencia de valor
print(resultado, type(resultado))
print("é None?", resultado is None)

# Convencoes de nome (PEP 8)
taxa_juros = 0.05         # snake_case para variaveis
VELOCIDADE_LUZ = 299792458  # MAIUSCULAS para constantes
print(taxa_juros, VELOCIDADE_LUZ)

a = 10

if a < 20:
    print("a é menor que 20")

print("fim")

saldo = 100.0
compra = 149.9

if saldo >= compra:
    print("Compra aprovada")
else:
    print(f"Faltam R$ {compra - saldo:.2f}")

media = 6.4

if media >= 9:
    conceito = "A"
elif media >= 7:
    conceito = "B"
elif media >= 5:
    conceito = "C"
else:
    conceito = "D"

print(f"Média {media} -> conceito {conceito}")

nota = 8.0
frequencia = 60

if nota >= 7:
    if frequencia >= 75:
        print("Aprovado")
    else:
        print("Reprovado por frequência")
else:
    print("Reprovado por nota")

nota, frequencia = 8.0, 60

if nota >= 7 and frequencia >= 75:
    print("Aprovado")
elif nota >= 7 and frequencia < 75:
    print("Reprovado por frequência")
else:
    print("Reprovado por nota")

print("Tem alguma pendência?", not (nota >= 7 and frequencia >= 75))

idade = 25
temperatura = 36.8

# Em Python isso e legal e legivel:
if 18 <= idade < 60:
    print("Faixa adulta")

if 36.0 <= temperatura <= 37.5:
    print("Temperatura normal")

vogais = "aeiou"
letra = "e"
print(letra in vogais)

turma = ["Ana", "Bruno", "Carlos"]
print("Diana" not in turma)

if letra in vogais and "Ana" in turma:
    print("As duas verificações passaram")

idade = 17
status = "maior" if idade >= 18 else "menor"
print(f"Você é {status} de idade")

nota = 6.5
print("Aprovado" if nota >= 7 else "Recuperação")

def descrever(comando):
    match comando.split():
        case ["ligar"]:
            return "Ligando o equipamento"
        case ["desligar"]:
            return "Desligando"
        case ["canal", numero]:
            return f"Mudando para o canal {numero}"
        case _:
            return "Comando desconhecido"

for c in ["ligar", "canal 12", "reiniciar"]:
    print(f"{c:12} -> {descrever(c)}")

print("=== MENU ===")
print("1 - Cadastrar")
print("2 - Consultar")
print("0 - Sair")

opcao = input("Escolha: ")

if opcao == "1":
    print("Cadastro selecionado")
elif opcao == "2":
    print("Consulta selecionada")
elif opcao == "0":
    print("Encerrando")
else:
    print("Opção inválida")

entrada = input("Digite algo: ")

if entrada.isdigit():
    numero = int(entrada)
    tipo = "par" if numero % 2 == 0 else "ímpar"
    print(f"Número inteiro {tipo}")
elif entrada.replace(".", "", 1).isdigit():
    print("Número com casas decimais")
elif entrada.isalpha():
    print("Somente letras")
else:
    print("Combinação de caracteres")

for i in range(5):
    print("volta", i)

print(list(range(10, 15)))
print(list(range(0, 21, 5)))
print(list(range(10, 0, -2)))

for i in range(1, 6):
    print(f"{i} ao quadrado = {i ** 2}")

frutas = ["maçã", "banana", "laranja"]

for fruta in frutas:
    print(f"- {fruta} ({len(fruta)} letras)")

palavra = "engenharia"
vogais = 0

for letra in palavra:
    if letra in "aeiou":
        vogais += 1

print(f"{palavra} tem {vogais} vogais")

cores = ["vermelho", "azul", "verde"]

for i, cor in enumerate(cores):
    print(i, cor)

print("---")
for posicao, cor in enumerate(cores, start=1):
    print(f"{posicao}º lugar: {cor}")

alunos = ["Ana", "Bruno", "Carlos"]
notas = [9.5, 7.0, 8.2]

for aluno, nota in zip(alunos, notas):
    print(f"{aluno:<8} {nota:>4.1f}")

print(dict(zip(alunos, notas)))

i = 0
while i < 5:
    print("valor:", i)
    i += 1

print("fim do laço")

numero = 1
soma = 0

while numero <= 10:
    soma += numero
    numero += 1

print("soma de 1 a 10:", soma)
print("conferindo:", sum(range(1, 11)))

for i in range(1, 100):
    if i * i > 50:
        print(f"o primeiro quadrado acima de 50 é {i * i}")
        break
    print(i * i, end=" ")

for i in range(1, 11):
    if i % 3 == 0:
        continue
    print(i, end=" ")

print("\n(múltiplos de 3 foram pulados)")

nomes = ["Ana", "Bruno", "Carlos"]
procurado = "Diana"

for nome in nomes:
    if nome == procurado:
        print("encontrado")
        break
else:
    print(f"{procurado} não está na lista")

while True:
    print("\n1 - Somar  |  2 - Sobre  |  0 - Sair")
    opcao = input("Opção: ")

    if opcao == "1":
        a = float(input("a: "))
        b = float(input("b: "))
        print("resultado:", a + b)
    elif opcao == "2":
        print("Manual de Experimentos com Python")
    elif opcao == "0":
        print("Encerrando")
        break
    else:
        print("Opção inválida")

for i in range(1, 4):
    print(f"\nTabuada do {i}")
    for j in range(1, 6):
        print(f"  {i} x {j} = {i * j}")

while True:
    try:
        idade = int(input("Idade (0 a 120): "))
    except ValueError:
        print("Digite apenas números inteiros")
        continue

    if 0 <= idade <= 120:
        break
    print("Fora da faixa permitida")

print("Idade registrada:", idade)

frutas = ["maçã", "banana", "laranja"]
mista = ["Python", 3.12, True, None]

print(frutas[0])     # primeiro
print(frutas[-1])    # ultimo
print(len(frutas), len(mista))

animais = ["gato", "cachorro"]

animais.append("pássaro")     # no fim
animais.insert(1, "peixe")    # na posicao 1
print(animais)

animais.remove("gato")        # por valor
ultimo = animais.pop()        # remove e devolve o ultimo
print(ultimo, animais)

animais.extend(["arara", "tatu"])
print(animais)

numeros = [12, 5, 8, 5, 20]

print("tamanho:", len(numeros))
print("soma:", sum(numeros))
print("maior/menor:", max(numeros), min(numeros))
print("média:", sum(numeros) / len(numeros))
print("o 5 aparece", numeros.count(5), "vezes")
print("posição do 8:", numeros.index(8))
print("20 está na lista?", 20 in numeros)

notas = [7.5, 9.0, 5.5, 8.0]

print(sorted(notas))              # copia ordenada
print(sorted(notas, reverse=True))
print("original intacta:", notas)

notas.sort()                      # ordena no lugar
print("depois de sort():", notas)

nomes = ["carlos", "Ana", "bruno"]
print(sorted(nomes, key=str.lower))

letras = ["a", "b", "c", "d", "e", "f", "g"]

print(letras[:3])     # inicio ate 2
print(letras[-3:])    # ultimos tres
print(letras[2:5])    # do meio
print(letras[::2])    # de dois em dois
print(letras[::-1])   # invertida

original = [1, 2, 3]
apelido = original          # mesmo objeto
copia = original.copy()     # objeto novo (ou original[:])

apelido.append(99)

print("original:", original)
print("apelido:", apelido)
print("cópia:", copia)
print("apelido é o mesmo objeto?", apelido is original)

matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

print(matriz[1][2])       # linha 1, coluna 2

for linha in matriz:
    print(" ".join(f"{v:3d}" for v in linha))

diagonal = [matriz[i][i] for i in range(3)]
print("diagonal:", diagonal)

coordenada = (10, 20)
cores = ("vermelho", "azul", "verde")
sozinha = (42,)          # a virgula e obrigatoria
sem_parenteses = 1, 2, 3

print(coordenada[0], cores[-1], sozinha, sem_parenteses)
print(type(sozinha), type((42)))

cores = ("vermelho", "azul")

try:
    cores[0] = "amarelo"
except TypeError as erro:
    print("Erro:", erro)

# Para "mudar", crie outra tupla
cores = cores + ("verde",)
print(cores)

ponto = (15, 25)
x, y = ponto
print(x, y)

pessoa = ("Ramon", 38, "São José")
nome, idade, cidade = pessoa
print(f"{nome}, {idade}, {cidade}")

# O asterisco recolhe o resto
primeiro, *meio, ultimo = [1, 2, 3, 4, 5]
print(primeiro, meio, ultimo)

aluno = {
    "nome": "Maria",
    "curso": "Telecomunicações",
    "fase": 4,
}

print(aluno["nome"])
print(aluno.get("fase"))
print(aluno.get("email", "não informado"))   # valor padrao

estudante = {"nome": "Ana", "curso": "Python"}

estudante["fase"] = 2                       # adiciona
estudante["curso"] = "Ciência de Dados"     # atualiza
estudante.update({"nota": 9.5, "ativo": True})
print(estudante)

nota = estudante.pop("nota")     # remove e devolve
del estudante["ativo"]           # remove
print(nota, estudante)

notas = {"João": 8.5, "Maria": 9.0, "Pedro": 7.5}

for nome in notas:                 # percorre as chaves
    print(nome, end=" ")
print()

for nota in notas.values():
    print(nota, end=" ")
print()

for nome, nota in notas.items():   # forma mais usada
    print(f"{nome:<8} {nota:>4.1f}")

texto = "engenharia de telecomunicacoes"
contagem = {}

for letra in texto:
    if letra == " ":
        continue
    contagem[letra] = contagem.get(letra, 0) + 1

mais_comuns = sorted(contagem.items(),
                     key=lambda par: par[1],
                     reverse=True)
print(mais_comuns[:5])

turma = {
    "Ana":   {"notas": [8.5, 9.0], "faltas": 2},
    "Bruno": {"notas": [7.0, 6.0], "faltas": 6},
}

for nome, dados in turma.items():
    notas = dados["notas"]
    media = sum(notas) / len(notas)
    print(f"{nome:<6} média {media:.1f}  faltas {dados['faltas']}")

frutas = {"maçã", "banana", "maçã"}
print(frutas)

numeros = [1, 2, 2, 3, 3, 3, 4]
print(set(numeros))
print("sem repetidos, ordenado:", sorted(set(numeros)))

vazio = set()      # cuidado: {} cria um dicionario
print(type(vazio), type({}))

cores = {"vermelho", "azul"}

cores.add("amarelo")
cores.update(["verde", "roxo"])
cores.discard("inexistente")   # nao gera erro
cores.remove("roxo")           # geraria KeyError se faltasse

print(sorted(cores))

turma_a = {"Ana", "Bruno", "Carlos", "Diana"}
turma_b = {"Bruno", "Diana", "Eduardo"}

print("união:        ", sorted(turma_a | turma_b))
print("interseção:   ", sorted(turma_a & turma_b))
print("só na turma A:", sorted(turma_a - turma_b))
print("exclusivos:   ", sorted(turma_a ^ turma_b))

vogais = {"a", "e", "i", "o", "u"}
algumas = {"a", "e"}
consoantes = {"x", "y", "z"}

print("a é vogal?", "a" in vogais)
print("subconjunto?", algumas.issubset(vogais))
print("superconjunto?", vogais.issuperset(algumas))
print("sem elementos comuns?", vogais.isdisjoint(consoantes))

from collections import deque

# Pilha: ultimo a entrar, primeiro a sair
pilha = []
pilha.append("página 1")
pilha.append("página 2")
print("desempilhou:", pilha.pop(), "| resta:", pilha)

# Fila: primeiro a entrar, primeiro a sair
fila = deque(["cliente 1", "cliente 2"])
fila.append("cliente 3")
print("atendeu:", fila.popleft(), "| resta:", list(fila))

registros = ["ok", "erro", "ok", "ok", "erro"]

print("lista mantém a ordem e as repetições:", registros)
print("conjunto responde 'quais tipos existem':", set(registros))

resumo = {}
for r in registros:
    resumo[r] = resumo.get(r, 0) + 1
print("dicionário responde 'quantos de cada':", resumo)

print("tupla protege o que não muda:", tuple(sorted(set(registros))))

# Versao com laco
quadrados = []
for n in range(1, 6):
    quadrados.append(n ** 2)
print(quadrados)

# Mesma coisa em uma linha
quadrados = [n ** 2 for n in range(1, 6)]
print(quadrados)

numeros = [12, 7, 30, 5, 18, 3]

pares = [n for n in numeros if n % 2 == 0]
grandes = [n for n in numeros if n > 10]

print(pares)
print(grandes)

nomes = ["ana", "Bruno", "carlos"]
print([n.title() for n in nomes if n[0].islower()])

notas = [9.0, 5.5, 7.0, 4.0]

situacao = ["aprovado" if n >= 7 else "reprovado" for n in notas]
print(situacao)

ajustadas = [min(n + 1, 10) if n < 7 else n for n in notas]
print(ajustadas)

matriz = [[1, 2, 3], [4, 5, 6]]

plana = [valor for linha in matriz for valor in linha]
print(plana)

tabela = [[i * j for j in range(1, 5)] for i in range(1, 4)]
for linha in tabela:
    print(linha)

alunos = ["Ana", "Bruno", "Carlos"]
notas = [9.5, 7.0, 8.2]

boletim = {a: n for a, n in zip(alunos, notas)}
print(boletim)

aprovados = {a: n for a, n in boletim.items() if n >= 8}
print(aprovados)

print({a: round(n) for a, n in boletim.items()})

texto = "engenharia de telecomunicacoes"

letras = {c for c in texto if c.isalpha()}
print(sorted(letras))

tamanhos = {len(p) for p in texto.split()}
print(tamanhos)

numeros = range(1, 1_000_001)

soma = sum(n for n in numeros if n % 3 == 0)
print("soma dos múltiplos de 3:", soma)

print("algum acima de 999999?", any(n > 999_999 for n in numeros))
print("todos positivos?", all(n > 0 for n in numeros))

dados = ["12", "abc", "7", "", "30"]

# Difícil de ler em uma linha só:
# validos = [int(d) for d in dados if d.isdigit() and int(d) > 10]

# Preferível quando há mais de uma regra:
validos = []
for d in dados:
    if not d.isdigit():
        continue
    numero = int(d)
    if numero > 10:
        validos.append(numero)

print(validos)

simples = 'aspas simples'
duplas = "aspas duplas"
mistura = "Ele disse: 'tudo certo'"

bloco = """Primeira linha
Segunda linha"""

vazia = ""
print(simples, "|", duplas, "|", mistura)
print(bloco)
print("string vazia é falsa?", not vazia)

palavra = "Python"

print(palavra[0], palavra[1], palavra[-1], palavra[-2])
print("tamanho:", len(palavra))

for i, letra in enumerate(palavra):
    print(f"{i:>2} {letra}")

frase = "Python é uma linguagem clara"

print(frase[:6])
print(frase[-5:])
print(frase[7:15])
print(frase[::2])
print(frase[::-1])

nome = "python"

try:
    nome[0] = "P"
except TypeError as erro:
    print("Erro:", erro)

# A saida e sempre uma string nova
maiuscula = nome.capitalize()
print(nome, "->", maiuscula)

texto = "  Python É uma Linguagem incrível  "

print(f"[{texto.strip()}]")
print(f"[{texto.lstrip()}]  [{texto.rstrip()}]")
print(texto.strip().upper())
print(texto.strip().lower())
print(texto.strip().title())
print(texto.strip().capitalize())
print("-".join(texto.split()))

amostras = ["12345", "Python", "Python3", "  ", "TITULO"]

for a in amostras:
    print(f"{repr(a):>10} "
          f"digito={a.isdigit():<2} "
          f"alpha={a.isalpha():<2} "
          f"alnum={a.isalnum():<2} "
          f"espaco={a.isspace():<2} "
          f"maiusc={a.isupper()}")

frase = "Python é rápido e Python é claro"

print("in:", "rápido" in frase)
print("find:", frase.find("Python"))     # primeira ocorrencia
print("rfind:", frase.rfind("Python"))   # ultima
print("find ausente:", frase.find("Java"))  # -1
print("count:", frase.count("Python"))
print("startswith:", frase.startswith("Python"))
print("endswith:", frase.endswith("claro"))

texto = "Eu gosto de Java, Java é interessante"

print(texto.replace("Java", "Python"))
print(texto.replace("Java", "Python", 1))   # so a primeira

telefone = "(48) 99999-1234"
limpo = (telefone.replace("(", "").replace(")", "")
                  .replace(" ", "").replace("-", ""))
print("só dígitos:", limpo)

linha = "Python,Java,C,Rust"
linguagens = linha.split(",")
print(linguagens)

texto = "palavra1   palavra2\tpalavra3"
print(texto.split())          # qualquer espaco em branco

print("1-2-3-4".split("-", 2))  # no maximo 2 divisoes

frutas = ["maçã", "banana", "uva"]
print(", ".join(frutas))
print(" | ".join(frutas))

quebra = "\n"
print(quebra.join(frutas))

produtos = [("Cabo HDMI", 39.9), ("Roteador", 289.0),
            ("Antena", 129.5)]

print(f"{'PRODUTO':<14}{'PREÇO':>10}")
print("-" * 24)
for nome, preco in produtos:
    print(f"{nome:<14}{preco:>10.2f}")

print("-" * 24)
print(f"{'TOTAL':<14}{sum(p for _, p in produtos):>10.2f}")

titulo = "RELATÓRIO"

print(titulo.center(30, "="))
print(titulo.ljust(20, ".") + "ok")
print(titulo.rjust(30))
print(f"{titulo:*^30}")
print(f"{42:0>5}")

print("Linha 1\nLinha 2")
print("Coluna1\tColuna2")
print("Aspas: \"Python\"")
print("Barra: C:\\Users\\Documentos")

caminho = r"C:\Users\Documentos\dados.txt"
print(caminho)

padrao = r"\d+\.\d+"     # util em expressoes regulares
print(padrao)

email = "ramon.mayor@ifsc.edu.br"

usuario, dominio = email.split("@")
print("usuário:", usuario)
print("domínio:", dominio)
print("extensão:", dominio[dominio.rfind("."):])
print("nome formatado:", usuario.replace(".", " ").title())

def validar_email(email):
    """Validação simples: devolve (valido, mensagem)."""
    email = email.strip().lower()

    if not email:
        return False, "não pode estar vazio"
    if email.count("@") != 1:
        return False, "precisa de exatamente um @"

    usuario, dominio = email.split("@")
    if not usuario or not dominio:
        return False, "usuário e domínio são obrigatórios"
    if "." not in dominio:
        return False, "domínio precisa de um ponto"

    return True, "válido"

testes = ["ramon@ifsc.edu.br", "@ifsc.edu.br", "sem-arroba.com",
          "  ALUNO@IFSC.EDU.BR  "]

for t in testes:
    ok, msg = validar_email(t)
    marca = "ok " if ok else "erro"
    print(f"[{marca}] {t.strip():<24} {msg}")

texto = """Python é uma linguagem de programação.
É fácil de aprender e muito poderosa.
Versão usada: 3.12"""

palavras = texto.split()
vogais = sum(1 for c in texto.lower() if c in "aeiou")
digitos = sum(1 for c in texto if c.isdigit())

print("caracteres:", len(texto))
print("palavras:", len(palavras))
print("linhas:", len(texto.splitlines()))
print("vogais:", vogais)
print("dígitos:", digitos)
print("maior palavra:", max(palavras, key=len))

def cabecalho():
    """Imprime o cabeçalho padrão do relatório."""
    print("=" * 34)
    print("IFSC - Manual de Experimentos")
    print("=" * 34)

cabecalho()
print("conteúdo do relatório")

def saudacao(nome, curso):
    print(f"Olá, {nome}! Bem-vindo ao curso de {curso}.")

saudacao("Maria", "Telecomunicações")
saudacao("João", "Redes")
saudacao(curso="Python", nome="Ana")   # argumentos nomeados

def area_retangulo(base, altura):
    return base * altura

def celsius_para_fahrenheit(c):
    return c * 9 / 5 + 32

print(area_retangulo(3, 4))
print(f"{celsius_para_fahrenheit(25):.1f} °F")
print("soma de áreas:", area_retangulo(2, 2) + area_retangulo(3, 3))

def estatisticas(valores):
    return min(valores), max(valores), sum(valores) / len(valores)

menor, maior, media = estatisticas([7.5, 9.0, 5.5, 8.0])
print(f"menor {menor} | maior {maior} | média {media:.2f}")

tudo = estatisticas([1, 2, 3])
print(tudo, type(tudo))

def classificar(idade):
    if idade < 0:
        return "idade inválida"
    if idade < 13:
        return "criança"
    if idade < 18:
        return "adolescente"
    if idade < 60:
        return "adulto"
    return "idoso"

for i in [-1, 5, 15, 30, 70]:
    print(f"{i:>3} -> {classificar(i)}")

def criar_perfil(nome, curso="não informado", ativo=True):
    status = "ativo" if ativo else "inativo"
    print(f"{nome:<8} | {curso:<16} | {status}")

criar_perfil("Maria", "Telecomunicações")
criar_perfil("João")
criar_perfil("Ana", ativo=False)

def somar(*numeros):
    print(f"recebi {numeros} ->", sum(numeros))
    return sum(numeros)

somar(1, 2, 3)
somar(10, 20, 30, 40)
somar()

valores = [5, 10, 15]
somar(*valores)      # o asterisco desempacota a lista

def relatorio(**dados):
    if not dados:
        print("nenhum dado recebido")
        return
    for chave, valor in dados.items():
        print(f"{chave.replace('_', ' ').title():<12}: {valor}")
    print("-" * 26)

relatorio(nome="Pedro", cargo="Técnico", setor="Redes")
relatorio()

equipamento = {"modelo": "RTL-SDR", "faixa_mhz": "24 a 1766"}
relatorio(**equipamento)

def registrar(evento, nivel="info", *tags, **extras):
    print(f"[{nivel.upper()}] {evento}")
    if tags:
        print("  tags:", ", ".join(tags))
    if extras:
        print("  extras:", extras)

registrar("sistema iniciado")
registrar("falha na antena", "erro", "rf", "campo", codigo=42)

contador = 0          # global

def mostrar():
    interno = 10      # local
    print("dentro:", interno, contador)

mostrar()
print("fora:", contador)

try:
    print(interno)
except NameError as erro:
    print("Erro:", erro)

total = 0

def somar_errado(valor):
    total = valor          # cria uma variavel local nova
    return total

def somar_certo(valor):
    global total
    total += valor

somar_errado(10)
print("depois do errado:", total)
somar_certo(10)
somar_certo(5)
print("depois do certo:", total)

def contador():
    n = 0
    def incrementar():
        nonlocal n
        n += 1
        return n
    return incrementar

c = contador()
print(c(), c(), c())

def adicionar_errado(item, lista=[]):
    lista.append(item)
    return lista

print(adicionar_errado("a"))
print(adicionar_errado("b"))   # a lista lembrou do "a"!

def adicionar_certo(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)
    return lista

print(adicionar_certo("a"))
print(adicionar_certo("b"))

quadrado = lambda x: x ** 2
print(quadrado(5))

alunos = [("Ana", 9.5), ("Bruno", 7.0), ("Carlos", 8.2)]

print(sorted(alunos, key=lambda par: par[1]))
print(sorted(alunos, key=lambda par: par[1], reverse=True))
print(max(alunos, key=lambda par: par[1]))

numeros = [1, 2, 3, 4, 5, 6]

print(list(map(lambda x: x ** 2, numeros)))
print(list(filter(lambda x: x % 2 == 0, numeros)))

# Mesma coisa, mais legivel para a maioria das pessoas:
print([x ** 2 for x in numeros])
print([x for x in numeros if x % 2 == 0])

def aplicar(funcao, valores):
    return [funcao(v) for v in valores]

def dobro(x):
    return x * 2

print(aplicar(dobro, [1, 2, 3]))
print(aplicar(str.upper, ["a", "b"]))
print(aplicar(len, ["python", "ifsc"]))

def fatorial(n):
    if n <= 1:          # caso base
        return 1
    return n * fatorial(n - 1)

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print([fatorial(i) for i in range(7)])
print([fibonacci(i) for i in range(10)])

def calcular_imc(peso: float, altura: float) -> dict:
    """Calcula o IMC e devolve o valor com a classificação.

    Args:
        peso: massa em quilogramas.
        altura: altura em metros.

    Returns:
        Dicionário com as chaves 'imc' e 'classificacao'.

    Raises:
        ValueError: se peso ou altura não forem positivos.
    """
    if peso <= 0 or altura <= 0:
        raise ValueError("peso e altura devem ser positivos")

    imc = peso / altura ** 2
    if imc < 18.5:
        faixa = "abaixo do peso"
    elif imc < 25:
        faixa = "peso normal"
    elif imc < 30:
        faixa = "sobrepeso"
    else:
        faixa = "obesidade"

    return {"imc": round(imc, 2), "classificacao": faixa}

print(calcular_imc(70, 1.75))
print(calcular_imc.__doc__.splitlines()[0])

import time

def cronometrar(funcao):
    """Mede o tempo de execução da função decorada."""
    def interna(*args, **kwargs):
        inicio = time.perf_counter()
        resultado = funcao(*args, **kwargs)
        gasto = time.perf_counter() - inicio
        print(f"{funcao.__name__} levou {gasto:.4f} s")
        return resultado
    return interna

@cronometrar
def somar_ate(n):
    return sum(range(n))

print(somar_ate(1_000_000))

import math

print(math.pi)
print(math.sqrt(144))
print(math.floor(3.7), math.ceil(3.2))
print(math.log10(1000))

from math import pi, sqrt, radians, sin

print(pi)
print(sqrt(81))
print(round(sin(radians(30)), 4))

# Evite: importa tudo e polui o espaco de nomes
# from math import *

import statistics as stat
from datetime import datetime as dt

amostras = [12.5, 13.0, 11.8, 12.9]
print("média:", stat.mean(amostras))
print("mediana:", stat.median(amostras))
print("ano atual:", dt(2026, 7, 22).year)

# Aqui o modulo e gravado em disco e depois importado.
codigo = """
def celsius_para_fahrenheit(c):
    return c * 9 / 5 + 32

def watts_para_dbm(p):
    import math
    return 10 * math.log10(p * 1000)
"""

with open("conversoes.py", "w", encoding="utf-8") as arquivo:
    arquivo.write(codigo)

import conversoes

print(conversoes.celsius_para_fahrenheit(25))
print(conversoes.watts_para_dbm(0.001), "dBm")   # 1 mW
print(round(conversoes.watts_para_dbm(0.1), 2), "dBm")

def principal():
    print("executando o programa")

print("valor de __name__:", __name__)

if __name__ == "__main__":
    principal()

meu_projeto/
|-- main.py            # ponto de entrada
|-- requisitos.txt     # dependencias
|-- dados/
|   `-- medidas.csv
`-- pacote/
    |-- __init__.py    # marca a pasta como pacote
    |-- conversoes.py
    `-- relatorio.py

# Criar e ativar um ambiente isolado do sistema
python3 -m venv .venv
source .venv/bin/activate        # Linux e macOS
.venv\Scripts\activate           # Windows

# Instalar, listar e registrar dependencias
pip install requests matplotlib
pip list
pip freeze > requisitos.txt

# Reproduzir o ambiente em outra maquina
pip install -r requisitos.txt

class Aluno:
    """Representa um aluno da turma."""

    def __init__(self, nome, curso):
        self.nome = nome        # atributo de instancia
        self.curso = curso
        self.notas = []

ana = Aluno("Ana", "Telecomunicações")
bruno = Aluno("Bruno", "Redes")

print(ana.nome, "|", ana.curso, "|", ana.notas)
print(bruno.nome, "|", bruno.curso)

class Aluno:
    def __init__(self, nome):
        self.nome = nome
        self.notas = []

    def adicionar_nota(self, nota):
        if 0 <= nota <= 10:
            self.notas.append(nota)
        else:
            print("nota fora da faixa")

    def media(self):
        if not self.notas:
            return 0.0
        return sum(self.notas) / len(self.notas)

    def aprovado(self):
        return self.media() >= 7

ana = Aluno("Ana")
ana.adicionar_nota(8.5)
ana.adicionar_nota(9.0)
ana.adicionar_nota(15)

print(ana.notas, f"média {ana.media():.2f}", ana.aprovado())

class Ponto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Ponto(x={self.x}, y={self.y})"

p = Ponto(3, 4)
print(p)            # usa __str__
print(repr(p))      # usa __repr__
print([p, p])       # listas usam __repr__

class Turma:
    instituicao = "IFSC"      # compartilhado por todos
    total = 0

    def __init__(self, codigo):
        self.codigo = codigo   # exclusivo de cada objeto
        Turma.total += 1

a = Turma("TEL-2026-1")
b = Turma("RED-2026-1")

print(a.codigo, b.codigo)
print(a.instituicao, b.instituicao)
print("turmas criadas:", Turma.total)

class Conta:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self._saldo = saldo        # convencao: uso interno

    @property
    def saldo(self):
        return self._saldo

    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("valor deve ser positivo")
        self._saldo += valor

    def sacar(self, valor):
        if valor > self._saldo:
            return False
        self._saldo -= valor
        return True

c = Conta("Ana", 100)
c.depositar(50)
print("saque de 500 deu certo?", c.sacar(500))
print("saldo:", c.saldo)

try:
    c.saldo = 1_000_000       # bloqueado: property sem setter
except AttributeError as erro:
    print("Erro:", erro)

class Equipamento:
    def __init__(self, modelo):
        self.modelo = modelo
        self.ligado = False

    def ligar(self):
        self.ligado = True
        return f"{self.modelo} ligado"

    def descrever(self):
        return f"Equipamento {self.modelo}"

class Radio(Equipamento):
    def __init__(self, modelo, frequencia):
        super().__init__(modelo)      # reaproveita o __init__
        self.frequencia = frequencia

    def descrever(self):              # sobrescreve
        return f"Rádio {self.modelo} em {self.frequencia} MHz"

r = Radio("RTL-SDR", 145.8)
print(r.ligar())
print(r.descrever())
print("é um Equipamento?", isinstance(r, Equipamento))

class Antena:
    def ganho(self):
        return 0.0

class Dipolo(Antena):
    def ganho(self):
        return 2.15

class Yagi(Antena):
    def __init__(self, elementos):
        self.elementos = elementos

    def ganho(self):
        return 2.15 + 2.5 * (self.elementos - 1)

for antena in [Antena(), Dipolo(), Yagi(4)]:
    nome = type(antena).__name__
    print(f"{nome:<8} ganho {antena.ganho():>5.2f} dBi")

from dataclasses import dataclass, field

@dataclass
class Medida:
    sensor: str
    valor: float
    unidade: str = "dBm"
    tags: list = field(default_factory=list)

m1 = Medida("ant-01", -73.5)
m2 = Medida("ant-01", -73.5)

print(m1)
print("iguais?", m1 == m2)      # __eq__ vem de graca
m1.tags.append("teste")
print(m1.tags, m2.tags)

class Aluno:
    def __init__(self, nome):
        self.nome = nome
        self.notas = []

    def media(self):
        return sum(self.notas) / len(self.notas) if self.notas else 0

class Turma:
    def __init__(self, codigo):
        self.codigo = codigo
        self.alunos = []

    def matricular(self, aluno):
        self.alunos.append(aluno)

    def relatorio(self):
        print(f"Turma {self.codigo}")
        print(f"{'ALUNO':<10}{'MÉDIA':>7}  SITUAÇÃO")
        for a in sorted(self.alunos, key=lambda x: -x.media()):
            situacao = "aprovado" if a.media() >= 7 else "exame"
            print(f"{a.nome:<10}{a.media():>7.2f}  {situacao}")

turma = Turma("TEL-2026-1")
for nome, notas in [("Ana", [8.5, 9.0]), ("Bruno", [6.0, 6.5]),
                    ("Carlos", [7.5, 8.0])]:
    aluno = Aluno(nome)
    aluno.notas = notas
    turma.matricular(aluno)

turma.relatorio()

with open("exemplo.txt", "w", encoding="utf-8") as arquivo:
    arquivo.write("Primeira linha\n")
    arquivo.write("Segunda linha\n")
    arquivo.writelines(["terceira\n", "quarta\n"])

print("arquivo gravado")

with open("dados.txt", "w", encoding="utf-8") as f:
    f.write("linha 1\nlinha 2\nacentuação: ção, ã, ê\n")

with open("dados.txt", "r", encoding="utf-8") as f:
    conteudo = f.read()

print(conteudo)
print("caracteres lidos:", len(conteudo))

with open("dados.txt", "w", encoding="utf-8") as f:
    f.write("alfa\nbeta\ngama\n")

with open("dados.txt", "r", encoding="utf-8") as f:
    for numero, linha in enumerate(f, 1):
        print(f"{numero}: {linha.strip()}")

with open("dados.txt", "r", encoding="utf-8") as f:
    linhas = f.readlines()
print(linhas)

with open("registro.log", "w", encoding="utf-8") as f:
    f.write("início da sessão\n")

for evento in ["antena conectada", "sinal capturado"]:
    with open("registro.log", "a", encoding="utf-8") as f:
        f.write(evento + "\n")

with open("registro.log", encoding="utf-8") as f:
    print(f.read())

# Forma frágil: se ocorrer um erro antes do close, o arquivo fica aberto
arquivo = open("teste.txt", "w", encoding="utf-8")
arquivo.write("dado")
arquivo.close()
print("fechado manualmente?", arquivo.closed)

# Forma correta: o with fecha ate se houver excecao
with open("teste.txt", "a", encoding="utf-8") as arquivo:
    arquivo.write(" e mais dado")
print("fechado pelo with?", arquivo.closed)

from pathlib import Path

pasta = Path("medidas")
pasta.mkdir(exist_ok=True)

arquivo = pasta / "sessao01.txt"      # a barra monta o caminho
arquivo.write_text("-73.5 dBm\n-71.2 dBm\n", encoding="utf-8")

print("existe?", arquivo.exists())
print("nome:", arquivo.name, "| extensão:", arquivo.suffix)
print("tamanho:", arquivo.stat().st_size, "bytes")
print("conteúdo:", arquivo.read_text(encoding="utf-8").split())
print("arquivos na pasta:", [p.name for p in pasta.iterdir()])

import csv

linhas = [
    ["sensor", "valor_dbm", "data"],
    ["ant-01", -73.5, "2026-07-22"],
    ["ant-02", -68.1, "2026-07-22"],
]

with open("medidas.csv", "w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows(linhas)

with open("medidas.csv", encoding="utf-8") as f:
    for registro in csv.DictReader(f):
        print(f"{registro['sensor']}: {registro['valor_dbm']} dBm")

import json

config = {
    "estacao": "IFSC-389",
    "frequencias": [145.8, 437.5],
    "ativa": True,
    "operador": {"nome": "Ramon", "indicativo": "PU4MAY"},
}

with open("config.json", "w", encoding="utf-8") as f:
    json.dump(config, f, indent=2, ensure_ascii=False)

with open("config.json", encoding="utf-8") as f:
    lido = json.load(f)

print(lido["operador"]["indicativo"])
print(lido["frequencias"][0])
print(json.dumps(lido, ensure_ascii=False)[:60], "...")

import json
from pathlib import Path

ARQUIVO = Path("tarefas.json")

def carregar():
    if not ARQUIVO.exists():
        return []
    return json.loads(ARQUIVO.read_text(encoding="utf-8"))

def salvar(tarefas):
    ARQUIVO.write_text(
        json.dumps(tarefas, indent=2, ensure_ascii=False),
        encoding="utf-8")

tarefas = carregar()
tarefas.append({"texto": "revisar o manual", "feita": False})
tarefas.append({"texto": "testar a antena", "feita": True})
salvar(tarefas)

for i, t in enumerate(carregar(), 1):
    marca = "x" if t["feita"] else " "
    print(f"[{marca}] {i}. {t['texto']}")

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("não é possível dividir por zero")
    resultado = None

print("resultado:", resultado)
print("o programa continuou")

def dividir(texto_a, texto_b):
    try:
        return float(texto_a) / float(texto_b)
    except ZeroDivisionError:
        return "divisor igual a zero"
    except ValueError:
        return "entrada não numérica"

print(dividir("10", "4"))
print(dividir("10", "0"))
print(dividir("dez", "2"))

entradas = ["12", "abc", None]

for valor in entradas:
    try:
        print("dobro:", int(valor) * 2)
    except (ValueError, TypeError) as erro:
        print(f"falhou com {valor!r}: {type(erro).__name__}: {erro}")

def ler_config(nome):
    try:
        arquivo = open(nome, encoding="utf-8")
    except FileNotFoundError:
        print("arquivo não encontrado, usando padrões")
        return {}
    else:
        print("arquivo aberto com sucesso")
        conteudo = arquivo.read()
        return {"linhas": len(conteudo.splitlines())}
    finally:
        print("fim da tentativa de leitura")

with open("config.txt", "w", encoding="utf-8") as f:
    f.write("a=1\nb=2\n")

print(ler_config("config.txt"))
print(ler_config("inexistente.txt"))

def calcular_media(notas):
    if not notas:
        raise ValueError("a lista de notas está vazia")
    return sum(notas) / len(notas)

print(calcular_media([8, 9, 10]))

try:
    calcular_media([])
except ValueError as erro:
    print("Erro tratado:", erro)

class IdadeInvalida(Exception):
    """Erro de domínio: idade fora da faixa aceitável."""

    def __init__(self, idade, mensagem="idade inválida"):
        self.idade = idade
        super().__init__(f"{mensagem} ({idade})")

def validar(idade):
    if not isinstance(idade, int):
        raise TypeError("idade deve ser um inteiro")
    if idade < 0:
        raise IdadeInvalida(idade, "não pode ser negativa")
    if idade > 150:
        raise IdadeInvalida(idade, "acima do limite")
    return True

for candidato in [25, -5, 200, "trinta"]:
    try:
        validar(candidato)
        print(f"{candidato!r}: ok")
    except IdadeInvalida as erro:
        print(f"{candidato!r}: {erro}")
    except TypeError as erro:
        print(f"{candidato!r}: {erro}")

def ler_texto(nome):
    try:
        with open(nome, encoding="utf-8") as arquivo:
            conteudo = arquivo.read()
    except FileNotFoundError:
        print(f"'{nome}' não existe")
    except PermissionError:
        print(f"sem permissão para ler '{nome}'")
    except UnicodeDecodeError:
        print(f"'{nome}' não está em UTF-8")
    else:
        if not conteudo.strip():
            print(f"'{nome}' está vazio")
        return conteudo
    return None

with open("ok.txt", "w", encoding="utf-8") as f:
    f.write("conteúdo válido")

print(repr(ler_texto("ok.txt")))
print(repr(ler_texto("faltando.txt")))

Traceback (most recent call last):
  File "relatorio.py", line 18, in <module>
    main()
  File "relatorio.py", line 12, in main
    media = calcular(notas)
  File "relatorio.py", line 6, in calcular
    return sum(notas) / len(notas)
           ~~~~~~~~~~~^~~~~~~~~~~~
ZeroDivisionError: division by zero

import math

print(math.pi, math.e)
print(math.sqrt(2), math.hypot(3, 4))
print(math.floor(3.7), math.ceil(3.2), math.trunc(-3.7))
print(math.log10(1000), math.log2(1024))
print(math.degrees(math.pi), math.sin(math.radians(90)))
print(math.factorial(5), math.gcd(24, 36))

import random

random.seed(42)          # torna o resultado reproduzivel

print(random.random())
print(random.randint(1, 6))
print(random.uniform(1.5, 2.5))
print(random.choice(["ouro", "prata", "bronze"]))
print(random.sample(range(1, 61), 6))

cartas = ["A", "2", "3", "4"]
random.shuffle(cartas)
print(cartas)

from datetime import datetime, date, timedelta

hoje = date(2026, 7, 22)
agora = datetime(2026, 7, 22, 14, 30)

print(hoje.strftime("%d/%m/%Y"))
print(agora.strftime("%d/%m/%Y às %H:%M"))
print("dia da semana:", hoje.weekday())   # 0 = segunda

prazo = hoje + timedelta(days=30)
print("prazo:", prazo, "| faltam", (prazo - hoje).days, "dias")

lida = datetime.strptime("01/03/2026", "%d/%m/%Y")
print("convertida:", lida.date())

import statistics as stat

amostras = [12.5, 13.0, 11.8, 12.9, 12.1, 13.4]

print("média:", round(stat.mean(amostras), 3))
print("mediana:", stat.median(amostras))
print("desvio padrão:", round(stat.stdev(amostras), 4))
print("variância:", round(stat.variance(amostras), 4))
print("moda:", stat.mode([1, 2, 2, 3]))

from collections import Counter, defaultdict, namedtuple

texto = "engenharia de telecomunicacoes"
contagem = Counter(c for c in texto if c.isalpha())
print(contagem.most_common(4))

grupos = defaultdict(list)
for nome in ["Ana", "Bruno", "Alice", "Carlos"]:
    grupos[nome[0]].append(nome)
print(dict(grupos))

Medida = namedtuple("Medida", "sensor valor")
m = Medida("ant-01", -73.5)
print(m, m.sensor, m.valor)

from itertools import combinations, permutations, product, count

print(list(combinations("ABC", 2)))
print(list(permutations("ABC", 2)))
print(list(product([0, 1], repeat=2)))

contador = count(start=10, step=5)
print([next(contador) for _ in range(4)])

import re

texto = "Contatos: ramon@ifsc.edu.br, suporte@ifsc.edu.br, (48) 3381-2800"

emails = re.findall(r"[\w.]+@[\w.]+", texto)
print(emails)

telefone = re.search(r"\(\d{2}\)\s?\d{4}-\d{4}", texto)
print(telefone.group() if telefone else "não encontrado")

print(re.sub(r"\d", "#", "senha 12345"))
print(bool(re.fullmatch(r"\d{3}\.\d{3}\.\d{3}-\d{2}",
                        "123.456.789-00")))

import os
import sys
import time

print("versão:", sys.version.split()[0])
print("plataforma:", sys.platform)
print("pasta atual:", os.path.basename(os.getcwd()))
print("variável de ambiente HOME existe?", "HOME" in os.environ)

inicio = time.perf_counter()
soma = sum(range(200_000))
print(f"tempo: {time.perf_counter() - inicio:.4f} s")

# Antes
def Calc(L):
   T=0
   for I in range( len(L) ):T=T+L[I]
   return T/len(L)

# Depois
def calcular_media(valores):
    """Retorna a média aritmética de uma sequência numérica."""
    if not valores:
        return 0.0
    return sum(valores) / len(valores)

print(Calc([7, 8, 9]), calcular_media([7, 8, 9]))

def media(valores: list[float]) -> float:
    return sum(valores) / len(valores) if valores else 0.0

def formatar(nome: str, nota: float, aprovado: bool = False) -> str:
    marca = "aprovado" if aprovado else "em avaliação"
    return f"{nome}: {nota:.1f} ({marca})"

print(media([8.0, 9.0]))
print(formatar("Ana", 8.5, True))
print(media.__annotations__)

def desconto(preco, percentual):
    assert 0 <= percentual <= 100, "percentual fora da faixa"
    return preco * (1 - percentual / 100)

print(desconto(100, 15))

try:
    desconto(100, 150)
except AssertionError as erro:
    print("AssertionError:", erro)

import unittest

def media(valores):
    return sum(valores) / len(valores) if valores else 0.0

class TesteMedia(unittest.TestCase):
    def test_lista_normal(self):
        self.assertAlmostEqual(media([8, 9, 10]), 9.0)

    def test_lista_vazia(self):
        self.assertEqual(media([]), 0.0)

    def test_um_elemento(self):
        self.assertEqual(media([7]), 7)

unittest.main(argv=["prog"], exit=False, verbosity=2)

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(levelname)s | %(message)s")

logging.debug("detalhe que só interessa ao desenvolvedor")
logging.info("processando 3 arquivos")
logging.warning("valor de RSSI acima do esperado")
logging.error("falha ao abrir a porta serial")

import random

PALAVRAS = ["python", "antena", "modulacao", "protocolo"]

def mascarar(palavra, achadas):
    return " ".join(c if c in achadas else "_" for c in palavra)

def jogar(tentativas=6):
    random.seed(2)                    # remova para sortear de fato
    palavra = random.choice(PALAVRAS).upper()
    achadas = set()

    while tentativas > 0:
        print(f"\n{mascarar(palavra, achadas)}   "
              f"({tentativas} tentativas)")

        if all(c in achadas for c in palavra):
            return f"Acertou: {palavra}"

        letra = input("letra: ").upper().strip()
        if len(letra) != 1 or not letra.isalpha():
            print("digite uma única letra")
            continue
        if letra in achadas:
            print("letra já usada")
            continue

        achadas.add(letra)
        if letra in palavra:
            print("existe na palavra")
        else:
            tentativas -= 1
            print("não existe")

    return f"Acabaram as tentativas. Era {palavra}"

print(jogar())

import json
from pathlib import Path

ARQUIVO = Path("boletim.json")

def media(notas):
    return sum(notas) / len(notas) if notas else 0.0

def salvar(turma):
    ARQUIVO.write_text(json.dumps(turma, ensure_ascii=False,
                                  indent=2), encoding="utf-8")

def carregar():
    if ARQUIVO.exists():
        return json.loads(ARQUIVO.read_text(encoding="utf-8"))
    return {}

def relatorio(turma):
    print(f"{'ALUNO':<10}{'MÉDIA':>7}  SITUAÇÃO")
    print("-" * 30)
    for nome, notas in sorted(turma.items(),
                              key=lambda p: -media(p[1])):
        m = media(notas)
        print(f"{nome:<10}{m:>7.2f}  "
              f"{'aprovado' if m >= 7 else 'exame'}")
    medias = [media(n) for n in turma.values()]
    print("-" * 30)
    print(f"{'TURMA':<10}{sum(medias) / len(medias):>7.2f}")

turma = carregar()
turma.update({"Ana": [8.5, 9.0], "Bruno": [6.0, 6.5],
              "Carlos": [7.5, 8.0]})
salvar(turma)
relatorio(carregar())

from collections import Counter

LINHAS = """2026-07-22 10:01 INFO  estação iniciada
2026-07-22 10:03 WARNING sinal fraco em 145.8
2026-07-22 10:04 ERROR falha na porta serial
2026-07-22 10:07 INFO  pacote recebido
2026-07-22 10:09 ERROR falha na porta serial"""

with open("estacao.log", "w", encoding="utf-8") as f:
    f.write(LINHAS)

niveis = Counter()
mensagens_erro = []

with open("estacao.log", encoding="utf-8") as f:
    for linha in f:
        partes = linha.split(maxsplit=3)
        if len(partes) < 4:
            continue
        _, hora, nivel, mensagem = partes
        niveis[nivel] += 1
        if nivel == "ERROR":
            mensagens_erro.append((hora, mensagem.strip()))

print("ocorrências por nível:", dict(niveis))
print("erros registrados:")
for hora, msg in mensagens_erro:
    print(f"  {hora}  {msg}")
print("mensagem de erro mais comum:",
      Counter(m for _, m in mensagens_erro).most_common(1))

import json
from pathlib import Path

ARQUIVO = Path("agenda.json")

def carregar():
    if ARQUIVO.exists():
        return json.loads(ARQUIVO.read_text(encoding="utf-8"))
    return {}

def salvar(agenda):
    ARQUIVO.write_text(json.dumps(agenda, ensure_ascii=False,
                                  indent=2), encoding="utf-8")

def menu():
    agenda = carregar()
    while True:
        print("\n1 incluir | 2 listar | 3 remover | 0 sair")
        opcao = input("opção: ").strip()

        if opcao == "1":
            nome = input("nome: ").strip()
            agenda[nome] = input("telefone: ").strip()
            salvar(agenda)
            print("contato salvo")
        elif opcao == "2":
            if not agenda:
                print("agenda vazia")
            for nome, fone in sorted(agenda.items()):
                print(f"  {nome:<10} {fone}")
        elif opcao == "3":
            removido = agenda.pop(input("nome: ").strip(), None)
            salvar(agenda)
            print("removido" if removido else "não encontrado")
        elif opcao == "0":
            print("até logo")
            break
        else:
            print("opção inválida")

menu()

# ---- entrada e saida -------------------------------------------
nome = input("Nome: ")
idade = int(input("Idade: "))
print(f"{nome} tem {idade} anos e média {7.5:.2f}")

# ---- decisao ---------------------------------------------------
if nota >= 7:      pass
elif nota >= 5:    pass
else:              pass
conceito = "A" if nota >= 9 else "B"

# ---- repeticao -------------------------------------------------
for i in range(1, 11): pass
for i, item in enumerate(lista, start=1): pass
for a, b in zip(lista_a, lista_b): pass
while condicao: pass          # break / continue / else

# ---- colecoes --------------------------------------------------
lista = [1, 2, 3];            lista.append(4)
tupla = (1, 2, 3)
dicio = {"chave": "valor"};   dicio.get("chave", "padrao")
conj  = {1, 2, 3};            conj.add(4)
pares = [x ** 2 for x in lista if x % 2 == 0]

# ---- funcoes ---------------------------------------------------
def calcular(a, b=1, *args, **kwargs) -> float:
    """Docstring."""
    return a + b

# ---- classes ---------------------------------------------------
class Aluno:
    def __init__(self, nome):
        self.nome = nome
    def __str__(self):
        return self.nome

# ---- arquivos --------------------------------------------------
with open("dados.txt", "w", encoding="utf-8") as f:
    f.write("linha\n")

# ---- excecoes --------------------------------------------------
try:      pass
except ValueError as erro: print(erro)
else:     pass
finally:  pass

# ---- ponto de entrada ------------------------------------------
if __name__ == "__main__":
    main()