# Exemplo 1: Definindo uma classe simples
class Pessoa:
    pass # 'pass' é uma instrução nula, usada quando você não quer adicionar nada ainda.
 
# Criando um objeto (instância) da classe Pessoa
pessoa1 = Pessoa()
pessoa2 = Pessoa()
 
print(type(pessoa1))
print(type(pessoa2))
print(pessoa1)
print(pessoa2)

# Exemplo 2: Classe Pessoa com atributos de instância
class Pessoa:
    def __init__(self, nome, idade):
        """
        Método construtor da classe Pessoa.
        Inicializa uma nova instância de Pessoa com um nome e uma idade.
        """
        self.nome = nome  # Atributo de instância
        self.idade = idade # Atributo de instância
 
# Criando instâncias da classe Pessoa
pessoa_a = Pessoa("Alice", 30)
pessoa_b = Pessoa("Bob", 25)
 
print(f"Pessoa A: Nome = {pessoa_a.nome}, Idade = {pessoa_a.idade}")
print(f"Pessoa B: Nome = {pessoa_b.nome}, Idade = {pessoa_b.idade}")
 
# Podemos até modificar atributos de uma instância específica
pessoa_a.idade = 31
print(f"Pessoa A (após modificação): Nome = {pessoa_a.nome}, Idade = {pessoa_a.idade}")

# Exemplo 3: Classe com atributo de classe
class Carro:
    # Atributo de classe: compartilhado por todas as instâncias de Carro
    rodas = 4
    tipo_combustivel = "Gasolina"
 
    def __init__(self, marca, modelo, cor):
        self.marca = marca    # Atributo de instância
        self.modelo = modelo  # Atributo de instância
        self.cor = cor        # Atributo de instância
 
# Criando instâncias de Carro
carro1 = Carro("Ford", "Focus", "Prata")
carro2 = Carro("Chevrolet", "Onix", "Preto")
 
print(f"Carro 1: Marca={carro1.marca}, Rodas={carro1.rodas}, Combustível={carro1.tipo_combustivel}")
print(f"Carro 2: Marca={carro2.marca}, Rodas={carro2.rodas}, Combustível={carro2.tipo_combustivel}")
 
# Acessando o atributo de classe diretamente pela classe
print(f"Todos os carros têm {Carro.rodas} rodas.")
 
# Modificando um atributo de classe afeta todas as instâncias (se acessado via classe)
Carro.rodas = 6 # Imagine um carro futurista!
print(f"Carro 1 (após mudança): Rodas={carro1.rodas}")
print(f"Carro 2 (após mudança): Rodas={carro2.rodas}")

# Exemplo 4: Classe Pessoa com método de instância
class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
 
    def apresentar(self):
        """
        Método de instância para apresentar a pessoa.
        Acessa os atributos de instância 'nome' e 'idade'.
        """
        return f"Olá, meu nome é {self.nome} e eu tenho {self.idade} anos."
 
    def aniversario(self):
        """
        Método de instância para aumentar a idade da pessoa.
        Modifica o atributo de instância 'idade'.
        """
        self.idade += 1
        print(f"Feliz aniversário, {self.nome}! Agora você tem {self.idade} anos.")
 
# Criando instâncias
pessoa1 = Pessoa("Carlos", 28)
pessoa2 = Pessoa("Diana", 22)
 
# Chamando métodos de instância
print(pessoa1.apresentar())
print(pessoa2.apresentar())
 
pessoa1.aniversario()
print(pessoa1.apresentar())

