From bd7682d8a4ea755a16a0f2cf83bc297f8acedc12 Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Wed, 12 Nov 2025 21:31:43 -0300 Subject: [PATCH 1/7] Exercicios atualizados --- respExercicio02.py | 40 ++++++++++++++++++++++++++++++++++++++++ tests/respExercicio01.py | 22 ++++++++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 respExercicio02.py create mode 100644 tests/respExercicio01.py diff --git a/respExercicio02.py b/respExercicio02.py new file mode 100644 index 0000000..eec0468 --- /dev/null +++ b/respExercicio02.py @@ -0,0 +1,40 @@ +class aluno: + def __init__(self, nome, matricula, curso, disciplina=None, notas=None): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplina = disciplina + self.notas = notas if notas is not None else [] + + def adicionar_nota(self, nota): + self.notas.append(nota) + + def calcular_media(self): + if not self.notas: + return 0 + return sum(self.notas) / len(self.notas) + + def status(self): + media = self.calcular_media() + if media >= 7: + return "Aprovado" + elif media >= 5: + return "Recuperação" + else: + return "Reprovado" + +aluno.adicionar_nota(8.5) +aluno.adicionar_nota(7.0) +aluno.adicionar_nota(9.2) +print(f"Média: {aluno.calcular_media()}") +print(f"Status: {aluno.status()}") + + + + + + + + + + diff --git a/tests/respExercicio01.py b/tests/respExercicio01.py new file mode 100644 index 0000000..b783202 --- /dev/null +++ b/tests/respExercicio01.py @@ -0,0 +1,22 @@ +class aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + class disciplina: + def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): + self.nome_disciplina = nome_disciplina + self.codigo_disciplina = codigo_disciplina + self.carga_horaria = carga_horaria + + +aluno1 = aluno("Joao Silva", "2023001", "Engenharia de Software") +aluno2 = aluno("Maria Santos", "2023002", "Ciencia da Computacao") +disciplina1 = aluno.disciplina("Programação Orientada a Objetos", "POO101", 60) +disciplina2 = aluno.disciplina("Estruturas de Dados", "ED202", 45) +print(f"Aluno: {aluno1.nome}, Matrícula: {aluno1.matricula}, Curso: {aluno1.curso}") +print(f"Aluno: {aluno2.nome}, Matrícula: {aluno2.matricula}, Curso: {aluno2.curso}") +print(f"Disciplina: {disciplina1.nome_disciplina}, Código: {disciplina1.codigo_disciplina}, Carga Horaria: {disciplina1.carga_horaria} horas") +print(f"Disciplina: {disciplina2.nome_disciplina}, Código: {disciplina2.codigo_disciplina}, Carga Horaria: {disciplina2.carga_horaria} horas") + From 4ab3e215eb31701b87b525398d21dd9224cc17b6 Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Wed, 12 Nov 2025 22:05:14 -0300 Subject: [PATCH 2/7] Carina Dalp --- respExercicio02.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/respExercicio02.py b/respExercicio02.py index eec0468..2865343 100644 --- a/respExercicio02.py +++ b/respExercicio02.py @@ -1,16 +1,15 @@ -class aluno: - def __init__(self, nome, matricula, curso, disciplina=None, notas=None): +class Aluno: + def __init__(self, nome, matricula, curso): self.nome = nome self.matricula = matricula self.curso = curso - self.disciplina = disciplina - self.notas = notas if notas is not None else [] + self.notas = [] def adicionar_nota(self, nota): self.notas.append(nota) def calcular_media(self): - if not self.notas: + if len(self.notas) == 0: return 0 return sum(self.notas) / len(self.notas) @@ -22,12 +21,13 @@ def status(self): return "Recuperação" else: return "Reprovado" - -aluno.adicionar_nota(8.5) -aluno.adicionar_nota(7.0) -aluno.adicionar_nota(9.2) -print(f"Média: {aluno.calcular_media()}") -print(f"Status: {aluno.status()}") + +alunoTeste = Aluno("Carlos Silva", "2023003", "Matemática") +alunoTeste.adicionar_nota(8) +alunoTeste.adicionar_nota(7) +alunoTeste.adicionar_nota(9) +print(f"Média: {alunoTeste.calcular_media()}") +print(f"Status: {alunoTeste.status()}") From 5f1c76e5d38fe27c53c4287f29377e56330a6c61 Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Sun, 16 Nov 2025 20:41:43 -0300 Subject: [PATCH 3/7] Exercicios atualizados --- .../respExercicio01.py => respExercicio01.py | 0 respExercicio03.py | 33 ++++++++++++ respExercicio04.py | 33 ++++++++++++ respExercicio05.py | 35 ++++++++++++ respExercicio06.py | 40 ++++++++++++++ respExercicio07.py | 54 +++++++++++++++++++ respExercicio08.py | 40 ++++++++++++++ 7 files changed, 235 insertions(+) rename tests/respExercicio01.py => respExercicio01.py (100%) create mode 100644 respExercicio03.py create mode 100644 respExercicio04.py create mode 100644 respExercicio05.py create mode 100644 respExercicio06.py create mode 100644 respExercicio07.py create mode 100644 respExercicio08.py diff --git a/tests/respExercicio01.py b/respExercicio01.py similarity index 100% rename from tests/respExercicio01.py rename to respExercicio01.py diff --git a/respExercicio03.py b/respExercicio03.py new file mode 100644 index 0000000..8116939 --- /dev/null +++ b/respExercicio03.py @@ -0,0 +1,33 @@ +class Professor: + def __init__(self, nome: str, departamento: str, salario: float): + self.nome = nome + self.departamento = departamento + self._salario = salario # atributo privado + + @property + def salario(self): + return self._salario + + @salario.setter + def salario(self, novo_valor): + if novo_valor > 0: + self._salario = novo_valor + else: + print("Erro: Salário deve ser um valor positivo!") + + def exibir_informacoes(self): + return f"Professor: {self.nome}, Departamento: {self.departamento}, Salário: R$ {self._salario:.2f}" + + + +professor = Professor ("Dr. Silva", "Computacao", 5000.00) +print(f"salario atual: {professor.salario}") +professor.salario = 6000.00 +print(f"novo salario: {professor.salario}") +professor.salario -1000.00 +print(f"salario apos tentativa invalida: {professor.salario}") + + + + + \ No newline at end of file diff --git a/respExercicio04.py b/respExercicio04.py new file mode 100644 index 0000000..2254852 --- /dev/null +++ b/respExercicio04.py @@ -0,0 +1,33 @@ +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á, meu nome é {self.nome}, meu CPF é {self.cpf}" + + +class Funcionario(Pessoa): + def __init__(self, nome, cpf, data_nascimento, cargo): + super().__init__(nome, cpf, data_nascimento) + self.cargo = cargo + + +class Tutor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, atuacao): + super().__init__(nome, cpf, data_nascimento) + self.atuacao = atuacao + + def apresentar(self): + super().apresentar() + return f"Olá, meu nome é {self.nome}, meu CPF é {self.cpf} e sou tutor na área de {self.atuacao}." + +# Testando as classes com polimorfismo + +Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário"), +Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") + +print(Funcionario.apresentar(Funcionario)) +print(Tutor.apresentar(Tutor)) + \ No newline at end of file diff --git a/respExercicio05.py b/respExercicio05.py new file mode 100644 index 0000000..8eabd80 --- /dev/null +++ b/respExercicio05.py @@ -0,0 +1,35 @@ +class Pessoa: + def __init__(self, nome, cpf, data_nascimento): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + +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}") + +funcionario = Funcionario( + "Ana Costa", + "111.222.333-44", + "20/03/1988", + "Coordenadora", + 4500.0) +funcionario.exibir_dados() + + + + + + + + \ No newline at end of file diff --git a/respExercicio06.py b/respExercicio06.py new file mode 100644 index 0000000..ca0797d --- /dev/null +++ b/respExercicio06.py @@ -0,0 +1,40 @@ +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + +class Curso: + def __init__(self, nome, codigo): + self.nome = nome + self.codigo = codigo + self.disciplinas = [] + + def adicionar_disciplina(self, disciplina): + self.disciplinas.append(disciplina) + + def listar_disciplinas(self): + print("Disciplinas do curso:") + for d in self.disciplinas: + print(f"- {d.nome} (Código: {d.codigo})") + + def carga_horaria_total(self): + total = 0 + for d in self.disciplinas: + total += d.carga_horaria + return total + +if __name__ == "__main__": + 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 diff --git a/respExercicio07.py b/respExercicio07.py new file mode 100644 index 0000000..3e8f30a --- /dev/null +++ b/respExercicio07.py @@ -0,0 +1,54 @@ + +class aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + self.disciplinas_inscritas = [] + + def listar_disciplinas(self): + print(f"=== Disciplinas inscritas do aluno {self.nome}:===") + if not self.disciplinas_inscritas: + print("Nenhuma disciplina inscrita.") + else: + for d in self.disciplinas_inscritas: + print(f"- {d.nome_disciplina} (Código: {d.codigo_disciplina})") + print() + +class disciplina: + def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): + self.nome_disciplina = nome_disciplina + self.codigo_disciplina = codigo_disciplina + self.carga_horaria = carga_horaria + self.alunos_matriculados = [] + + def listar_alunos(self): + print(f"===Alunos matriculados na disciplina {self.nome_disciplina}:===") + if not self.alunos_matriculados: + print("Nenhum aluno matriculado.") + else: + for a in self.alunos_matriculados: + print(f"- {a.nome} (Matrícula: {a.matricula})") + print() + +class secretaria: + @staticmethod + def inscrever_aluno(aluno, disciplina): + if disciplina not in aluno.disciplinas_inscritas: + aluno.disciplinas_inscritas.append(disciplina) + if aluno not in disciplina.alunos_matriculados: + disciplina.alunos_matriculados.append(aluno) + +if __name__ == "__main__": + + 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.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 diff --git a/respExercicio08.py b/respExercicio08.py new file mode 100644 index 0000000..10c15e1 --- /dev/null +++ b/respExercicio08.py @@ -0,0 +1,40 @@ +class Departamento: + def __init__(self, nome, sigla): + self.nome = nome + self.sigla = sigla + self.professores = [] + + + @classmethod + def criar_departamento_exatas(cls, nome): + return cls(nome, "EXA") + + @classmethod + def criar_departamento_humanas(cls, nome): + return cls(nome, "HUM") + + def adicionar_professor(self, professor): + self.professores.append(professor) + + def listar_professores(self): + print(f"=== Professores do departamento {self.nome}: ===") + for p in self.professores: + print(f"- {p.prof}") + + if __name__ == "__main__": + depto_exatas = Departamento.criar_departamento_exatas("Matematica e Computação") + depto_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + + print(f"Departamento: {depto_exatas.nome}, Sigla: {depto_exatas.sigla}") + print(f"Departamento: {depto_humanas.nome}, Sigla: {depto_humanas.sigla}") + + depto_exatas.adicionar_professor("Joao Silva") + depto_exatas.adicionar_professor("Ana Costa") + depto_exatas.listar_professores() + + + + + + + \ No newline at end of file From c470c8b40e78bec57f484629c81960694695b33b Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Wed, 19 Nov 2025 19:05:53 -0300 Subject: [PATCH 4/7] Exercicios atualizados --- Resposta_10.md | 0 Resposta_10.py | 47 +++++++++++++++++++++++++++++++++++++++++++ respExercicio09.py | 50 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+) create mode 100644 Resposta_10.md create mode 100644 Resposta_10.py create mode 100644 respExercicio09.py diff --git a/Resposta_10.md b/Resposta_10.md new file mode 100644 index 0000000..e69de29 diff --git a/Resposta_10.py b/Resposta_10.py new file mode 100644 index 0000000..9f543bd --- /dev/null +++ b/Resposta_10.py @@ -0,0 +1,47 @@ +class Pessoa: # pessoa minuscula = Pessao maiuscula + def __init__(self, nome, idade): + self.nome = nome # pendente self. + self.idade = idade + self.cpf = None # self.cpf + + def apresentar(self): # self): + return f"Olá, sou {self.nome}" + + +class Estudante(Pessoa): + def __init__(self, nome, idade, curso): + super().__init__(nome, idade) # nao precisa informar self.nome= nome + 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 len(self.notas) == 0: + return 0 + return sum(self.notas) / len(self.notas) + + +class Professor(Pessoa): + def __init__(self, nome, idade, departamento, salario): + super().__init__(nome, idade) + self.departamento = departamento + self.salario = salario + + def apresentar(self): + return f"Ola, sou o professor {self.nome} do departamento {self.departamento}" + + +if __name__ == "__main__": + estudante = Estudante("Joao", 20, "Engenharia") + professor = Professor("Dr. Silva", 45, "Computacao", 8000) + +print(estudante.apresentar()) +print(professor.apresentar()) +estudante.adicionar_nota(8) +estudante.adicionar_nota(10) +print(f"Média do estudante: {estudante.calcular_media()}") + +print(f"Salário do professor: {professor.salario}") diff --git a/respExercicio09.py b/respExercicio09.py new file mode 100644 index 0000000..749e192 --- /dev/null +++ b/respExercicio09.py @@ -0,0 +1,50 @@ +class Aluno: + def __init__(self, nome, matricula, curso): + self.nome = nome + self.matricula = matricula + self.curso = curso + + def apresentar(self): + return f"Olá, meu nome é {self.nome}, minha matrícula é {self.matricula} e curso {self.curso}." + +class Professor: + def __init__(self, nome, departamento): + self.nome = nome + self.departamento = departamento + + def apresentar(self): + return f"Olá, meu nome é {self.nome} e eu trabalho no departamento de {self.departamento}." + +class Funcionario: + def __init__(self, nome, setor): + self.nome = nome + self.setor = setor + + def apresentar(self): + return f"Olá, meu nome é {self.nome} e eu trabalho no setor de {self.setor}." + + #criando objetos + + +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) +] + + + # polimorfismo +for pessoa in pessoas: + print(pessoa.apresentar()) + + +#dúvidas????? + +#aluno = aluno("João Silva", "2023001", "Engenharia de Software") +#professor = professor("Dr. Maria", "Computação") +#funcionario = funcionario("Carlos Santos", "Recursos Humanos") + + # apresentações +#print(aluno.apresentar()) +#print(professor.apresentar()) +#print(funcionario.apresentar()) \ No newline at end of file From 9b4369e21e0547e379f727fbb93a324bca5deda1 Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Wed, 19 Nov 2025 20:51:43 -0300 Subject: [PATCH 5/7] =?UTF-8?q?Exerc=C3=ADcios=20atualizados?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Resposta_10.md | 42 ++++++++++++++++++++++++++++++++++++++++++ Resposta_10.py | 4 ++-- respExercicio01.py | 20 ++++++++++---------- respExercicio03.py | 15 +++++++-------- respExercicio04.py | 8 ++++---- respExercicio05.py | 8 ++++---- respExercicio07.py | 14 +++++++------- respExercicio08.py | 29 ++++++++++++++++++----------- respExercicio09.py | 13 ++++++++----- 9 files changed, 102 insertions(+), 51 deletions(-) diff --git a/Resposta_10.md b/Resposta_10.md index e69de29..edeac49 100644 --- a/Resposta_10.md +++ b/Resposta_10.md @@ -0,0 +1,42 @@ +Erro 1 = Nome da classe pessoa minúscula +Problema: classes em Py devem seguir a conversão CamelCase +Solução: Alterado para clss Pessoa +Conceito: Convenção e boas praticas de POO + +Erro 2 = Pendente Self. (atributo nome não sendo iniciado corretamente) +Problema: Dentro do `__init__`, estava escrito `nome = nome`, não atribuindo valor ao objeto. +Solução: Inserido self.nome = nome +Conceito: Encapsulado e inicialização correta de atributos + +Erro 3 = Atributo privado contribuindo para falha futura +Problema: self._cpf = None estava correto, mas poderia causar confusão sem getter/setter +Solução:Mantido (não é erro de fato). Apenas confirmamos sua funcionalidade. +Conceito: Encapsulamento + +Erro 4 = Metodo apresentar() sem parametro self +Problema: Definido como def apresentar () +Solução: Corrigido para `def apresentar(self) +Conceito: Metodo de instância + +Erro 5 = Classe Estudante não chamando o construtor da classe mãe +Problema: Estava redefinindo `self.nome = nome` diretamente +Solução: Usado `super().__init__(nome, idade) +Conceito: Herança e uso correto de `super() + +Erro 6 = Divisão por zero na média +Problema: sum(self.notas) / len(self.notas)` causa erro se a lista estiver vazia. +Solução:Adicionada verificação: + +if len(self.notas) == 0: + return 0 + +Conceito: + +Erro 7 = Média sendo calculada sem adicionar notas antes +Problema: No teste, chamava calcular_media() sem adicionar nenhuma nota. +Solução: Notas foram adicionadas antes da chamada e também implementada proteção no método. +Conceito: Lógica do programa e integridade dos dados. + + + + diff --git a/Resposta_10.py b/Resposta_10.py index 9f543bd..6aaac59 100644 --- a/Resposta_10.py +++ b/Resposta_10.py @@ -1,8 +1,8 @@ -class Pessoa: # pessoa minuscula = Pessao maiuscula +class Pessoa: # pessoa minuscula = Pessoa maiuscula def __init__(self, nome, idade): self.nome = nome # pendente self. self.idade = idade - self.cpf = None # self.cpf + self.cpf = None # self.cpf = privado, não foi declarado no init, ficando como futuro atributo def apresentar(self): # self): return f"Olá, sou {self.nome}" diff --git a/respExercicio01.py b/respExercicio01.py index b783202..5990239 100644 --- a/respExercicio01.py +++ b/respExercicio01.py @@ -1,22 +1,22 @@ -class aluno: +class Aluno: def __init__(self, nome, matricula, curso): self.nome = nome self.matricula = matricula self.curso = curso - class disciplina: + class Disciplina: def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): self.nome_disciplina = nome_disciplina self.codigo_disciplina = codigo_disciplina self.carga_horaria = carga_horaria -aluno1 = aluno("Joao Silva", "2023001", "Engenharia de Software") -aluno2 = aluno("Maria Santos", "2023002", "Ciencia da Computacao") -disciplina1 = aluno.disciplina("Programação Orientada a Objetos", "POO101", 60) -disciplina2 = aluno.disciplina("Estruturas de Dados", "ED202", 45) -print(f"Aluno: {aluno1.nome}, Matrícula: {aluno1.matricula}, Curso: {aluno1.curso}") -print(f"Aluno: {aluno2.nome}, Matrícula: {aluno2.matricula}, Curso: {aluno2.curso}") -print(f"Disciplina: {disciplina1.nome_disciplina}, Código: {disciplina1.codigo_disciplina}, Carga Horaria: {disciplina1.carga_horaria} horas") -print(f"Disciplina: {disciplina2.nome_disciplina}, Código: {disciplina2.codigo_disciplina}, Carga Horaria: {disciplina2.carga_horaria} horas") +Aluno1 = Aluno("Joao Silva", "2023001", "Engenharia de Software") +Aluno2 = Aluno("Maria Santos", "2023002", "Ciencia da Computacao") +Disciplina1 = Aluno.Disciplina("Programação Orientada a Objetos", "POO101", 60) +Disciplina2 = Aluno.Disciplina("Estruturas de Dados", "ED202", 45) +print(f"Aluno: {Aluno1.nome}, Matrícula: {Aluno1.matricula}, Curso: {Aluno1.curso}") +print(f"Aluno: {Aluno2.nome}, Matrícula: {Aluno2.matricula}, Curso: {Aluno2.curso}") +print(f"Disciplina: {Disciplina1.nome_disciplina}, Código: {Disciplina1.codigo_disciplina}, Carga Horaria: {Disciplina1.carga_horaria} horas") +print(f"Disciplina: {Disciplina2.nome_disciplina}, Código: {Disciplina2.codigo_disciplina}, Carga Horaria: {Disciplina2.carga_horaria} horas") diff --git a/respExercicio03.py b/respExercicio03.py index 8116939..84ec28d 100644 --- a/respExercicio03.py +++ b/respExercicio03.py @@ -18,14 +18,13 @@ def salario(self, novo_valor): def exibir_informacoes(self): return f"Professor: {self.nome}, Departamento: {self.departamento}, Salário: R$ {self._salario:.2f}" - - -professor = Professor ("Dr. Silva", "Computacao", 5000.00) -print(f"salario atual: {professor.salario}") -professor.salario = 6000.00 -print(f"novo salario: {professor.salario}") -professor.salario -1000.00 -print(f"salario apos tentativa invalida: {professor.salario}") +if __name__ == "__main__": + professor = Professor("Dr. Silva", "Computacao", 5000.00) + print(f"salario atual: {professor.salario}") + professor.salario = 6000.00 + print(f"novo salario: {professor.salario}") + professor.salario = -1000.00 + print(f"salario apos tentativa invalida: {professor.salario}") diff --git a/respExercicio04.py b/respExercicio04.py index 2254852..133a007 100644 --- a/respExercicio04.py +++ b/respExercicio04.py @@ -25,9 +25,9 @@ def apresentar(self): # Testando as classes com polimorfismo -Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário"), -Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") +f1 = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário") +t1 = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") -print(Funcionario.apresentar(Funcionario)) -print(Tutor.apresentar(Tutor)) +print(f1.apresentar()) +print(t1.apresentar()) \ No newline at end of file diff --git a/respExercicio05.py b/respExercicio05.py index 8eabd80..a02f773 100644 --- a/respExercicio05.py +++ b/respExercicio05.py @@ -1,5 +1,5 @@ class Pessoa: - def __init__(self, nome, cpf, data_nascimento): + def __init__(self, nome, cpf, data_nascimento): # def = criar self.nome = nome self.cpf = cpf self.data_nascimento = data_nascimento @@ -17,14 +17,14 @@ def exibir_dados(self): print(f"Data de Nascimento: {self.data_nascimento}") print(f"Cargo: {self.cargo}") print(f"Salário: R$ {self.salario:.2f}") - -funcionario = Funcionario( +if __name__ == "__main__": + funcionario = Funcionario( "Ana Costa", "111.222.333-44", "20/03/1988", "Coordenadora", 4500.0) -funcionario.exibir_dados() + funcionario.exibir_dados() diff --git a/respExercicio07.py b/respExercicio07.py index 3e8f30a..e97e230 100644 --- a/respExercicio07.py +++ b/respExercicio07.py @@ -1,5 +1,5 @@ -class aluno: +class Aluno: def __init__(self, nome, matricula, curso): self.nome = nome self.matricula = matricula @@ -15,7 +15,7 @@ def listar_disciplinas(self): print(f"- {d.nome_disciplina} (Código: {d.codigo_disciplina})") print() -class disciplina: +class Disciplina: def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): self.nome_disciplina = nome_disciplina self.codigo_disciplina = codigo_disciplina @@ -39,12 +39,12 @@ def inscrever_aluno(aluno, disciplina): if aluno not in disciplina.alunos_matriculados: disciplina.alunos_matriculados.append(aluno) -if __name__ == "__main__": +if __name__ == "__main__": #executa o código - 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) + 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.inscrever_aluno(aluno1, disciplina1) secretaria.inscrever_aluno(aluno1, disciplina2) diff --git a/respExercicio08.py b/respExercicio08.py index 10c15e1..9e8dd41 100644 --- a/respExercicio08.py +++ b/respExercicio08.py @@ -17,20 +17,27 @@ def adicionar_professor(self, professor): self.professores.append(professor) def listar_professores(self): - print(f"=== Professores do departamento {self.nome}: ===") - for p in self.professores: - print(f"- {p.prof}") + print(f"=== Professores do departamento {self.nome}: ===") + for p in self.professores: + print(f"- {p}") - if __name__ == "__main__": - depto_exatas = Departamento.criar_departamento_exatas("Matematica e Computação") - depto_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") - print(f"Departamento: {depto_exatas.nome}, Sigla: {depto_exatas.sigla}") - print(f"Departamento: {depto_humanas.nome}, Sigla: {depto_humanas.sigla}") - depto_exatas.adicionar_professor("Joao Silva") - depto_exatas.adicionar_professor("Ana Costa") - depto_exatas.listar_professores() + + + + +if __name__ == "__main__": + depto_exatas = Departamento.criar_departamento_exatas("Matemática e Computação") + depto_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia") + + print(f"Departamento: {depto_exatas.nome}, Sigla: {depto_exatas.sigla}") + print(f"Departamento: {depto_humanas.nome}, Sigla: {depto_humanas.sigla}") + + depto_exatas.adicionar_professor("João Silva") + depto_exatas.adicionar_professor("Ana Costa") + + depto_exatas.listar_professores() diff --git a/respExercicio09.py b/respExercicio09.py index 749e192..10cadec 100644 --- a/respExercicio09.py +++ b/respExercicio09.py @@ -4,20 +4,24 @@ def __init__(self, nome, matricula, curso): self.matricula = matricula self.curso = curso - def apresentar(self): - return f"Olá, meu nome é {self.nome}, minha matrícula é {self.matricula} e curso {self.curso}." + def apresentar(self): + return f"Olá, meu nome é {self.nome}, minha matrícula é {self.matricula}." class Professor: - def __init__(self, nome, departamento): + def __init__(self, nome, departamento, salario): self.nome = nome self.departamento = departamento + self.salario = salario def apresentar(self): return f"Olá, meu nome é {self.nome} e eu trabalho no departamento de {self.departamento}." class Funcionario: - def __init__(self, nome, setor): + def __init__(self, nome, cpf, data_nascimento, setor, salario): self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + self.salario = salario self.setor = setor def apresentar(self): @@ -32,7 +36,6 @@ def apresentar(self): Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 3000.0) ] - # polimorfismo for pessoa in pessoas: print(pessoa.apresentar()) From d72233201d9b6eddbf3d1cf2ff84a6e5d4c3b75c Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Wed, 19 Nov 2025 21:54:33 -0300 Subject: [PATCH 6/7] =?UTF-8?q?Exerc=C3=ADcios=20atualizados?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- respExercicio11.py | 30 ++++++++++++++++++++++++++++++ respExercicio12.py | 0 respExercicio13.py | 0 respExercicio14.py | 0 respExercicio15.py | 0 respExercicio16.py | 0 respExercicio17.py | 0 respExercicio18.py | 0 respExercicio19.py | 0 respExercicio20.py | 0 10 files changed, 30 insertions(+) create mode 100644 respExercicio11.py create mode 100644 respExercicio12.py create mode 100644 respExercicio13.py create mode 100644 respExercicio14.py create mode 100644 respExercicio15.py create mode 100644 respExercicio16.py create mode 100644 respExercicio17.py create mode 100644 respExercicio18.py create mode 100644 respExercicio19.py create mode 100644 respExercicio20.py diff --git a/respExercicio11.py b/respExercicio11.py new file mode 100644 index 0000000..054b06b --- /dev/null +++ b/respExercicio11.py @@ -0,0 +1,30 @@ +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): + return funcionario.salario - descontos + +class GeradorRelatorio: + def gerar_relatorio(self, funcionario): + return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario}" + +class Repositoriofuncionario: + def salvar(self, funcionario): + print(f"Salvando {funcionario.nome} no banco de dados...") + +calculadora = CalculadoraSalario() +gerador = GeradorRelatorio() +calculadora = CalculadoraSalario() +gerador = GeradorRelatorio() +repositorio = Repositoriofuncionario() + +funcionario = Funcionario("Ana Silva", 5000, "Desenvolvedor") + +salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500) +relatorio = gerador.gerar_relatorio(funcionario) +repositorio.salvar(funcionario) +print(relatorio) \ No newline at end of file diff --git a/respExercicio12.py b/respExercicio12.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio13.py b/respExercicio13.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio14.py b/respExercicio14.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio15.py b/respExercicio15.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio16.py b/respExercicio16.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio17.py b/respExercicio17.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio18.py b/respExercicio18.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio19.py b/respExercicio19.py new file mode 100644 index 0000000..e69de29 diff --git a/respExercicio20.py b/respExercicio20.py new file mode 100644 index 0000000..e69de29 From f55f72b8e7f90be2396434f3f01bfec727d0becf Mon Sep 17 00:00:00 2001 From: Carina Dalpino Date: Sun, 23 Nov 2025 17:47:05 -0300 Subject: [PATCH 7/7] =?UTF-8?q?Exerc=C3=ADcios=20atualizados?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .vscode/settings.json | 15 ++++++ Resposta_10.py | 25 ++++----- respExercicio01.py | 28 +++++----- respExercicio04.py | 30 ++++++----- respExercicio05.py | 3 +- respExercicio07.py | 8 +-- respExercicio09.py | 55 ++++++++++++-------- respExercicio11.py | 23 +++++---- respExercicio12.py | 42 +++++++++++++++ respExercicio13.py | 58 +++++++++++++++++++++ respExercicio14.py | 96 ++++++++++++++++++++++++++++++++++ respExercicio15.py | 56 ++++++++++++++++++++ respExercicio16.py | 51 ++++++++++++++++++ respExercicio17.py | 82 +++++++++++++++++++++++++++++ respExercicio18.py | 105 ++++++++++++++++++++++++++++++++++++++ respExercicio19.py | 69 +++++++++++++++++++++++++ respExercicio20.py | 58 +++++++++++++++++++++ tests/test_exercicio01.py | 4 +- 18 files changed, 732 insertions(+), 76 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..54ac0fd --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,15 @@ +{ + "python.analysis.autoImportCompletions": true, + "python.analysis.completeFunctionParens": true, + "python.analysis.supportAllPythonDocuments": true, + "python.analysis.diagnosticMode": "workspace", + "python.analysis.indexing": true, + "python.analysis.autoSearchPaths": true, + "python.analysis.extraPaths": ["."], + "editor.quickSuggestions": { + "other": true, + "comments": false, + "strings": false +}, +"editor.definitionLinkOpensInPeek": false +} diff --git a/Resposta_10.py b/Resposta_10.py index 6aaac59..5c5c048 100644 --- a/Resposta_10.py +++ b/Resposta_10.py @@ -1,21 +1,21 @@ -class Pessoa: # pessoa minuscula = Pessoa maiuscula +class Pessoa: def __init__(self, nome, idade): - self.nome = nome # pendente self. + self.nome = nome self.idade = idade - self.cpf = None # self.cpf = privado, não foi declarado no init, ficando como futuro atributo + self.cpf = None - def apresentar(self): # self): + def apresentar(self): return f"Olá, sou {self.nome}" class Estudante(Pessoa): def __init__(self, nome, idade, curso): - super().__init__(nome, idade) # nao precisa informar self.nome= nome + super().__init__(nome, idade) self.curso = curso self.notas = [] def adicionar_nota(self, nota): - if nota >= 0 and nota <= 10: + if 0 <= nota <= 10: self.notas.append(nota) def calcular_media(self): @@ -38,10 +38,11 @@ def apresentar(self): estudante = Estudante("Joao", 20, "Engenharia") professor = Professor("Dr. Silva", 45, "Computacao", 8000) -print(estudante.apresentar()) -print(professor.apresentar()) -estudante.adicionar_nota(8) -estudante.adicionar_nota(10) -print(f"Média do estudante: {estudante.calcular_media()}") + print(estudante.apresentar()) + print(professor.apresentar()) + + estudante.adicionar_nota(8) + estudante.adicionar_nota(10) -print(f"Salário do professor: {professor.salario}") + print(f"Média do estudante: {estudante.calcular_media()}") + print(f"Salário do professor: {professor.salario}") diff --git a/respExercicio01.py b/respExercicio01.py index 5990239..063d8e6 100644 --- a/respExercicio01.py +++ b/respExercicio01.py @@ -3,20 +3,24 @@ def __init__(self, nome, matricula, curso): self.nome = nome self.matricula = matricula self.curso = curso - - class Disciplina: - def __init__(self, nome_disciplina, codigo_disciplina, carga_horaria): - self.nome_disciplina = nome_disciplina - self.codigo_disciplina = codigo_disciplina - self.carga_horaria = carga_horaria - - + + +class Disciplina: + def __init__(self, nome, codigo, carga_horaria): + self.nome = nome + self.codigo = codigo + self.carga_horaria = carga_horaria + + +# Exemplos de uso Aluno1 = Aluno("Joao Silva", "2023001", "Engenharia de Software") Aluno2 = Aluno("Maria Santos", "2023002", "Ciencia da Computacao") -Disciplina1 = Aluno.Disciplina("Programação Orientada a Objetos", "POO101", 60) -Disciplina2 = Aluno.Disciplina("Estruturas de Dados", "ED202", 45) + +Disciplina1 = Disciplina("Programação Orientada a Objetos", "POO101", 60) +Disciplina2 = Disciplina("Estruturas de Dados", "ED202", 45) + print(f"Aluno: {Aluno1.nome}, Matrícula: {Aluno1.matricula}, Curso: {Aluno1.curso}") print(f"Aluno: {Aluno2.nome}, Matrícula: {Aluno2.matricula}, Curso: {Aluno2.curso}") -print(f"Disciplina: {Disciplina1.nome_disciplina}, Código: {Disciplina1.codigo_disciplina}, Carga Horaria: {Disciplina1.carga_horaria} horas") -print(f"Disciplina: {Disciplina2.nome_disciplina}, Código: {Disciplina2.codigo_disciplina}, Carga Horaria: {Disciplina2.carga_horaria} horas") +print(f"Disciplina: {Disciplina1.nome}, Código: {Disciplina1.codigo}, Carga Horaria: {Disciplina1.carga_horaria} horas") +print(f"Disciplina: {Disciplina2.nome}, Código: {Disciplina2.codigo}, Carga Horaria: {Disciplina2.carga_horaria} horas") diff --git a/respExercicio04.py b/respExercicio04.py index 133a007..df837dc 100644 --- a/respExercicio04.py +++ b/respExercicio04.py @@ -5,7 +5,7 @@ def __init__(self, nome, cpf, data_nascimento): self.data_nascimento = data_nascimento def apresentar(self): - return f"Olá, meu nome é {self.nome}, meu CPF é {self.cpf}" + return f"Olá, meu nome é {self.nome}, meu CPF é {self.cpf}" class Funcionario(Pessoa): @@ -13,21 +13,27 @@ def __init__(self, nome, cpf, data_nascimento, cargo): super().__init__(nome, cpf, data_nascimento) self.cargo = cargo + def apresentar(self): + return f"Olá, meu nome é {self.nome} e eu trabalho no cargo de {self.cargo}." + -class Tutor(Pessoa): - def __init__(self, nome, cpf, data_nascimento, atuacao): +class Professor(Pessoa): + def __init__(self, nome, cpf, data_nascimento, departamento): super().__init__(nome, cpf, data_nascimento) - self.atuacao = atuacao + self.departamento = departamento def apresentar(self): - super().apresentar() - return f"Olá, meu nome é {self.nome}, meu CPF é {self.cpf} e sou tutor na área de {self.atuacao}." + return f"Olá, meu nome é {self.nome}, sou professor no departamento de {self.departamento}." -# Testando as classes com polimorfismo -f1 = Funcionario("João Silva", "123.456.789-00", "01/01/1990", "Secretário") -t1 = Tutor("Maria Santos", "987.654.321-00", "15/05/1985", "Programação") +class Tutor(Professor): + def __init__(self, nome, cpf, data_nascimento, area_atuacao): + # o teste espera isso: departamento NÃO é pedido + super().__init__(nome, cpf, data_nascimento, departamento="Tutoria") + self.area_atuacao = area_atuacao -print(f1.apresentar()) -print(t1.apresentar()) - \ No newline at end of file + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, sou tutor na área de {self.area_atuacao} " + f"e pertenço ao departamento de {self.departamento}." + ) diff --git a/respExercicio05.py b/respExercicio05.py index a02f773..1535cdf 100644 --- a/respExercicio05.py +++ b/respExercicio05.py @@ -2,7 +2,8 @@ class Pessoa: def __init__(self, nome, cpf, data_nascimento): # def = criar self.nome = nome self.cpf = cpf - self.data_nascimento = data_nascimento + self.data_nascimento = data_nascimento + class Funcionario(Pessoa): def __init__(self, nome, cpf, data_nascimento, cargo, salario): diff --git a/respExercicio07.py b/respExercicio07.py index e97e230..444d355 100644 --- a/respExercicio07.py +++ b/respExercicio07.py @@ -31,7 +31,7 @@ def listar_alunos(self): print(f"- {a.nome} (Matrícula: {a.matricula})") print() -class secretaria: +class Secretaria: @staticmethod def inscrever_aluno(aluno, disciplina): if disciplina not in aluno.disciplinas_inscritas: @@ -46,9 +46,9 @@ def inscrever_aluno(aluno, disciplina): disciplina1 = Disciplina("POO", "POO001", 60) disciplina2 = Disciplina("Banco de Dados", "BD001", 80) - secretaria.inscrever_aluno(aluno1, disciplina1) - secretaria.inscrever_aluno(aluno1, disciplina2) - secretaria.inscrever_aluno(aluno2, disciplina1) + 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 diff --git a/respExercicio09.py b/respExercicio09.py index 10cadec..e91632a 100644 --- a/respExercicio09.py +++ b/respExercicio09.py @@ -5,7 +5,12 @@ def __init__(self, nome, matricula, curso): self.curso = curso def apresentar(self): - return f"Olá, meu nome é {self.nome}, minha matrícula é {self.matricula}." + return ( + f"Olá, meu nome é {self.nome}, " + f"sou aluno do curso de {self.curso} " + f"e minha matrícula é {self.matricula}." + ) + class Professor: def __init__(self, nome, departamento, salario): @@ -14,31 +19,37 @@ def __init__(self, nome, departamento, salario): self.salario = salario def apresentar(self): - return f"Olá, meu nome é {self.nome} e eu trabalho no departamento de {self.departamento}." + return ( + f"Olá, meu nome é {self.nome}, " + f"sou professor e trabalho no departamento de {self.departamento}." + ) + class Funcionario: - def __init__(self, nome, cpf, data_nascimento, setor, salario): - self.nome = nome - self.cpf = cpf - self.data_nascimento = data_nascimento - self.salario = salario - self.setor = setor + def __init__(self, nome, cpf, data_nascimento, setor, salario): + self.nome = nome + self.cpf = cpf + self.data_nascimento = data_nascimento + self.setor = setor + self.salario = salario - def apresentar(self): - return f"Olá, meu nome é {self.nome} e eu trabalho no setor de {self.setor}." - - #criando objetos + def apresentar(self): + return ( + f"Olá, meu nome é {self.nome}, " + f"sou funcionário e trabalho no setor de {self.setor}." + ) - -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) -] - - # polimorfismo -for pessoa in pessoas: - print(pessoa.apresentar()) + +# Demonstração de polimorfismo +if __name__ == "__main__": + 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", "Secretaria", 3000.0) + ] + + for pessoa in pessoas: + print(pessoa.apresentar()) #dúvidas????? diff --git a/respExercicio11.py b/respExercicio11.py index 054b06b..266fcc2 100644 --- a/respExercicio11.py +++ b/respExercicio11.py @@ -12,19 +12,20 @@ class GeradorRelatorio: def gerar_relatorio(self, funcionario): return f"Relatório: {funcionario.nome} - {funcionario.cargo} - R$ {funcionario.salario}" -class Repositoriofuncionario: +class RepositorioFuncionario: def salvar(self, funcionario): print(f"Salvando {funcionario.nome} no banco de dados...") -calculadora = CalculadoraSalario() -gerador = GeradorRelatorio() -calculadora = CalculadoraSalario() -gerador = GeradorRelatorio() -repositorio = Repositoriofuncionario() -funcionario = Funcionario("Ana Silva", 5000, "Desenvolvedor") +if __name__ == "__main__": + + calculadora = CalculadoraSalario() + gerador = GeradorRelatorio() + repositorio = RepositorioFuncionario() + funcionario = Funcionario("Ana Silva", 5000, "Desenvolvedor") + + salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500) + relatorio = gerador.gerar_relatorio(funcionario) + repositorio.salvar(funcionario) + print(relatorio) -salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500) -relatorio = gerador.gerar_relatorio(funcionario) -repositorio.salvar(funcionario) -print(relatorio) \ No newline at end of file diff --git a/respExercicio12.py b/respExercicio12.py index e69de29..d76f2bc 100644 --- a/respExercicio12.py +++ b/respExercicio12.py @@ -0,0 +1,42 @@ +from abc import ABC, abstractmethod + +class CalculadorDesconto(ABC): + @abstractmethod + def calcular(self, valor): + pass + + +class DescontoEstudante(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.90 # 10% + + +class DescontoFuncionario(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.85 # 15% + + +class DescontoVIP(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.80 # 20% + + +class ProcessadorPagamento: + def processar(self, valor, estrategia: CalculadorDesconto): + return estrategia.calcular(valor) + + +# Demonstração de extensão sem modificar código existente +class DescontoNetshoes(CalculadorDesconto): + def calcular(self, valor): + return valor * 0.75 # 25% + + +if __name__ == "__main__": + pagamento = ProcessadorPagamento() + valor_original = 1000.0 + + print("Estudante:", pagamento.processar(valor_original, DescontoEstudante())) + print("Funcionário:", pagamento.processar(valor_original, DescontoFuncionario())) + print("VIP:", pagamento.processar(valor_original, DescontoVIP())) + print("Netshoes:", pagamento.processar(valor_original, DescontoNetshoes())) diff --git a/respExercicio13.py b/respExercicio13.py index e69de29..517f191 100644 --- a/respExercicio13.py +++ b/respExercicio13.py @@ -0,0 +1,58 @@ +# SOLID - Liskov Substitution Principle (LSP) + +# SOLID - Liskov Substitution Principle (LSP) + +class Veiculo: + def __init__(self, velocidade_maxima): + self.velocidade = 0 + self.velocidade_maxima = velocidade_maxima + + def acelerar(self): + if self.velocidade + 20 <= self.velocidade_maxima: + self.velocidade += 20 + + def frear(self): + if self.velocidade - 10 >= 0: + self.velocidade -= 10 + + def get_velocidade(self): + return self.velocidade + + +class Carro(Veiculo): + def __init__(self): + super().__init__(180) + + +class Bicicleta(Veiculo): + def __init__(self): + super().__init__(50) + + +class Aviao(Veiculo): + def __init__(self): + super().__init__(900) + + +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") + + +if __name__ == "__main__": + + controlador = ControladorTrafego() + + carro = Carro() + bicicleta = Bicicleta() + aviao = Aviao() + + controlador.testar_veiculo(carro) + controlador.testar_veiculo(bicicleta) + controlador.testar_veiculo(aviao) + diff --git a/respExercicio14.py b/respExercicio14.py index e69de29..53162a1 100644 --- a/respExercicio14.py +++ b/respExercicio14.py @@ -0,0 +1,96 @@ +# Exercício 14 - Princípio da Segregação de Interface (ISP) + +## Objetivo +#Aplicar o quarto princípio SOLID - Interface Segregation Principle (ISP). + +## Descrição do Exercício +#Refatore interfaces "gordas" em interfaces menores e mais específicas. + +from abc import ABC, abstractmethod + +# Interfaces pequenas e específicas + +class Trabalhavel(ABC): + @abstractmethod + def trabalhar(self): + pass + +class Alimentavel(ABC): + @abstractmethod + def comer(self): + pass + +class Descansavel(ABC): + @abstractmethod + def dormir(self): + pass + +class Programavel(ABC): + @abstractmethod + def programar(self): + pass + +# Classes concretas ------------------------- + +class Desenvolvedor(Trabalhavel, Alimentavel, Descansavel, Programavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando como desenvolvedora.") + + 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á programando.") + +class Gerente(Trabalhavel, Alimentavel, Descansavel): + def __init__(self, nome): + self.nome = nome + + def trabalhar(self): + print(f"{self.nome} está trabalhando como gerente.") + + def comer(self): + print(f"{self.nome} está comendo.") + + def dormir(self): + print(f"{self.nome} está dormindo.") + +class Robo(Trabalhavel, Programavel): + def __init__(self, id_robo): + self.id_robo = id_robo + + def trabalhar(self): + print(f"Robo {self.id_robo} está executando tarefas.") + + def programar(self): + print(f"Robo {self.id_robo} está executando código.") + + # Demonstração de uso ---------------------- +if __name__ == "__main__": + + desenvolvedor = Desenvolvedor("Ana") + gerente = Gerente("Carlos") + robo = Robo("R202") + + print("----- Desenvolvedor -----") + desenvolvedor.trabalhar() + desenvolvedor.comer() + desenvolvedor.dormir() + desenvolvedor.programar() + + print("\n----- Gerente -----") + gerente.trabalhar() + gerente.comer() + gerente.dormir() + + print("\n----- Robo -----") + robo.trabalhar() + robo.programar() + + \ No newline at end of file diff --git a/respExercicio15.py b/respExercicio15.py index e69de29..221a4f2 100644 --- a/respExercicio15.py +++ b/respExercicio15.py @@ -0,0 +1,56 @@ +# Exercício 15 - Princípio da Inversão de Dependência (DIP) + +## Objetivo +#Aplicar o quinto princípio SOLID - Dependency Inversion Principle (DIP). + +## Descrição do Exercício +#Refatore código que depende de implementações concretas para depender de abstrações. + + +from abc import ABC, abstractmethod + + +#abstração +class ServicoNotificacao(ABC): + @abstractmethod + def enviar (self, mensagem): + pass + + #concretas + +class EmailService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando email com a mensagem: {mensagem}") + +class SMSService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando SMS com a mensagem: {mensagem}") + +class PushService(ServicoNotificacao): + def enviar(self, mensagem): + print(f"Enviando notificação push com a mensagem: {mensagem}") + +#Alta camada de depende da abstraçã, não da implementação concreta + +class NotificadorService: + def __init__(self, servico: ServicoNotificacao): + self.servico = servico #injeção de dependência + + def notificar(self, mensagem): + self.servico.enviar(mensagem) + + #demonstração +if __name__ == "__main__": + email_service = EmailService() + sms_service = SMSService() + push_service = PushService() + + notificador_email = NotificadorService(email_service) + notificador_sms = NotificadorService(sms_service) + notificador_push = NotificadorService(push_service) + + mensagem = "Bem-vindo ao sistema!" + + notificador_email.notificar(mensagem) + notificador_sms.notificar(mensagem) + notificador_push.notificar(mensagem) diff --git a/respExercicio16.py b/respExercicio16.py index e69de29..1244999 100644 --- a/respExercicio16.py +++ b/respExercicio16.py @@ -0,0 +1,51 @@ +class ProcessadorPagamento: + 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}" + + #crie o adaptador +class PayPalAdapter(ProcessadorPagamento): + def __init__(self, paypal_api): + self.paypal_api = paypal_api + + def processar_pagamento(self, valor, cartao): + return self.paypal_api.make_payment(valor, cartao) + +#Processador de pagamento interno (exemplo) + +class ProcessadorPagamentoInterno(ProcessadorPagamento): + def processar_pagamento(self, valor, cartao): + return f"Sistema Interno: Processando ${valor} no cartão {cartao}" + +#qualquer processador de pagamento pode ser usado aqui +class SistemaPagamento: + def __init__(self, processador: ProcessadorPagamento): + self.processador = processador + + def realizar_pagamento(self, valor, cartao): + resultado = self.processador.processar_pagamento(valor, cartao) + print(resultado) + +if __name__ == "__main__": + +#uso +# 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") + + + + diff --git a/respExercicio17.py b/respExercicio17.py index e69de29..f1eb4bb 100644 --- a/respExercicio17.py +++ b/respExercicio17.py @@ -0,0 +1,82 @@ +#Padrão Decorator (Estrutural) +#Crie um sistema de bebidas onde você pode adicionar ingredientes extras usando decorators. + +class Bebida: + def get_descricao(self): + return self.descricao() + pass + + def get_preco(self): + pass + +class Cafe(Bebida): + def get_descricao(self): + return "Café" + + def get_preco(self): + return 5.00 + +class Cha(Bebida): + def get_descricao(self): + return "Chá" + + def get_preco(self): + return 3.00 + + + #decorator base +class BebidaDecorator(Bebida): + def __init__(self, bebida: Bebida): + self.bebida = bebida + + def get_descricao(self): + return self.bebida.get_descricao() + + def get_preco(self): + return self.bebida.get_preco() + + + #decorators concretos +class Leite(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + ", com Leite" + + def get_preco(self): + return self.bebida.get_preco() + 2.00 + +class Acucar(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Açúcar" + + def get_preco(self): + return self.bebida.get_preco() + 0.50 + +class Chantilly(BebidaDecorator): + def get_descricao(self): + return self.bebida.get_descricao() + " com Chantilly" + + def get_preco(self): + return self.bebida.get_preco() + 3.00 + + #demostração de uso + +if __name__ == "__main__": + + # Bebida simples + cafe = Cafe() + print(f"{cafe.get_descricao()} - R$ {cafe.get_preco():.2f}") + + # Bebida com decorators + cafe_com_leite = Leite(cafe) + print(f"{cafe_com_leite.get_descricao()} - R$ {cafe_com_leite.get_preco():.2f}") + + # Múltiplos decorators + cafe_especial = Chantilly(Acucar(Leite(Cafe()))) + print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco():.2f}") + + + + + + + diff --git a/respExercicio18.py b/respExercicio18.py index e69de29..070d322 100644 --- a/respExercicio18.py +++ b/respExercicio18.py @@ -0,0 +1,105 @@ +#Implementar o padrão de projeto Facade para simplificar uma interface complexa. + +## Descrição do Exercício# +#Crie uma facade para simplificar o uso de um sistema complexo de home theater. + +class Amplificador: + def ligar(self): + print("Amplificador ligado.") + + def definir_volume(self, volume): + print(f"Volume definido para {volume}.") + + + def desligar(self): + print("Amplificador desligado.") + +class DVDPlayer: + def ligar(self): + print("DVD Player ligado.") + + def reproduzir(self, filme): + print(f"Reproduzindo filme: {filme}") + + def parar(self): + print("DVD Player parado.") + + def desligar(self): + print("DVD Player desligado.") + + +class Projetor: + def ligar(self): + print("Projetor ligado.") + + def modo_widescreen(self): + print("Projetor em modo widescreen.") + + def desligar(self): + print("Projetor desligado.") + +class Luzes: + def aumentar(self, nivel): + print(f"Luzes aumentadas para {nivel}%.") + + def diminuir(self, nivel): + print(f"Luzes diminuídas para {nivel}%.") + +class PipocaPopper: + def ligar(self): + print("Pipoca Popper ligado.") + + def fazer_pipoca(self): + print("Fazendo pipoca...") + +#Facade + +class HomeTheaterFacade: + def __init__(self): + self.amp = Amplificador() + self.dvd = DVDPlayer() + self.proj = Projetor() + self.luzes = Luzes() + self.pipoca = PipocaPopper() + + def assistir_filme(self, filme): + print("Preparando para assistir ao filme...") + + self.pipoca.ligar() + self.pipoca.fazer_pipoca() + + self.luzes.diminuir(10) + + self.proj.ligar() + self.proj.modo_widescreen() + + self.amp.ligar() + self.amp.definir_volume(5) + + self.dvd.ligar() + self.dvd.reproduzir(filme) + + print("Aproveite o filme!") + + def fim_filme(self): + print("Desligando o home theater...") + + self.amp.desligar() + self.dvd.parar() + self.dvd.desligar() + self.proj.desligar() + self.luzes.aumentar(100) + + print("Home theater desligado.") + +#Uso da Facade +if __name__ == "__main__": + home_theater = HomeTheaterFacade() + home_theater.assistir_filme("Matrix") + home_theater.fim_filme() + + + + + + diff --git a/respExercicio19.py b/respExercicio19.py index e69de29..8b36aae 100644 --- a/respExercicio19.py +++ b/respExercicio19.py @@ -0,0 +1,69 @@ +#Implementar o padrão de projeto Observer para notificação de mudanças de estado. + +## Descrição do Exercício +#Crie um sistema de notificações onde múltiplos observadores são notificados quando o estado de um objeto muda. + +from abc import ABC, abstractmethod + +# Classe Observador (Observer) +class Observer(ABC): + @abstractmethod + def update(self, message): + pass + +# Classe Sujeito (Subject) +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): + self.observers.remove(observer) + + def notificar_observers(self): + for observer in self.observers: + observer.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() + + # Observers Concretos + +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 DisplayCompleto(Observer): + def update(self, temperatura, umidade, pressao): + print(f"Display Completo: {temperatura}°C, {umidade}%, {pressao} hPa") + + +# Demonstração de uso +if __name__ == "__main__": + + estacao = EstacaoMeteorologica() + + # Criando displays + display_temp = DisplayTemperatura() + display_umidade = DisplayUmidade() + display_completo = DisplayCompleto() + + # Registrando observadores + estacao.adicionar_observer(display_temp) + estacao.adicionar_observer(display_umidade) + estacao.adicionar_observer(display_completo) + + # Mudança de estado + estacao.definir_medicoes(25.5, 65.0, 1013.2) + estacao.definir_medicoes(27.0, 70.0, 1015.1) \ No newline at end of file diff --git a/respExercicio20.py b/respExercicio20.py index e69de29..82e4dcc 100644 --- a/respExercicio20.py +++ b/respExercicio20.py @@ -0,0 +1,58 @@ +from abc import ABC, abstractmethod + +# ----------------------------- +# Interface (Strategy) +# ----------------------------- +class EstrategiaFrete(ABC): + @abstractmethod + def calcular_frete(self, peso, distancia): + pass + + +# ----------------------------- +# Estratégias Concretas +# ----------------------------- +class FreteNormal(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 5.00 + (peso * 2.0) + (distancia * 0.1) + + +class FreteExpresso(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 15.00 + (peso * 3.0) + (distancia * 0.2) + + +class FreteEconomico(EstrategiaFrete): + def calcular_frete(self, peso, distancia): + return 2.00 + (peso * 1.0) + (distancia * 0.05) + + +# ----------------------------- +# Contexto (Calculadora de Frete) +# ----------------------------- +class CalculadoraFrete: + def __init__(self, estrategia: EstrategiaFrete): + self.estrategia = estrategia + + def definir_estrategia(self, nova_estrategia: EstrategiaFrete): + self.estrategia = nova_estrategia + + def calcular(self, peso, distancia): + return self.estrategia.calcular_frete(peso, distancia) + + +# ----------------------------- +# Demonstração de uso +# ----------------------------- +if __name__ == "__main__": + 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)}") diff --git a/tests/test_exercicio01.py b/tests/test_exercicio01.py index 3c9b02f..ac0b978 100644 --- a/tests/test_exercicio01.py +++ b/tests/test_exercicio01.py @@ -6,8 +6,8 @@ class TestExercicio01(unittest.TestCase): def setUp(self): try: - import prof_respExercicio01 - self.module = prof_respExercicio01 + import respExercicio01 + self.module = respExercicio01 except ImportError: self.fail("Arquivo respExercicio01.py não encontrado")