Revisão para a 2ª VA

# hierarquia: IndexError é filha de LookupError (aula 14)
try:
    lista = [1, 2, 3]
    print(lista[10])
except LookupError as erro:          # LookupError pega IndexError e KeyError
    print(f"Capturado por LookupError: {type(erro).__name__}")
# Capturado por LookupError: IndexError

# exceção customizada carrega dados do erro (aula 14)
class SaldoInsuficienteError(Exception):
    def __init__(self, saldo, valor):
        self.falta = valor - saldo
        super().__init__(f"Faltam R$ {self.falta:.2f}")   # texto vai pro print(erro)

try:
    raise SaldoInsuficienteError(saldo=100, valor=150)
except SaldoInsuficienteError as erro:
    print(erro)              # Faltam R$ 50.00
    print(erro.falta)        # 50

# with abre e fecha sozinho (aula 17) — é o finally da aula 14 automático
with open("pedidos.txt", "w", encoding="utf-8") as f:   # "w" cria e APAGA tudo
    f.write("Ana;Calabresa;39.90\n")                     # write não pula linha sozinho

with open("pedidos.txt", "a", encoding="utf-8") as f:   # "a" anexa e preserva
    f.write("Bruno;Portuguesa;42.00\n")

# as 4 formas de LER (aula 17) — read() traz o arquivo TODO numa string só:
with open("pedidos.txt", "r", encoding="utf-8") as f:
    print(repr(f.readline()))     # 'Ana;Calabresa;39.90\n'  (UMA linha, COM o \n)

with open("pedidos.txt", "r", encoding="utf-8") as f:
    print(f.readlines())          # ['Ana;Calabresa;39.90\n', 'Bruno;Portuguesa;42.00\n']  (lista com todas)

with open("pedidos.txt", "r", encoding="utf-8") as f:   # "r" lê (padrão) — a forma pythônica:
    for linha in f:
        print(linha.strip())      # .strip() tira o \n
# Ana;Calabresa;39.90
# Bruno;Portuguesa;42.00

# list comprehension: TRANSFORMAR e FILTRAR (aula 18)
class Pet:
    def __init__(self, nome, especie):
        self.nome = nome
        self.especie = especie

pets = [Pet("Rex", "Cão"), Pet("Mimi", "Gato"), Pet("Bob", "Cão")]

nomes = [pet.nome for pet in pets]                          # TRANSFORMAR
print(nomes)                        # ['Rex', 'Mimi', 'Bob']

caes = [pet.nome for pet in pets if pet.especie == "Cão"]   # FILTRAR
print(caes)                         # ['Rex', 'Bob']

numeros = [3, 1, 2]

ordenada = sorted(numeros)     # sorted() devolve uma lista NOVA (aula 18)
print(ordenada)                # [1, 2, 3]

resultado = numeros.sort()     # .sort() ordena in-place e devolve None
print(resultado)               # None
print(numeros)                 # [1, 2, 3]

estoque = {"P01": "Café", "P02": "Chá"}
print(estoque.get("P01"))          # Café
print(estoque.get("P99"))          # None  — .get() evita KeyError
print(estoque.get("P99", "vazio")) # vazio

# set só deduplica objetos com __eq__ + __hash__ (aula 11 revisitada na 18)
class Pet:
    def __init__(self, nome):
        self.nome = nome
    def __eq__(self, outro):
        return self.nome == outro.nome
    def __hash__(self):
        return hash(self.nome)

unicos = {Pet("Rex"), Pet("Rex"), Pet("Mimi")}
print(len(unicos))             # 2

# Singleton: intercepta __new__ para devolver sempre a MESMA instância (aula 20)
class ConfigSistema:
    _instancia = None

    def __new__(cls):
        if cls._instancia is None:
            cls._instancia = super().__new__(cls)
            cls._instancia.tema = "claro"   # estado inicial só na 1ª vez
        return cls._instancia

config1 = ConfigSistema()
config2 = ConfigSistema()

print(config1 is config2)    # True  — prova com is (identidade), não com ==
config1.tema = "escuro"
print(config2.tema)          # escuro  — é o mesmo objeto

from abc import ABC, abstractmethod

class Calabresa:
    def __str__(self): return "Calabresa"
class Portuguesa:
    def __str__(self): return "Portuguesa"

# Simple Factory: uma função central decide QUAL classe pelo parâmetro (aula 20)
def criar_pizza(sabor):
    tabela = {"calabresa": Calabresa, "portuguesa": Portuguesa}  # guarda CLASSES
    if sabor not in tabela:
        raise ValueError(f"Sabor desconhecido: {sabor}")
    return tabela[sabor]()          # o () instancia a classe escolhida

print(criar_pizza("calabresa"))     # Calabresa

# Factory Method (GoF): a SUBCLASSE do criador decide o produto
class Pizzaria(ABC):
    @abstractmethod
    def criar_pizza(self):
        ...
    def entregar(self):
        return f"Entregando {self.criar_pizza()}"

class PizzariaPaulistana(Pizzaria):
    def criar_pizza(self):
        return Calabresa()

print(PizzariaPaulistana().entregar())   # Entregando Calabresa

from abc import ABC, abstractmethod

# Observer: o Subject AVISA todos os inscritos ao mudar de estado (aula 21)
class Inscrito(ABC):
    @abstractmethod
    def atualizar(self, video):     # cada Observer implementa atualizar()
        ...

class Canal:                        # Subject / Observável
    def __init__(self, nome):
        self.nome = nome
        self.inscritos = []
    def inscrever(self, inscrito):
        self.inscritos.append(inscrito)
    def publicar(self, video):
        for inscrito in self.inscritos:   # notificar = percorrer a lista
            inscrito.atualizar(video)

