From 3245d197abda26addf6e737f7326a18e632dcc6c Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Wed, 12 Nov 2025 20:07:11 -0300 Subject: [PATCH 01/12] teste --- tests/respExercicio01.py | 29 +++++++++++++++++++++++++++++ tests/test_exercicio01.py | 3 ++- 2 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 tests/respExercicio01.py diff --git a/tests/respExercicio01.py b/tests/respExercicio01.py new file mode 100644 index 0000000..d6b1fd8 --- /dev/null +++ b/tests/respExercicio01.py @@ -0,0 +1,29 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def apresentar(self): + print ( f"Aluno: {self.nome}, Matrícula: {self.matricula}, Curso: {self.curso}") + + + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + def apresentar(self): + print ( f"Disciplina: {self.nome}, codigo: {self.codigo}, carga horaria: {self.carga_horaria}") + +aluno1 = Aluno('João Silva', 2023001, 'Engenharia de Software') +aluno1.apresentar() + +disciplina1 = Disciplina('Programação Orientada a Objetos', 'POO001', '60h') +disciplina1.apresentar() + + + + \ No newline at end of file diff --git a/tests/test_exercicio01.py b/tests/test_exercicio01.py index ac0b978..20653e5 100644 --- a/tests/test_exercicio01.py +++ b/tests/test_exercicio01.py @@ -29,5 +29,6 @@ def test_disciplina_atributos(self): self.assertEqual(disciplina.codigo, "POO001") self.assertEqual(disciplina.carga_horaria, 60) + if __name__ == '__main__': - unittest.main() \ No newline at end of file + unittest.main() From 453adeb77bf9d9f4aeeda563a335045ad1179245 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Wed, 12 Nov 2025 20:46:35 -0300 Subject: [PATCH 02/12] ex02 --- tests/respExercicio02.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 tests/respExercicio02.py diff --git a/tests/respExercicio02.py b/tests/respExercicio02.py new file mode 100644 index 0000000..d779b57 --- /dev/null +++ b/tests/respExercicio02.py @@ -0,0 +1,29 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + self.notas.append(float(nota)) + + def calcular_media(self): + self.media = sum(self.notas) / len(self.notas) + return self.media + + def status(self): + if self.media > 7: + print('aprovado') + else: + print('reprovado') + +aluno1 = Aluno('João Silva', 2023001, 'Engenharia de Software') +aluno1.adicionar_nota(10) +aluno1.adicionar_nota(7) +aluno1.adicionar_nota(8) +media = aluno1.calcular_media() +aluno1.status() + + + From 0e14705d5b15f7d2e5e860ca08e3f6613cd30eba Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Fri, 14 Nov 2025 22:45:16 -0300 Subject: [PATCH 03/12] alguma coisa --- tests/respExercicio02.py | 7 ++++--- tests/respExercicio03.py | 30 ++++++++++++++++++++++++++++++ tests/respExercicio04.py | 31 +++++++++++++++++++++++++++++++ tests/test_exercicio03.py | 6 +++--- 4 files changed, 68 insertions(+), 6 deletions(-) create mode 100644 tests/respExercicio03.py create mode 100644 tests/respExercicio04.py diff --git a/tests/respExercicio02.py b/tests/respExercicio02.py index d779b57..9039222 100644 --- a/tests/respExercicio02.py +++ b/tests/respExercicio02.py @@ -19,10 +19,11 @@ def status(self): print('reprovado') aluno1 = Aluno('João Silva', 2023001, 'Engenharia de Software') -aluno1.adicionar_nota(10) -aluno1.adicionar_nota(7) -aluno1.adicionar_nota(8) +aluno1.adicionar_nota(3) +aluno1.adicionar_nota(3) +aluno1.adicionar_nota(3) media = aluno1.calcular_media() +print(aluno1.media) aluno1.status() diff --git a/tests/respExercicio03.py b/tests/respExercicio03.py new file mode 100644 index 0000000..06592f1 --- /dev/null +++ b/tests/respExercicio03.py @@ -0,0 +1,30 @@ +class Professor: + def __init__(self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + @property + def obter_salario(self): + return self._salario + + @obter_salario.setter + def obter_salario(self, novo_salario): + if novo_salario > 0: + self._salario = novo_salario + else: + print('Salario não pode ser menor que0') + + def aumentar_salario(self, valor): + if valor > 0: + self._salario += valor + else: + print('O aumento não pode ser menor ou igual a zero') + +prof = Professor("Dr. Silva", "Computação", 5000.0) +print(f"Salário atual: R$ {prof.obter_salario}") +prof.obter_salario = 6000.0 # Deve funcionar +print(f"Novo salário: R$ {prof.obter_salario}") +prof.obter_salario= -1000.0 # Deve dar erro +print(f"Salário após tentativa inválida: R$ {prof.obter_salario}") + diff --git a/tests/respExercicio04.py b/tests/respExercicio04.py new file mode 100644 index 0000000..5caa947 --- /dev/null +++ b/tests/respExercicio04.py @@ -0,0 +1,31 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento =data_nascimento + + def apresentar(self): + return (f' Olá, sou {self.nome} , CPF: {self.cpf}') + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + + def apresentar(self): + return(f' Olá, sou {self.nome} , CPF: {self.cpf}') + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + super().__init__(nome, cpf, data_nascimento) + self.area_atuacao =area_atuacao + + def apresentar(self): + return(f' Olá, sou {self.nome}, CPF: {self.cpf}, atuo na área de {self.area_atuacao}') + +funcionario = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário") +tutor = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") + +print(funcionario.apresentar()) +tutor.apresentar() + diff --git a/tests/test_exercicio03.py b/tests/test_exercicio03.py index f204315..227ea52 100644 --- a/tests/test_exercicio03.py +++ b/tests/test_exercicio03.py @@ -20,12 +20,12 @@ def test_salario_privado(self): def test_property_salario(self): prof = self.module.Professor("Dr. Silva", "Computação", 5000) - self.assertEqual(prof.salario, 5000) + self.assertEqual(prof._salario, 5000) def test_setter_salario_positivo(self): prof = self.module.Professor("Dr. Silva", "Computação", 5000) - prof.salario = 6000 - self.assertEqual(prof.salario, 6000) + prof._salario = 6000 + self.assertEqual(prof._salario, 6000) if __name__ == '__main__': unittest.main() \ No newline at end of file From 17de3b8e6ea29f0ae9d7ba89fc67823b47c49c6c Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Fri, 14 Nov 2025 23:03:05 -0300 Subject: [PATCH 04/12] ex04 --- tests/respExercicio05.py | 43 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 tests/respExercicio05.py diff --git a/tests/respExercicio05.py b/tests/respExercicio05.py new file mode 100644 index 0000000..13280c1 --- /dev/null +++ b/tests/respExercicio05.py @@ -0,0 +1,43 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento =data_nascimento + + def apresentar(self): + return (f' Olá, sou {self.nome} , CPF: {self.cpf}') + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + self.salario = salario + + def exibir_dados(self): + print("=== Dados do Funcionário ===") + print(f"Nome: {self.nome}") + print(f"CPF: {self.cpf}") + print(f"Data de Nascimento: {self.data_nascimento}") + print(f"Cargo: {self.cargo}") + print(f"Salário: R$ {self.salario:.2f}") + + + + + + + + + ## Exemplo de Uso +##``python +funcionario = Funcionario("Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0) +funcionario.exibir_dados() + +## Exemplo de Saída Esperada + +#=== Dados do Funcionário === +#Nome: Ana Costa +#CPF: 111.222.333-44 +#Data de Nascimento: 20/03/1988 +##Cargo: Coordenadora +##Salário: R$ 4500.0 \ No newline at end of file From c7cd86be899aca1262750f514e3cdc91087c71d5 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Sat, 15 Nov 2025 12:27:21 -0300 Subject: [PATCH 05/12] att --- {tests => resolucao}/respExercicio01.py | 0 {tests => resolucao}/respExercicio02.py | 0 {tests => resolucao}/respExercicio03.py | 0 {tests => resolucao}/respExercicio04.py | 0 {tests => resolucao}/respExercicio05.py | 0 resolucao/respExercicio06.py | 32 +++++++++++++++++++++++++ 6 files changed, 32 insertions(+) rename {tests => resolucao}/respExercicio01.py (100%) rename {tests => resolucao}/respExercicio02.py (100%) rename {tests => resolucao}/respExercicio03.py (100%) rename {tests => resolucao}/respExercicio04.py (100%) rename {tests => resolucao}/respExercicio05.py (100%) create mode 100644 resolucao/respExercicio06.py diff --git a/tests/respExercicio01.py b/resolucao/respExercicio01.py similarity index 100% rename from tests/respExercicio01.py rename to resolucao/respExercicio01.py diff --git a/tests/respExercicio02.py b/resolucao/respExercicio02.py similarity index 100% rename from tests/respExercicio02.py rename to resolucao/respExercicio02.py diff --git a/tests/respExercicio03.py b/resolucao/respExercicio03.py similarity index 100% rename from tests/respExercicio03.py rename to resolucao/respExercicio03.py diff --git a/tests/respExercicio04.py b/resolucao/respExercicio04.py similarity index 100% rename from tests/respExercicio04.py rename to resolucao/respExercicio04.py diff --git a/tests/respExercicio05.py b/resolucao/respExercicio05.py similarity index 100% rename from tests/respExercicio05.py rename to resolucao/respExercicio05.py diff --git a/resolucao/respExercicio06.py b/resolucao/respExercicio06.py new file mode 100644 index 0000000..b25b4a7 --- /dev/null +++ b/resolucao/respExercicio06.py @@ -0,0 +1,32 @@ +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplinas): + self.disciplinas.append(disciplinas) + + def listar_disciplinas(self): + for i in self.disciplinas: + print(f"{i.nome} - ({i.codigo})") + + def carga_horaria_total(self): + total = sum( i.carga_horaria for i in self.disciplinas) + return total + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + +curso = Curso("Engenharia de Software", "ES001") +disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60) +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) + +curso.adicionar_disciplina(disciplina1) +curso.adicionar_disciplina(disciplina2) +curso.listar_disciplinas() +print(f"Carga horária total: {curso.carga_horaria_total()}h") \ No newline at end of file From 583bd50ccc5324030b8118fdb12f89bd05d47d9d Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Sat, 15 Nov 2025 13:26:28 -0300 Subject: [PATCH 06/12] ex07 --- {resolucao => tests}/respExercicio01.py | 0 {resolucao => tests}/respExercicio02.py | 0 {resolucao => tests}/respExercicio03.py | 0 {resolucao => tests}/respExercicio04.py | 0 {resolucao => tests}/respExercicio05.py | 0 {resolucao => tests}/respExercicio06.py | 0 tests/respExercicio07.py | 41 +++++++++++++++++++++++++ 7 files changed, 41 insertions(+) rename {resolucao => tests}/respExercicio01.py (100%) rename {resolucao => tests}/respExercicio02.py (100%) rename {resolucao => tests}/respExercicio03.py (100%) rename {resolucao => tests}/respExercicio04.py (100%) rename {resolucao => tests}/respExercicio05.py (100%) rename {resolucao => tests}/respExercicio06.py (100%) create mode 100644 tests/respExercicio07.py diff --git a/resolucao/respExercicio01.py b/tests/respExercicio01.py similarity index 100% rename from resolucao/respExercicio01.py rename to tests/respExercicio01.py diff --git a/resolucao/respExercicio02.py b/tests/respExercicio02.py similarity index 100% rename from resolucao/respExercicio02.py rename to tests/respExercicio02.py diff --git a/resolucao/respExercicio03.py b/tests/respExercicio03.py similarity index 100% rename from resolucao/respExercicio03.py rename to tests/respExercicio03.py diff --git a/resolucao/respExercicio04.py b/tests/respExercicio04.py similarity index 100% rename from resolucao/respExercicio04.py rename to tests/respExercicio04.py diff --git a/resolucao/respExercicio05.py b/tests/respExercicio05.py similarity index 100% rename from resolucao/respExercicio05.py rename to tests/respExercicio05.py diff --git a/resolucao/respExercicio06.py b/tests/respExercicio06.py similarity index 100% rename from resolucao/respExercicio06.py rename to tests/respExercicio06.py diff --git a/tests/respExercicio07.py b/tests/respExercicio07.py new file mode 100644 index 0000000..5680e44 --- /dev/null +++ b/tests/respExercicio07.py @@ -0,0 +1,41 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] + + def listar_disciplinas(self): + for d in self.disciplinas_inscritas: + print(d.nome) + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + for a in self.alunos_matriculados: + print(f"{a.nome} ({a.curso})") + +class Secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + disciplina.alunos_matriculados.append(aluno) + aluno.disciplinas_inscritas.append(disciplina) + +aluno1 = Aluno("João Silva", "2023001", "Engenharia de Software") +aluno2 = Aluno("Maria Santos", "2023002", "Ciência da Computação") +disciplina1 = Disciplina("POO", "POO001", 60) +disciplina2 = Disciplina("Banco de Dados", "BD001", 80) + +secretaria = Secretaria() +secretaria.inscrever_aluno(aluno1, disciplina1) +secretaria.inscrever_aluno(aluno1, disciplina2) +secretaria.inscrever_aluno(aluno2, disciplina1) + + +aluno1.listar_disciplinas() +disciplina1.listar_alunos() \ No newline at end of file From e43aeb4f8b1c1a87f1b07cfecbebb617b752b389 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Sat, 15 Nov 2025 13:55:00 -0300 Subject: [PATCH 07/12] ex08 --- tests/respExercicio08.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 tests/respExercicio08.py diff --git a/tests/respExercicio08.py b/tests/respExercicio08.py new file mode 100644 index 0000000..f4ea485 --- /dev/null +++ b/tests/respExercicio08.py @@ -0,0 +1,25 @@ +class Departamento: + def __init__(self, nome, sigla): + self.nome = nome + self.sigla = sigla + self.professores = [] + + + @classmethod + def criar_departamento_exatas(cls, nome): + sigla = 'EXA' + return cls(nome, sigla) + + @classmethod + def criar_departamento_humanas(cls, nome): + sigla = 'HUM' + return cls(nome, sigla) + + def adicionar_professor(self, professor): + self.professores.append(professor) + +dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") +dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + +print(f"Departamento: {dept_exatas.nome} - Sigla: {dept_exatas.sigla}") +print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}") From 06a76b6b0c59bfdd2fd6318ae903cc6b8a4ea722 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Mon, 17 Nov 2025 19:32:32 -0300 Subject: [PATCH 08/12] ex09 --- tests/respExercicio09.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 tests/respExercicio09.py diff --git a/tests/respExercicio09.py b/tests/respExercicio09.py new file mode 100644 index 0000000..ded8062 --- /dev/null +++ b/tests/respExercicio09.py @@ -0,0 +1,37 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return ( f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}.") + +class Professor: + def __init__(self, nome, departamento, salario): + self.nome = nome + self.departamento = departamento + self._salario = salario + + def apresentar(self): + return (f"Olá, sou o professor {self.nome} e leciono no departamento {self.departamento}.") + +class Funcionario: + def __init__(self, nome, cpf, data_nascimento, cargo, salario): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + self.cargo = cargo + self.salario = salario + + def apresentar(self): + return (f"Olá, sou o funcionário {self.nome} e meu cargo é {self.cargo}.") + +pessoas = [ + Aluno("João Silva", "2023001", "Engenharia de Software"), + Professor("Dr. Maria", "Computação", 8000.0), + Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0) +] + +for pessoa in pessoas: + print(pessoa.apresentar()) \ No newline at end of file From 5887f02cbc8f381b79700b5f0d2ba20ca9cc0822 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Mon, 17 Nov 2025 21:40:54 -0300 Subject: [PATCH 09/12] ex10, 11, 12 --- Resposta_10.md | 36 +++++++++++++++++++++++++++++++ tests/Resposta_10.py | 46 ++++++++++++++++++++++++++++++++++++++++ tests/respExercicio11.py | 31 +++++++++++++++++++++++++++ tests/respExercicio12.py | 44 ++++++++++++++++++++++++++++++++++++++ tests/respExercicio13.py | 0 5 files changed, 157 insertions(+) create mode 100644 Resposta_10.md create mode 100644 tests/Resposta_10.py create mode 100644 tests/respExercicio11.py create mode 100644 tests/respExercicio12.py create mode 100644 tests/respExercicio13.py diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..14ec5b0 --- /dev/null +++ b/Resposta_10.md @@ -0,0 +1,36 @@ +Relatório dos 7 Erros - Exercício 10 +Erro 1: Classe com nome em minúscula +Problema: class pessoa: deveria ser class Pessoa: + +Solução: Renomear para class Pessoa: +Conceito POO: Convenção de nomenclatura - classes em Python devem usar PascalCase +Erro 2: Atribuição sem self +Problema: nome = nome ao invés de self.nome = nome + +Solução: Alterar para self.nome = nome +Conceito POO: Encapsulamento - o atributo não era armazenado na instância +Erro 3: Atributo privado sem inicialização adequada +Problema: self.__cpf = None sem parâmetro no __init__ + +Solução: Adicionar parâmetro cpf=None na assinatura do método +Conceito POO: Encapsulamento - atributos privados devem ser inicializados corretamente +Erro 4: Método sem parâmetro self +Problema: def apresentar(): está faltando self + +Solução: Alterar para def apresentar(self): +Conceito POO: Métodos de instância sempre precisam do parâmetro self +Erro 5: Não usar super() na herança +Problema: Estudante não chama super().__init__(), duplicando código + +Solução: Usar super().__init__(nome, idade, cpf=None) para herdar inicialização da classe pai +Conceito POO: Herança - reutilizar código da classe pai evita duplicação +Erro 6: Divisão por zero +Problema: calcular_media() divide por zero quando self.notas está vazio + +Solução: Adicionar verificação if not self.notas: return 0 +Conceito POO: Tratamento de exceções e validação de dados +Erro 7: Teste com estudante sem notas +Problema: print(estudante.calcular_media()) sem adicionar notas causa erro + +Solução: Adicionar notas com estudante.adicionar_nota() antes de calcular +Conceito POO: Lógica de negócio - estado do objeto deve ser válido antes de operações diff --git a/tests/Resposta_10.py b/tests/Resposta_10.py new file mode 100644 index 0000000..d0f6e14 --- /dev/null +++ b/tests/Resposta_10.py @@ -0,0 +1,46 @@ +class Pessoa: # Erro 1 + def __init__(self, nome, idade, cpf = None): + self.nome = nome # Erro 2 + self.idade = idade + self.__cpf = cpf # Erro 3 + + def apresentar(self): # Erro 4 + return f"Olá, sou {self.nome}" + +class Estudante(Pessoa): + def __init__(self, nome, idade, curso): + super().__init__(nome, idade, cpf = None) + self.curso = curso + self.notas = [] + + def adicionar_nota(self, nota): + if nota >= 0 and nota <= 10: + self.notas.append(nota) + + def calcular_media(self): + if not self.notas: + return 0 + media = sum(self.notas) / len(self.notas) + return media + + +class Professor(Pessoa): + def __init__(self, nome, idade, departamento, salario): + super().__init__(nome, idade, cpf = None) + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Olá, sou o professor {self.nome} do departamento {self.departamento}" + +# Testando o código +estudante = Estudante("João", 20, "Engenharia") +professor = Professor("Dr. Silva", 45, "Computação", 8000) + +print(estudante.apresentar()) +print(professor.apresentar()) +estudante.adicionar_nota(7.5) +estudante.adicionar_nota(8.0) +estudante.adicionar_nota(9.5) +estudante.adicionar_nota(8.5) +print(f"Média do estudante: {estudante.calcular_media()}") # Erro 7 \ No newline at end of file diff --git a/tests/respExercicio11.py b/tests/respExercicio11.py new file mode 100644 index 0000000..f0cd5b5 --- /dev/null +++ b/tests/respExercicio11.py @@ -0,0 +1,31 @@ +class Funcionario: + def __init__(self, nome, salario, cargo): + self.nome = nome + self.salario = salario + self.cargo = cargo + +class CalculadoraSalario: + def calcular_salario_liquido(self, funcionario, descontos): + salario_liquido = funcionario.salario - descontos + return salario_liquido + +class GeradorRelatorio: + def gerar_relatorio(self, funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario}" + +class RepositorioFuncionario: + def salvar_no_banco(self, funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +# Testando +funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora") +calculadora = CalculadoraSalario() +gerador = GeradorRelatorio() +repositorio = RepositorioFuncionario() + +salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0) +relatorio = gerador.gerar_relatorio(funcionario) +repositorio.salvar_no_banco(funcionario) + +print(f"Salário líquido: R$ {salario_liquido:.2f}") +print(relatorio) \ No newline at end of file diff --git a/tests/respExercicio12.py b/tests/respExercicio12.py new file mode 100644 index 0000000..4a80ee4 --- /dev/null +++ b/tests/respExercicio12.py @@ -0,0 +1,44 @@ +from abc import ABC + +class CalculadorDesconto(ABC): + def calcular(self): + pass + + +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor_original): + valor = valor_original * 0.90 + return valor + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor_original): + valor = valor_original * 0.85 + return valor + +class DescontoVIP(CalculadorDesconto): + def calcular(self, valor_original): + valor = valor_original * 0.80 + return valor + + +class ProcessadorPagamento(CalculadorDesconto): + def processar(self, valor, desconto: CalculadorDesconto): + valor_desconto = desconto.calcular(valor) + return valor_desconto + + + + +# Uso do sistema +pagamento = ProcessadorPagamento() +valor_original = 1000.0 + +# Diferentes tipos de desconto +desconto_estudante = DescontoEstudante() +desconto_funcionario = DescontoFuncionario() + +valor_final1 = pagamento.processar(valor_original, desconto_estudante) +valor_final2 = pagamento.processar(valor_original, desconto_funcionario) + +print(f"Estudante: R$ {valor_final1}") +print(f"Funcionário: R$ {valor_final2}") diff --git a/tests/respExercicio13.py b/tests/respExercicio13.py new file mode 100644 index 0000000..e69de29 From cc5e89ae5ce63e2f2038ab078310f13e9fbc2d8d Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Wed, 19 Nov 2025 22:01:26 -0300 Subject: [PATCH 10/12] finalizado a 15 --- tests/respExercicio13.py | 77 ++++++++++++++++++++++++++++++++++++++++ tests/respExercicio14.py | 75 ++++++++++++++++++++++++++++++++++++++ tests/respExercicio15.py | 40 +++++++++++++++++++++ 3 files changed, 192 insertions(+) create mode 100644 tests/respExercicio14.py create mode 100644 tests/respExercicio15.py diff --git a/tests/respExercicio13.py b/tests/respExercicio13.py index e69de29..e3b022c 100644 --- a/tests/respExercicio13.py +++ b/tests/respExercicio13.py @@ -0,0 +1,77 @@ +class Veiculo: + def __init__(self): + self.velocidade_atual = 0 + + def acelerar(self): + self.velocidade_atual = 0 + return self.velocidade_atual + + def frear(self): + ... + + def get_velocidade(self): + self.velocidade_atual = 0 + return self.velocidade_atual + +class Carro(Veiculo): + def acelerar(self): + velocidade_max = 100 + if self.velocidade_atual < velocidade_max: + self.velocidade_atual = self.velocidade_atual + 20 + + def frear(self): + if self.velocidade_atual > 0: + self.velocidade_atual = self.velocidade_atual - 20 + + def get_velocidade(self): + self.velocidade = self.velocidade_atual + return self.velocidade + + + +class Bicicleta(Veiculo): + def acelerar(self): + velocidade_max = 50 + if self.velocidade_atual < velocidade_max: + self.velocidade_atual = self.velocidade_atual + 10 + + def frear(self): + if self.velocidade_atual > 0: + self.velocidade_atual = self.velocidade_atual - 10 + + def get_velocidade(self): + self.velocidade = self.velocidade_atual + return self.velocidade + +class Aviao(Veiculo): + def acelerar(self): + velocidade_max = 900 + if self.velocidade_atual < velocidade_max: + self.velocidade_atual = self.velocidade_atual + 300 + + def frear(self): + if self.velocidade_atual > 0: + self.velocidade_atual = self.velocidade_atual - 300 + + def get_velocidade(self): + self.velocidade = self.velocidade_atual + return self.velocidade + +class ControladorTrafego: + def testar_veiculo(self, veiculo): + print(f"Testando {type(veiculo).__name__}") + veiculo.acelerar() + veiculo.acelerar() + print(f"Velocidade: {veiculo.get_velocidade()} km/h") + veiculo.frear() + print(f"Velocidade após frear: {veiculo.get_velocidade()} km/h") + +carro = Carro() +bicicleta = Bicicleta() +aviao = Aviao() + +trafego = ControladorTrafego() + +trafego.testar_veiculo(carro) +trafego.testar_veiculo(bicicleta) +trafego.testar_veiculo(aviao) diff --git a/tests/respExercicio14.py b/tests/respExercicio14.py new file mode 100644 index 0000000..eadf5c7 --- /dev/null +++ b/tests/respExercicio14.py @@ -0,0 +1,75 @@ +from abc import ABC, abstractmethod + +class Trabalhar(ABC): + @abstractmethod + def trabalhar(self): + ... + +class Comer(ABC): + @abstractmethod + def comer(self): + ... + +class Dormir(ABC): + @abstractmethod + def dormir(self): + ... + +class Programar(ABC): + @abstractmethod + def programar(self): + ... + +class Desenvolvedor(Trabalhar, Comer, Dormir, ProcessLookupError): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f'{self.nome} está trabalhando') + + def comer(self): + print(f'{self.nome} está comendo') + + def dormir(self): + print(f'{self.nome} está dormindo') + + def programar(self): + print(f'{self.nome} está progamando') + +class Gerente(Trabalhar, Comer, Dormir, ProcessLookupError): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f'{self.nome} está trabalhando') + + def comer(self): + print(f'{self.nome} está comendo') + +class Robo(Trabalhar, Comer, Dormir, ProcessLookupError): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f'{self.nome} está trabalhando') + + def programar(self): + print(f'{self.nome} está comendo') + + +desenvolvedor = Desenvolvedor("Ana") +gerente = Gerente("Carlos") +robo = Robo("R2D2") + +# Desenvolvedor faz tudo +desenvolvedor.trabalhar() +desenvolvedor.comer() +desenvolvedor.programar() + +# Gerente não programa +gerente.trabalhar() +gerente.comer() + +# Robô não come nem dorme +robo.trabalhar() +robo.programar() \ No newline at end of file diff --git a/tests/respExercicio15.py b/tests/respExercicio15.py new file mode 100644 index 0000000..13a45bb --- /dev/null +++ b/tests/respExercicio15.py @@ -0,0 +1,40 @@ +from abc import ABC, abstractmethod + +class ServicoNotificacao(ABC): + @abstractmethod + def enviar(self, mensagem): + ... + +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email: {mensagem}") + +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS: {mensagem}") + +class NotificacaoService: + def __init__(self, servico: ServicoNotificacao): + self.servico = servico + + def notificar(self, mensagem): + self.servico.enviar(mensagem) + + +email_service = EmailService() +sms_service = SMSService() +push_service = PushService() + +# Mesmo código cliente funciona com qualquer implementação +notificador1 = NotificacaoService(email_service) +notificador2 = NotificacaoService(sms_service) +notificador3 = NotificacaoService(push_service) + +mensagem = "Bem-vindo ao sistema!" +notificador1.notificar(mensagem) +notificador2.notificar(mensagem) +notificador3.notificar(mensagem) \ No newline at end of file From dbe322475b1a500d736af23eccdae6e3d5efad6e Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Thu, 20 Nov 2025 13:41:12 -0300 Subject: [PATCH 11/12] Finalizando a 16 --- tests/respExercicio15.py | 2 +- tests/respExercicio16.py | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) create mode 100644 tests/respExercicio16.py diff --git a/tests/respExercicio15.py b/tests/respExercicio15.py index 13a45bb..b6e08f6 100644 --- a/tests/respExercicio15.py +++ b/tests/respExercicio15.py @@ -15,7 +15,7 @@ def enviar(self, mensagem): class PushService(ServicoNotificacao): def enviar(self, mensagem): - print(f"Enviando SMS: {mensagem}") + print(f"Enviando Push: {mensagem}") class NotificacaoService: def __init__(self, servico: ServicoNotificacao): diff --git a/tests/respExercicio16.py b/tests/respExercicio16.py new file mode 100644 index 0000000..5aa04b5 --- /dev/null +++ b/tests/respExercicio16.py @@ -0,0 +1,39 @@ +from abc import ABC, abstractmethod +class ProcessadorPagamento(ABC): + @abstractmethod + def processar_pagamento(self, valor, cartao): + pass + +class PayPalAPI: + def make_payment(self, amount, credit_card_number): + return f"PayPal: Processando ${amount} no cartão {credit_card_number}" + +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, api): + self.api = api + + def processar_pagamento(self, valor, cartao): + resultado = self.api.make_payment(valor, cartao) + return resultado + +class SistemaPagamento: + def __init__(self, pagamento: ProcessadorPagamento): + self.pagamento = pagamento + + def realizar_pagamento(self, valor, cartao): + print(self.pagamento.processar_pagamento(valor, cartao)) + + + +# Sistema funciona com interface padrão +# # processador_interno = ProcessadorPagamentoInterno() +# sistema1 = SistemaPagamento(processador_interno) + +# Adapter permite usar PayPal com a mesma interface +paypal_api = PayPalAPI() +paypal_adapter = PayPalAdapter(paypal_api) +sistema2 = SistemaPagamento(paypal_adapter) + +# # Ambos funcionam da mesma forma +# sistema1.realizar_pagamento(100.0, "1234-5678") +sistema2.realizar_pagamento(200.0, "8765-4321") \ No newline at end of file From d91c631e5eb66cef6cdc6be56474496b8bbe8804 Mon Sep 17 00:00:00 2001 From: Maximus Ponciano Date: Fri, 21 Nov 2025 13:18:16 -0300 Subject: [PATCH 12/12] finalizando --- tests/respExercicio17.py | 75 ++++++++++++++++++++++++++++++++++++++++ tests/respExercicio18.py | 73 ++++++++++++++++++++++++++++++++++++++ tests/respExercicio19.py | 65 ++++++++++++++++++++++++++++++++++ tests/respExercicio20.py | 41 ++++++++++++++++++++++ 4 files changed, 254 insertions(+) create mode 100644 tests/respExercicio17.py create mode 100644 tests/respExercicio18.py create mode 100644 tests/respExercicio19.py create mode 100644 tests/respExercicio20.py diff --git a/tests/respExercicio17.py b/tests/respExercicio17.py new file mode 100644 index 0000000..fcd7d4e --- /dev/null +++ b/tests/respExercicio17.py @@ -0,0 +1,75 @@ +from abc import ABC, abstractmethod + +class Bebidas(ABC): + @abstractmethod + def get_descricao(self): + pass + + def get_preco(self): + pass + +class BebidaDecorator(Bebidas): + def __init__(self, bebidas: Bebidas): + self.bebidas = bebidas + + +class Cafe(Bebidas): + def get_descricao(self): + tipo_de_bebida = 'Café' + return tipo_de_bebida + + def get_preco(self): + preco = 5.00 + return preco + + +class Cha(Bebidas): + def get_descricao(self): + tipo_de_bebida = 'Chá' + return tipo_de_bebida + + def get_preco(self): + preco = 3.00 + return preco + +class LeiteDecorator(BebidaDecorator): + def get_descricao(self): + self.com_leite = self.bebidas.get_descricao() + ' com leite' + return self.com_leite + + def get_preco(self): + self.preco = self.bebidas.get_preco() + 2 + return self.preco + +class AcucarDecorator(BebidaDecorator): + def get_descricao(self): + self.com_acucar = self.bebidas.get_descricao() + ' com acucar' + return self.com_acucar + + def get_preco(self): + self.preco = self.bebidas.get_preco() + 0.50 + return self.preco + +class ChantillyDecorator(BebidaDecorator): + def get_descricao(self): + self.com_chantilly = self.bebidas.get_descricao() + ' com chantilly' + return self.com_chantilly + + def get_preco(self): + self.preco = self.bebidas.get_preco() + 3 + return self.preco + + + + + +cafe = Cafe() +print(f"{cafe.get_descricao()} - R$ {cafe.get_preco()}") + +# Bebida com decorators +cafe_com_leite = LeiteDecorator(cafe) +print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco()}") + +# Múltiplos decorators +cafe_especial = LeiteDecorator(AcucarDecorator(ChantillyDecorator(Cafe()))) +print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco()}") \ No newline at end of file diff --git a/tests/respExercicio18.py b/tests/respExercicio18.py new file mode 100644 index 0000000..a035710 --- /dev/null +++ b/tests/respExercicio18.py @@ -0,0 +1,73 @@ +class Amplificador: + def ligar(self): + print("Ligando amplificador") + + def definir_volume(self, volume): + print(f'Definindo volume para {volume}%') + +class DVDPlayer: + def ligar(self): + print('Ligando DVD player') + + def reproduzir(self, filme): + print(f"Reproduzindo {filme}") + + +class Projetor: + def ligar(self): + print("ligando projetor") + + def modo_widescreen(self): + pass + + +class Luzes: + def diminuir(self, nivel): + print(f"Diminuindo luzes para {nivel}%") + +class PipocaPopper: + def ligar(self): + print("Ligando pipoqueira") + + def fazer_pipoca(self): + print('Fazendo pipoca') + +class HomeTheaterFacade: + def __init__(self, filme, volume, nivel): + self.filme = filme + self.volume = volume + self.nivel = nivel + self.amplificador = Amplificador() + self.dvd = DVDPlayer() + self.projetor = Projetor() + self.luzes = Luzes() + self.pipoca = PipocaPopper() + + def assistir_filme(self): + print(f"Preparando para assistir {self.filme}...") + self.amplificador.ligar() + self.amplificador.definir_volume(self.volume) + self.dvd.ligar() + self.projetor.ligar() + self.luzes.diminuir(self.nivel) + self.pipoca.ligar() + self.pipoca.fazer_pipoca() + self.dvd.reproduzir(self.filme) + + def fim_filme(self): + print("Filme finalizado!") + + +home = HomeTheaterFacade('matrix', 5, 10) +home.assistir_filme() + +# Preparando para assistir Matrix... +# Ligando amplificador +# Definindo volume para 5 +# Ligando DVD player +# Ligando projetor +# Diminuindo luzes para 10% +# Ligando pipoqueira +# Fazendo pipoca +# Reproduzindo Matrix +# Filme finalizado! \ No newline at end of file diff --git a/tests/respExercicio19.py b/tests/respExercicio19.py new file mode 100644 index 0000000..7374f03 --- /dev/null +++ b/tests/respExercicio19.py @@ -0,0 +1,65 @@ +from abc import ABC, abstractmethod +class Observer(ABC): + @abstractmethod + def update(self, temperatura, umidade, pressao): + pass + + +class EstacaoMeteorologica: + def __init__(self): + self.observers = [] + self.temperatura = None + self.umidade = None + self.pressao = None + + def adicionar_observer(self, observer): + self.observers.append(observer) + + def remover_observer(self, observer): + if observer in self.observers: + self.observers.remove(observer) + + def notificar_observers(self): + for obs in self.observers: + obs.update(self.temperatura, self.umidade, self.pressao) + + def definir_medicoes(self, temperatura, umidade, pressao): + self.temperatura = temperatura + self.umidade = umidade + self.pressao = pressao + self.notificar_observers() + + +class DisplayTemperatura(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Temperatura: {temperatura}°C") + + +class DisplayUmidade(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Umidade: {umidade}%") + +class DisplayPressao(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Pressão: {pressao} hpa") + +class DisplayCompleto(Observer): + def update(self, temperatura, umidade, pressao): + print( + f"Display Completo: Temp: {temperatura}°C Umidade: {umidade}% Pressão: {pressao} hPa") + + +estacao = EstacaoMeteorologica() + +display_temp = DisplayTemperatura() +display_umidade = DisplayUmidade() +display_pressao = DisplayPressao() +display_completo = DisplayCompleto() + +estacao.adicionar_observer(display_temp) +estacao.adicionar_observer(display_umidade) +estacao.adicionar_observer(display_pressao) +estacao.adicionar_observer(display_completo) + +estacao.definir_medicoes(25.5, 65.0, 1013.2) +estacao.definir_medicoes(27.0, 70.0, 1015.1) diff --git a/tests/respExercicio20.py b/tests/respExercicio20.py new file mode 100644 index 0000000..a8c1f09 --- /dev/null +++ b/tests/respExercicio20.py @@ -0,0 +1,41 @@ +from abc import ABC, abstractmethod + +class EstrategiaFrete(ABC): + @abstractmethod + def calcular_frete(self, peso, distancia): + pass + +class FreteNormal(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return peso * 2.0 + distancia * 0.1 + +class FreteExpressogit(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return peso * 3.0 + distancia * 0.2 + +class FreteEconomico(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return peso * 1.0 + distancia * 0.5 + +class CalculadoraFrete: + def __init__(self, frete: EstrategiaFrete): + self.frete = frete + + def calcular(self, peso, distancia): + return self.frete.calcular_frete(peso, distancia) + + def definir_estrategia(self, nova_estrategia: EstrategiaFrete): + self.frete = nova_estrategia + + +peso = 10.0 # kg +distancia = 100.0 # km + +calculadora = CalculadoraFrete(FreteNormal()) +print(f"Frete Normal: R$ {calculadora.calcular(peso, distancia)}") + +calculadora.definir_estrategia(FreteExpresso()) +print(f"Frete Expresso: R$ {calculadora.calcular(peso, distancia)}") + +calculadora.definir_estrategia(FreteEconomico()) +print(f"Frete Econômico: R$ {calculadora.calcular(peso, distancia)}")