# Exemplo 5: Classe com método de classe
class Livro:
    tipo_publicacao = "Livro Impresso" # Atributo de classe
 
    def __init__(self, titulo, autor, ano):
        self.titulo = titulo
        self.autor = autor
        self.ano = ano
 
    def detalhes(self):
        return f"Título: {self.titulo}, Autor: {self.autor}, Ano: {self.ano}, Tipo: {self.tipo_publicacao}"
 
    @classmethod
    def criar_livro_digital(cls, titulo, autor, ano):
        """
        Método de classe para criar um livro digital.
        Altera temporariamente o tipo de publicação para "Livro Digital".
        """
        # Podemos acessar atributos de classe via cls
        original_tipo = cls.tipo_publicacao
        cls.tipo_publicacao = "Livro Digital"
        livro_digital = cls(titulo, autor, ano) # Cria uma nova instância
        cls.tipo_publicacao = original_tipo # Restaura o atributo de classe
        return livro_digital
 
# Criando um livro normal
livro1 = Livro("Dom Casmurro", "Machado de Assis", 1899)
print(livro1.detalhes())
 
# Usando o método de classe para criar um livro digital
livro_digital = Livro.criar_livro_digital("Python Fluente", "Luciano Ramalho", 2015)
print(livro_digital.detalhes())
 
# Verificando se o tipo_publicacao do Livro original não foi alterado globalmente
# Note: o comportamento acima de alterar cls.tipo_publicacao é um exemplo didático.
# Em cenários reais, para um livro digital, você provavelmente teria um atributo de instância
# 'formato' ou uma subclasse 'LivroDigital'.
print(f"Tipo de publicação padrão da classe Livro após a criação do digital: {Livro.tipo_publicacao}")

# Exemplo 6: Classe com método estático
class Calculadora:
    def __init__(self, valor_inicial=0):
        self.valor = valor_inicial
 
    def adicionar(self, num):
        self.valor += num
        return self.valor
 
    @staticmethod
    def somar(a, b):
        """
        Método estático para somar dois números.
        Não precisa de acesso a 'self' ou 'cls'.
        """
        return a + b
 
    @staticmethod
    def multiplicar(a, b):
        """
        Método estático para multiplicar dois números.
        """
        return a * b
 
# Usando o método de instância
calc = Calculadora(10)
print(f"Valor atual da calculadora: {calc.adicionar(5)}")
 
# Usando métodos estáticos (podem ser chamados via classe ou instância)
print(f"Soma de 7 e 3: {Calculadora.somar(7, 3)}")
print(f"Multiplicação de 4 e 5: {Calculadora.multiplicar(4, 5)}")
 
# Também podemos chamar via instância, mas não é o propósito principal
print(f"Soma de 10 e 20 (via instância): {calc.somar(10, 20)}")

# Seu código para o Desafio 1 aqui
class Livro:
    def __init__(self, titulo, autor, paginas):
        self.titulo = titulo
        self.autor = autor
        self.paginas = paginas
        self.emprestado = False # Atributo de instância com valor padrão
 
    def emprestar(self):
        if not self.emprestado:
            self.emprestado = True
            print(f"'{self.titulo}' foi emprestado com sucesso.")
        else:
            print(f"'{self.titulo}' já está emprestado.")
 
    def devolver(self):
        if self.emprestado:
            self.emprestado = False
            print(f"'{self.titulo}' foi devolvido com sucesso.")
        else:
            print(f"'{self.titulo}' não estava emprestado.")
 
    def status(self):
        status_emprestimo = "Emprestado" if self.emprestado else "Disponível"
        return f"Livro: '{self.titulo}' por {self.autor}, {self.paginas} páginas. Status: {status_emprestimo}"
 
# Testando a classe Livro
print("\n--- Testando a classe Livro ---")
livro_a = Livro("O Pequeno Príncipe", "Antoine de Saint-Exupéry", 96)
livro_b = Livro("1984", "George Orwell", 328)
 
print(livro_a.status())
print(livro_b.status())
 
livro_a.emprestar()
print(livro_a.status())
 
livro_a.emprestar() # Tentando emprestar novamente
print(livro_a.status())
 
livro_b.devolver() # Tentando devolver algo que não está emprestado
print(livro_b.status())
 
livro_a.devolver()
print(livro_a.status())