class Fa(Inscrito):
    def __init__(self, nome):
        self.nome = nome
    def atualizar(self, video):
        print(f"{self.nome} recebeu: {video}")

canal = Canal("SENAI POO")
canal.inscrever(Fa("Ana"))
canal.inscrever(Fa("Bruno"))
canal.publicar("Aula 21")
# Ana recebeu: Aula 21
# Bruno recebeu: Aula 21

from abc import ABC, abstractmethod

# Strategy: cada algoritmo é uma classe trocável; o Contexto DELEGA (aula 21)
class Desconto(ABC):
    @abstractmethod
    def calcular(self, valor):
        ...

class SemDesconto(Desconto):
    def calcular(self, valor):
        return valor

class BlackFriday(Desconto):
    def calcular(self, valor):
        return valor * 0.5

class Carrinho:                     # Contexto: guarda a estratégia ativa
    def __init__(self, total, desconto):
        self.total = total
        self.desconto = desconto
    def total_final(self):
        return self.desconto.calcular(self.total)   # delega à estratégia

carrinho = Carrinho(200, SemDesconto())
print(carrinho.total_final())       # 200
carrinho.desconto = BlackFriday()   # troca a estratégia em runtime
print(carrinho.total_final())       # 100.0

# Ponte (aula 18): a key do sorted É a estratégia; sorted é o Contexto
produtos = [{"nome": "Café", "preco": 18}, {"nome": "Chá", "preco": 9}]
print([p["nome"] for p in sorted(produtos, key=lambda p: p["preco"])])
# ['Chá', 'Café']

import tkinter as tk               # convenção: nunca from tkinter import * (aula 22)

def ao_clicar():                    # callback = o Observer da aula 21
    rotulo.config(text="Clicado!")
    print("Botão clicado")

janela = tk.Tk()                    # janela raiz — a app tem exatamente UMA
janela.title("Exemplo")

rotulo = tk.Label(janela, text="Aguardando...")   # Label = o print() visual
rotulo.pack(padx=20, pady=10)

# command= recebe a FUNÇÃO como valor (sem parênteses) — clique = notificação
botao = tk.Button(janela, text="Clique", command=ao_clicar)
botao.pack(pady=10)

janela.mainloop()                   # loop de eventos — SEMPRE a última linha
# ao clicar no botão, o terminal mostra: Botão clicado

import tkinter as tk
from tkinter import messagebox

# a app inteira herda de tk.Tk (herança da aula 07; padrão da aula 23)
class App(tk.Tk):
    def __init__(self):
        super().__init__()          # obrigatório e PRIMEIRO
        self.clientes = ["Ana", "Bruno", "Carla"]   # a lista é a fonte da verdade

        self.lista = tk.Listbox(self, height=5)     # Listbox = a list visual (aula 18)
        self.lista.pack(padx=10, pady=10)
        self.preencher()
        # bind liga um evento a um callback — o command= generalizado
        self.lista.bind("<<ListboxSelect>>", self.ao_selecionar)

        tk.Button(self, text="Excluir", command=self.excluir).pack(pady=5)

    def preencher(self):
        self.lista.delete(0, tk.END)          # limpa ANTES de reinserir (senão duplica)
        for c in self.clientes:
            self.lista.insert(tk.END, c)      # o Listbox espelha a lista Python

    def ao_selecionar(self, evento):          # o handler recebe o evento
        selecao = self.lista.curselection()   # tupla de índices (vazia se nada)
        if selecao:
            print(self.clientes[selecao[0]])

    def excluir(self):
        selecao = self.lista.curselection()
        if selecao and messagebox.askyesno("Excluir", "Confirma?"):  # askyesno → bool
            del self.clientes[selecao[0]]
            self.preencher()

App().mainloop()                     # um único mainloop para toda a app

import sqlite3
from pathlib import Path

BANCO = Path(__file__).parent / "loja.db"   # o .db fica ao lado do script (aula 24)

conexao = sqlite3.connect(BANCO)            # abre (cria o arquivo se não existe)
conexao.execute("""
    CREATE TABLE IF NOT EXISTS produtos (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nome TEXT NOT NULL,
        preco REAL NOT NULL
    )
""")                                        # IF NOT EXISTS evita erro na 2ª execução
conexao.commit()                            # sem commit(), nada é gravado (erro nº 1)
conexao.close()                             # abrir → usar → fechar (aula 17)
print("Banco pronto")                       # Banco pronto

import sqlite3

conexao = sqlite3.connect("loja.db")       # abre o arquivo do banco (rode num .db novo pra ver esta saída)
conexao.execute("CREATE TABLE produtos (id INTEGER PRIMARY KEY AUTOINCREMENT, nome TEXT, preco REAL)")

# INSERT com placeholder ? — NUNCA f-string (evita SQL injection, aula 24)
conexao.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)", ("Caneta azul", 2.5))
conexao.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)", ("Caneta preta", 2.5))
conexao.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)", ("Caderno", 15.0))
conexao.commit()

# SELECT com busca parcial: WHERE ... LIKE ?
cursor = conexao.execute("SELECT nome, preco FROM produtos WHERE nome LIKE ?", ("Caneta%",))
print(cursor.fetchall())   # [('Caneta azul', 2.5), ('Caneta preta', 2.5)]

# UPDATE com WHERE (o cinto de segurança — sem ele, altera TODAS as linhas)
conexao.execute("UPDATE produtos SET preco = ? WHERE id = ?", (18.0, 3))
print(conexao.execute("SELECT nome, preco FROM produtos WHERE id = ?", (3,)).fetchone())
# ('Caderno', 18.0)

conexao.close()