# Seu código para o Desafio 2 aqui
class Retangulo:
    def __init__(self, largura, altura):
        if largura <= 0 or altura <= 0:
            raise ValueError("Largura e altura devem ser valores positivos.")
        self.largura = largura
        self.altura = altura
 
    def calcular_area(self):
        return self.largura * self.altura
 
    def calcular_perimetro(self):
        return 2 * (self.largura + self.altura)
 
    @classmethod
    def criar_quadrado(cls, lado):
        """
        Método de classe para criar um quadrado (um tipo especial de retângulo).
        """
        return cls(lado, lado) # cls() chama o construtor da própria classe
 
# Testando a classe Retangulo
print("\n--- Testando a classe Retangulo ---")
retangulo1 = Retangulo(10, 5)
print(f"Retângulo 1: Largura={retangulo1.largura}, Altura={retangulo1.altura}")
print(f"Área: {retangulo1.calcular_area()}")
print(f"Perímetro: {retangulo1.calcular_perimetro()}")
 
# Criando um quadrado usando o método de classe
quadrado1 = Retangulo.criar_quadrado(7)
print(f"\nQuadrado 1: Largura={quadrado1.largura}, Altura={quadrado1.altura}")
print(f"Área: {quadrado1.calcular_area()}")
print(f"Perímetro: {quadrado1.calcular_perimetro()}")
 
# Testando com valores inválidos (opcional, para explorar tratamento de erros)
try:
    Retangulo(0, 5)
except ValueError as e:
    print(f"\nErro ao criar retângulo: {e}")

# Seu código para o Desafio 3 aqui
class ContaBancaria:
    taxa_operacao = 0.01 # Atributo de classe: 1% de taxa por saque
 
    def __init__(self, numero_conta, titular, saldo=0.0):
        self.numero_conta = numero_conta
        self.titular = titular
        self.saldo = saldo
 
    @staticmethod
    def validar_valor(valor):
        """
        Método estático para validar se um valor é positivo.
        """
        return isinstance(valor, (int, float)) and valor > 0
 
    def depositar(self, valor):
        if not ContaBancaria.validar_valor(valor):
            print("Erro: O valor do depósito deve ser um número positivo.")
            return
 
        self.saldo += valor
        print(f"Depósito de R${valor:.2f} realizado. Saldo atual: R${self.saldo:.2f}")
 
    def sacar(self, valor):
        if not ContaBancaria.validar_valor(valor):
            print("Erro: O valor do saque deve ser um número positivo.")
            return
 
        valor_com_taxa = valor * (1 + ContaBancaria.taxa_operacao)
 
        if self.saldo >= valor_com_taxa:
            self.saldo -= valor_com_taxa
            print(f"Saque de R${valor:.2f} (taxa de R${valor * ContaBancaria.taxa_operacao:.2f}) realizado. Saldo atual: R${self.saldo:.2f}")
        else:
            print(f"Erro: Saldo insuficiente para sacar R${valor:.2f} (necessário R${valor_com_taxa:.2f}). Saldo atual: R${self.saldo:.2f}")
 
    def extrato(self):
        return f"Conta: {self.numero_conta} | Titular: {self.titular} | Saldo: R${self.saldo:.2f}"
 
# Testando a classe ContaBancaria
print("\n--- Testando a classe ContaBancaria ---")
conta1 = ContaBancaria("12345-6", "Maria Silva")
conta2 = ContaBancaria("78901-2", "João Pereira", 500.0)
 
print(conta1.extrato())
print(conta2.extrato())
 
conta1.depositar(1000)
conta1.sacar(50)
conta1.sacar(1000) # Tentando sacar mais do que tem
print(conta1.extrato())
 
conta2.depositar(200)
conta2.sacar(150)
print(conta2.extrato())
 
conta1.depositar(-50) # Testando valor inválido
conta1.sacar(0) # Testando valor inválido