diff --git a/README.md b/README.md
index 52ee7e3..16717a7 100644
--- a/README.md
+++ b/README.md
@@ -11,16 +11,19 @@ Proporcionar aos estudantes uma experiência prática e progressiva dos conceito
 ### Fundamentos de POO
 
 #### Classes e Objetos
+
 - **Classe**: Um modelo ou template que define a estrutura e comportamento de objetos. É como um "molde" que especifica quais atributos (dados) e métodos (funções) os objetos terão.
 - **Objeto**: Uma instância específica de uma classe. É a materialização concreta do modelo definido pela classe.
 - **Instanciação**: O processo de criar um objeto a partir de uma classe usando o operador de chamada `()`.
 
 #### Construtores
+
 - **Método `__init__()`**: Método especial chamado automaticamente quando um objeto é criado. Responsável por inicializar os atributos do objeto.
 - **Parâmetros do Construtor**: Valores passados durante a criação do objeto para configurar seu estado inicial.
 - **Self**: Referência ao próprio objeto, usado para acessar atributos e métodos da instância.
 
 #### Atributos e Métodos
+
 - **Atributos de Instância**: Variáveis que pertencem a cada objeto específico, definidas com `self.atributo`.
 - **Atributos de Classe**: Variáveis compartilhadas por todas as instâncias da classe.
 - **Métodos de Instância**: Funções que operam sobre dados específicos de cada objeto.
@@ -30,17 +33,21 @@ Proporcionar aos estudantes uma experiência prática e progressiva dos conceito
 ### Encapsulamento
 
 #### Princípio do Encapsulamento
+
 O encapsulamento é um dos pilares fundamentais da POO que consiste em:
+
 - **Ocultar detalhes internos**: Proteger dados e implementação interna da classe
 - **Controlar acesso**: Definir como os dados podem ser acessados e modificados
 - **Manter integridade**: Garantir que o objeto sempre esteja em um estado válido
 
 #### Níveis de Visibilidade em Python
+
 - **Público**: Atributos e métodos acessíveis de qualquer lugar (`atributo`)
 - **Protegido**: Convenção para indicar uso interno, prefixo `_` (`_atributo`)
 - **Privado**: Dificultam acesso externo, prefixo `__` (`__atributo`)
 
 #### Properties e Getters/Setters
+
 - **@property**: Decorator que permite acessar métodos como se fossem atributos
 - **Getter**: Método para obter o valor de um atributo privado
 - **Setter**: Método para definir o valor de um atributo com validação
@@ -49,11 +56,13 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em:
 ### Herança
 
 #### Conceitos Fundamentais
+
 - **Classe Base (Pai/Superclasse)**: Classe que define características comuns
 - **Classe Derivada (Filha/Subclasse)**: Classe que herda e especializa a classe base
 - **Relação "é um"**: A herança representa uma relação hierárquica onde a subclasse "é um" tipo da superclasse
 
 #### Mecanismos de Herança
+
 - **Herança Simples**: Uma classe herda de apenas uma classe pai
 - **Herança Múltipla**: Uma classe herda de múltiplas classes pai (suportada em Python)
 - **Método super()**: Função que permite chamar métodos da classe pai
@@ -63,11 +72,13 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em:
 ### Polimorfismo
 
 #### Definição e Tipos
+
 - **Polimorfismo**: Capacidade de objetos de diferentes classes responderem à mesma interface de forma específica
 - **Polimorfismo de Sobrescrita**: Mesmo método implementado diferentemente em classes relacionadas por herança
 - **Polimorfismo de Interface**: Objetos não relacionados que implementam os mesmos métodos
 
 #### Benefícios do Polimorfismo
+
 - **Flexibilidade**: Código que funciona com diferentes tipos de objetos
 - **Extensibilidade**: Facilita adição de novos tipos sem modificar código existente
 - **Manutenibilidade**: Reduz acoplamento entre componentes do sistema
@@ -75,16 +86,19 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em:
 ### Relacionamentos entre Objetos
 
 #### Composição
+
 - **Definição**: Relacionamento "tem um" onde um objeto contém outros objetos como partes integrantes
 - **Ciclo de Vida**: Os objetos componentes dependem do objeto principal
 - **Exemplo**: Um Carro "tem um" Motor - se o carro é destruído, o motor também é
 
 #### Agregação
+
 - **Definição**: Relacionamento "usa um" onde objetos existem independentemente mas se referenciam
 - **Ciclo de Vida**: Os objetos podem existir separadamente
 - **Exemplo**: Um Professor "leciona para" Alunos - professor e alunos existem independentemente
 
 #### Relacionamentos N:N (Muitos para Muitos)
+
 - **Definição**: Múltiplos objetos de um tipo se relacionam com múltiplos objetos de outro tipo
 - **Implementação**: Geralmente usando listas ou conjuntos para armazenar referências
 - **Exemplo**: Alunos podem estar matriculados em várias Disciplinas, e cada Disciplina pode ter vários Alunos
@@ -92,12 +106,14 @@ O encapsulamento é um dos pilares fundamentais da POO que consiste em:
 ### Recursos Avançados
 
 #### Métodos de Classe (@classmethod)
+
 - **Propósito**: Métodos que operam sobre a classe, não sobre instâncias específicas
 - **Primeiro Parâmetro**: `cls` (referência à classe)
 - **Uso Comum**: Factory methods (métodos fábrica) para criar objetos de formas específicas
 - **Acesso**: Podem ser chamados tanto pela classe quanto por instâncias
 
 #### Métodos Estáticos (@staticmethod)
+
 - **Propósito**: Funções relacionadas à classe mas que não precisam acessar dados da classe ou instância
 - **Parâmetros**: Não recebem `self` nem `cls` automaticamente
 - **Uso Comum**: Funções utilitárias relacionadas ao domínio da classe
@@ -205,12 +221,14 @@ Todos os exercícios são baseados em entidades e situações de uma **escola de
 Antes de submeter sua solução, você pode executar os testes localmente para verificar se sua implementação está correta:
 
 #### Pré-requisitos
+
 ```bash
 # Instale as dependências
 pip install -r requirements.txt
 ```
 
 #### Executando um teste específico
+
 ```bash
 # Para testar apenas o exercício 1
 python -m pytest tests/test_exercicio01.py -v
@@ -220,17 +238,20 @@ python -m pytest tests/test_exercicio02.py -v
 ```
 
 #### Executando todos os testes
+
 ```bash
 # Executa todos os testes do projeto
 python -m pytest tests/ -v
 ```
 
 #### Interpretando a saída dos testes
+
 - **PASSED**: Teste passou - sua implementação está correta
 - **FAILED**: Teste falhou - verifique a mensagem de erro
 - **ERROR**: Erro de importação - verifique o nome do arquivo
 
 #### Exemplo de saída de teste bem-sucedido
+
 ```
 tests/test_exercicio01.py::test_aluno_creation PASSED
 tests/test_exercicio01.py::test_disciplina_creation PASSED
@@ -238,6 +259,7 @@ tests/test_exercicio01.py::test_aluno_attributes PASSED
 ```
 
 #### Exemplo de saída com erro
+
 ```
 tests/test_exercicio01.py::test_aluno_creation FAILED
 E   AttributeError: 'Aluno' object has no attribute 'nome'
@@ -374,4 +396,4 @@ Para dúvidas sobre os exercícios:
 
 ---
 
-**Bons estudos!**
\ No newline at end of file
+**Bons estudos!**
diff --git a/Resposta_10.md b/Resposta_10.md
new file mode 100644
index 0000000..7fa277e
--- /dev/null
+++ b/Resposta_10.md
@@ -0,0 +1,96 @@
+# Relatório: Erros encontrados e correções - Exercício 10
+
+Abaixo estão os 7 erros identificados no código fornecido, a solução aplicada e o princípio de POO envolvido.
+
+---
+
+**Erro 1**: Nome da classe em minúsculas
+
+- Descrição: A classe foi declarada como `class pessoa:` (nome em minúsculas). Pela convenção do Python e boas práticas de POO, nomes de classes devem usar PascalCase.
+- Solução: Renomeada para `class Pessoa:`.
+- Conceito POO: Convenção de nomenclatura / legibilidade.
+
+---
+
+**Erro 2**: Atributo `nome` não atribuído ao objeto
+
+- Descrição: No construtor foi usado `nome = nome` (atribuição local), em vez de `self.nome = nome`. Isso não cria o atributo de instância.
+- Solução: Corrigido para `self.nome = nome` no `__init__` de `Pessoa`.
+- Conceito POO: Encapsulamento / inicialização de atributos de instância.
+
+---
+
+**Erro 3**: Uso incorreto / falta de inicialização do atributo `__cpf`
+
+- Descrição: Existia uma referência solta a `self.__cpf` no construtor (ou em algumas versões faltava a atribuição). Esse uso sem atribuição provoca `AttributeError` ou é ambíguo.
+- Solução: Inicializar o atributo privado corretamente: `self.__cpf = None`.
+- Conceito POO: Encapsulamento / atributos privados (name mangling). Inicialização correta de estado do objeto.
+
+---
+
+**Erro 4**: Método `apresentar` sem parâmetro `self`
+
+- Descrição: O método foi definido como `def apresentar():`, sem o parâmetro `self`, tornando impossível acessar `self.nome` dentro do método.
+- Solução: Alterado para `def apresentar(self):` e uso de `self.nome` para compor a string.
+- Conceito POO: Métodos de instância devem aceitar `self` como primeiro parâmetro.
+
+---
+
+**Erro 5**: Inicialização incorreta na subclasse `Estudante`
+
+- Descrição: A classe `Estudante` atribuía manualmente `self.nome = nome` e `self.idade = idade` invés de reutilizar o construtor da superclasse, perdendo lógica de inicialização e manutenção.
+- Solução: Usar `super().__init__(nome, idade)` dentro de `Estudante.__init__` para reaproveitar a inicialização da classe `Pessoa`.
+- Conceito POO: Herança e reutilização de construtores com `super()`.
+
+---
+
+**Erro 6**: Cálculo de média sem tratamento de casos especiais
+
+- Descrição: O cálculo `sum(self.notas) / len(self.notas)` assume que `self.notas` não está vazia; quando lista vazia, causa `ZeroDivisionError`.
+- Solução parcial/relacionada: implementar verificação antes da divisão (feito na solução final abaixo).
+- Conceito POO / Lógica: Validação de estado do objeto e tratamento de exceções.
+
+---
+
+**Erro 7**: Chamada de `calcular_media` com lista de notas vazia
+
+- Descrição: O teste no final do script chama `estudante.calcular_media()` sem ter adicionado nenhuma nota, resultando em `ZeroDivisionError` no código original.
+- Solução: Implementar proteção dentro de `calcular_media` para retornar `0.0` quando `self.notas` estiver vazia. Assim, a chamada é segura e o programa não levanta exceção inesperada. A implementação atual em `Resposta_10.py` é:
+
+```python
+    def calcular_media(self):
+        # Evita divisão por zero quando não há notas registradas
+        if not self.notas:
+            return 0.0
+        return sum(self.notas) / len(self.notas)
+```
+
+- Conceito POO / Lógica: Validação de estado do objeto; tratamento de entradas inválidas / ausência de dados.
+
+---
+
+## Observações sobre outras escolhas de design
+
+- O atributo `__cpf` foi mantido como privado (com double-underscore). Isso aplica name-mangling no Python e é adequado se a intenção for tornar o acesso direto mais difícil. Alternativamente, pode-se usar um único underscore (`_cpf`) ou implementar getters/setters para controlar acesso.
+- Ao retornar `0.0` para `calcular_media` quando não há notas, optamos por um comportamento seguro e previsível. Outra alternativa seria lançar uma exceção explícita (`ValueError`) para forçar o chamador a validar a existência de notas antes de pedir a média. A escolha depende do comportamento esperado pela aplicação.
+
+---
+
+## Resultado do teste
+
+Rodando o script `Resposta_10.py` após as correções, a saída é similar a:
+
+```
+Olá, sou João
+Olá, sou o professor Dr. Silva do departamento Computação
+Média do estudante: 0.0
+```
+
+Isso indica que o programa não produz exceções ao calcular a média quando não há notas (resultado `0.0`).
+
+---
+
+Arquivos entregues:
+
+- `Resposta_10.py` (corrigido)
+- `Resposta_10.md` (este relatório)
diff --git a/Resposta_10.py b/Resposta_10.py
new file mode 100644
index 0000000..352005c
--- /dev/null
+++ b/Resposta_10.py
@@ -0,0 +1,43 @@
+class Pessoa:
+    def __init__(self, nome, idade):
+        self.nome = nome
+        self.idade = idade
+    
+    def apresentar(self):
+        return f"Olá, sou {self.nome}"
+
+class Estudante(Pessoa):
+    def __init__(self, nome, idade, curso):
+        super().__init__(nome, idade)
+        self.curso = curso
+        self.notas = []
+    
+    def adicionar_nota(self, nota):
+        if nota >= 0 and nota <= 10:
+            self.notas.append(nota)
+    
+    def calcular_media(self):
+        # Evita divisão por zero quando não há notas registradas
+        if not self.notas:
+            return 0.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"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(8)
+estudante.adicionar_nota(7)
+
+print(f"Média do estudante: {estudante.calcular_media()}")  # Erro 7
\ No newline at end of file
diff --git a/exercicio_01.md b/exercicio_01.md
index af1b0fe..7194328 100644
--- a/exercicio_01.md
+++ b/exercicio_01.md
@@ -1,12 +1,14 @@
 # Exercício 01 - Modelagem Básica de Entidades
 
 ## Objetivo
+
 Praticar a criação de classes simples e inicialização de objetos.
 
 ## Descrição do Exercício
+
 Crie duas classes: **Aluno** e **Disciplina**.
 
-### Requisitos:
+### Requisitos
 
 1. **Classe Aluno** deve ter atributos para:
    - nome
@@ -23,12 +25,14 @@ Crie duas classes: **Aluno** e **Disciplina**.
 4. Instancie dois objetos de cada classe e imprima seus atributos.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio01.py` com a implementação das classes e a criação dos objetos solicitados.
 
 ## Exemplo de Saída Esperada
+
 ```
 Aluno: João Silva, Matrícula: 2023001, Curso: Engenharia de Software
 Aluno: Maria Santos, Matrícula: 2023002, Curso: Ciência da Computação
 Disciplina: Programação Orientada a Objetos, Código: POO001, Carga Horária: 60h
 Disciplina: Banco de Dados, Código: BD001, Carga Horária: 80h
-```
\ No newline at end of file
+```
diff --git a/exercicio_05.md b/exercicio_05.md
index 9165174..c84fd64 100644
--- a/exercicio_05.md
+++ b/exercicio_05.md
@@ -1,12 +1,14 @@
 # Exercício 05 - Herança e o Uso de super()
 
 ## Objetivo
+
 Entender e utilizar a função super() no construtor da classe filha.
 
 ## Descrição do Exercício
+
 Aprimore a classe **Funcionario** do exercício 4 utilizando corretamente a função `super()`.
 
-### Requisitos:
+### Requisitos
 
 1. No construtor (`__init__`) de **Funcionario**, utilize `super().__init__(...)` para inicializar os atributos herdados de **Pessoa**.
 
@@ -17,15 +19,18 @@ Aprimore a classe **Funcionario** do exercício 4 utilizando corretamente a fun
 4. Crie um objeto Funcionario e garanta que todos os atributos (herdados e próprios) foram inicializados corretamente.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio05.py` com a implementação aprimorada usando `super()`.
 
 ## 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
@@ -33,4 +38,4 @@ CPF: 111.222.333-44
 Data de Nascimento: 20/03/1988
 Cargo: Coordenadora
 Salário: R$ 4500.0
-```
\ No newline at end of file
+```
diff --git a/exercicio_06.md b/exercicio_06.md
index 4bad163..9999a36 100644
--- a/exercicio_06.md
+++ b/exercicio_06.md
@@ -1,12 +1,14 @@
 # Exercício 06 - Composição (Relacionamento "Tem Um")
 
 ## Objetivo
+
 Praticar o princípio da Composição, onde um objeto é feito de outros objetos.
 
 ## Descrição do Exercício
+
 Crie a classe **Curso** que será composta por objetos **Disciplina**.
 
-### Requisitos:
+### Requisitos
 
 1. Crie a classe **Curso** com atributos:
    - nome
@@ -22,9 +24,11 @@ Crie a classe **Curso** que será composta por objetos **Disciplina**.
 5. Adicione um método `carga_horaria_total()` que retorne a soma da carga horária de todas as disciplinas.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio06.py` com a implementação das classes e demonstração da composição.
 
 ## Exemplo de Uso
+
 ```python
 curso = Curso("Engenharia de Software", "ES001")
 disciplina1 = Disciplina("Programação Orientada a Objetos", "POO001", 60)
@@ -37,9 +41,10 @@ print(f"Carga horária total: {curso.carga_horaria_total()}h")
 ```
 
 ## Exemplo de Saída Esperada
+
 ```
 === Disciplinas do Curso: Engenharia de Software ===
 - Programação Orientada a Objetos (POO001)
 - Banco de Dados (BD001)
 Carga horária total: 140h
-```
\ No newline at end of file
+```
diff --git a/exercicio_08.md b/exercicio_08.md
index bbd7d0d..e132541 100644
--- a/exercicio_08.md
+++ b/exercicio_08.md
@@ -1,12 +1,14 @@
 # Exercício 08 - Método de Classe (@classmethod)
 
 ## Objetivo
+
 Entender o uso de métodos de classe para criar fábricas de objetos.
 
 ## Descrição do Exercício
+
 Crie a classe **Departamento** com métodos de classe para facilitar a criação de objetos.
 
-### Requisitos:
+### Requisitos
 
 1. Crie a classe **Departamento** com atributos:
    - nome
@@ -22,9 +24,11 @@ Crie a classe **Departamento** com métodos de classe para facilitar a criação
 5. Use esses métodos para criar dois departamentos distintos.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio08.py` com a implementação dos métodos de classe.
 
 ## Exemplo de Uso
+
 ```python
 dept_exatas = Departamento.criar_departamento_exatas("Matemática e Computação")
 dept_humanas = Departamento.criar_departamento_humanas("Letras e Filosofia")
@@ -34,7 +38,8 @@ print(f"Departamento: {dept_humanas.nome} - Sigla: {dept_humanas.sigla}")
 ```
 
 ## Exemplo de Saída Esperada
+
 ```
 Departamento: Matemática e Computação - Sigla: EXA
 Departamento: Letras e Filosofia - Sigla: HUM
-```
\ No newline at end of file
+```
diff --git a/exercicio_11.md b/exercicio_11.md
index 0c649e5..4b826ad 100644
--- a/exercicio_11.md
+++ b/exercicio_11.md
@@ -1,25 +1,28 @@
 # Exercício 11 - Princípio da Responsabilidade Única (SRP)
 
 ## Objetivo
+
 Aplicar o primeiro princípio SOLID - Single Responsibility Principle (SRP).
 
 ## Descrição do Exercício
+
 Refatore uma classe que viola o SRP, separando suas responsabilidades em classes distintas.
 
 ### Código Problemático:
+
 ```python
 class Funcionario:
     def __init__(self, nome, salario, cargo):
         self.nome = nome
         self.salario = salario
         self.cargo = cargo
-    
+
     def calcular_salario_liquido(self, descontos):
         return self.salario - descontos
-    
+
     def gerar_relatorio(self):
         return f"Relatório: {self.nome} - {self.cargo} - R$ {self.salario}"
-    
+
     def salvar_no_banco(self):
         print(f"Salvando {self.nome} no banco de dados...")
 ```
@@ -29,6 +32,7 @@ class Funcionario:
 1. **Identifique as responsabilidades** da classe Funcionario (dados, cálculos, relatórios, persistência).
 
 2. **Crie classes separadas** para cada responsabilidade:
+
    - **Funcionario**: apenas dados do funcionário
    - **CalculadoraSalario**: cálculos relacionados a salário
    - **GeradorRelatorio**: geração de relatórios
@@ -39,9 +43,11 @@ class Funcionario:
 4. **Demonstre o uso** das classes refatoradas.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio11.py` com a implementação refatorada seguindo o SRP.
 
 ## Exemplo de Uso
+
 ```python
 funcionario = Funcionario("Ana Silva", 5000.0, "Desenvolvedora")
 calculadora = CalculadoraSalario()
@@ -51,4 +57,4 @@ repositorio = RepositorioFuncionario()
 salario_liquido = calculadora.calcular_salario_liquido(funcionario, 500.0)
 relatorio = gerador.gerar_relatorio(funcionario)
 repositorio.salvar(funcionario)
-```
\ No newline at end of file
+```
diff --git a/exercicio_12.md b/exercicio_12.md
index 458d300..da2f877 100644
--- a/exercicio_12.md
+++ b/exercicio_12.md
@@ -1,12 +1,14 @@
 # Exercício 12 - Princípio Aberto/Fechado (OCP)
 
 ## Objetivo
+
 Aplicar o segundo princípio SOLID - Open/Closed Principle (OCP).
 
 ## Descrição do Exercício
+
 Implemente um sistema de cálculo de descontos que seja aberto para extensão mas fechado para modificação.
 
-### Requisitos:
+### Requisitos
 
 1. **Crie uma classe abstrata** `CalculadorDesconto` com método abstrato `calcular(valor)`.
 
@@ -20,9 +22,11 @@ Implemente um sistema de cálculo de descontos que seja aberto para extensão ma
 4. **Demonstre** como adicionar um novo tipo de desconto sem modificar código existente.
 
 ## Entrega
+
 Crie um arquivo chamado `respExercicio12.py` com a implementação seguindo o OCP.
 
 ## Exemplo de Uso
+
 ```python
 from abc import ABC, abstractmethod
 
@@ -42,7 +46,8 @@ print(f"Funcionário: R$ {valor_final2}")
 ```
 
 ## Exemplo de Saída Esperada
+
 ```
 Estudante: R$ 900.0
 Funcionário: R$ 850.0
-```
\ No newline at end of file
+```
diff --git a/respExercicio01.py b/respExercicio01.py
new file mode 100644
index 0000000..d1bb58e
--- /dev/null
+++ b/respExercicio01.py
@@ -0,0 +1,18 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas")
\ No newline at end of file
diff --git a/respExercicio02.py b/respExercicio02.py
new file mode 100644
index 0000000..948e25c
--- /dev/null
+++ b/respExercicio02.py
@@ -0,0 +1,42 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[]):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas")
\ No newline at end of file
diff --git a/respExercicio03.py b/respExercicio03.py
new file mode 100644
index 0000000..b81980a
--- /dev/null
+++ b/respExercicio03.py
@@ -0,0 +1,65 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[]):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+        
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000  # Isso levantará um ValueError
\ No newline at end of file
diff --git a/respExercicio04.py b/respExercicio04.py
new file mode 100644
index 0000000..d38b01e
--- /dev/null
+++ b/respExercicio04.py
@@ -0,0 +1,101 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[]):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.data_nascimento}"
+        
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+    def apresentar(self):
+        apresent = super().apresentar()
+        apresent += f", Cargo: {self.cargo}"
+        return apresent
+
+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):
+        apresent = super().apresentar()
+        apresent += f", Área de Atuação: {self.area_atuacao}"
+        return apresent
+        
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente")
+print(funcionario.apresentar())
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
\ No newline at end of file
diff --git a/respExercicio05.py b/respExercicio05.py
new file mode 100644
index 0000000..2655ebd
--- /dev/null
+++ b/respExercicio05.py
@@ -0,0 +1,103 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[]):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.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(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: R$ {self.salario:.2f}")
+
+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):
+        print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}")
+      
+
+        
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente", 7000)
+funcionario.exibir_dados()
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
+
+
+#---------------------------------------------------
diff --git a/respExercicio06.py b/respExercicio06.py
new file mode 100644
index 0000000..a90afd7
--- /dev/null
+++ b/respExercicio06.py
@@ -0,0 +1,127 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[]):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+class Disciplina:
+    def __init__ (self, nome, codigo, carga_horaria):
+        self.nome = nome
+        self.codigo = codigo
+        self.carga_horaria = carga_horaria
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.data_nascimento}"
+        
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+    def apresentar(self):
+        print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}")
+
+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):
+        print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}")
+      
+class Curso:
+    def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []):
+      self.nome = nome
+      self.codigo = codigo
+      self.disciplinas = disciplinas
+      
+    def adicionar_disciplina(self, disciplina: Disciplina):
+      if len(self.disciplinas) >= 2:
+        self.disciplinas = []
+      self.disciplinas.append(disciplina)
+    
+    def listar_disciplinas(self):
+      for disciplina in self.disciplinas:
+        print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}")
+        
+    def carga_horaria_total(self):
+      total = sum(disciplina.carga_horaria for disciplina in self.disciplinas)
+      return total
+        
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente")
+print(funcionario.apresentar())
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
+
+
+#---------------------------------------------------
+curso = Curso("Engenharia de Software", "ES101")
+disc1 = Disciplina("Programação", "CS101", 60)
+disc2 = Disciplina("Banco de Dados", "CS102", 80)
+curso.adicionar_disciplina(disc1)
+curso.adicionar_disciplina(disc2)
+curso.listar_disciplinas()
+total_carga = curso.carga_horaria_total()
+print(f"Carga horária total do curso: {total_carga} horas")
\ No newline at end of file
diff --git a/respExercicio07.py b/respExercicio07.py
new file mode 100644
index 0000000..ea8b4fa
--- /dev/null
+++ b/respExercicio07.py
@@ -0,0 +1,158 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        self.disciplinas_inscritas = disciplinas_inscritas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+    def listar_disciplinas(self):
+        print("Disciplinas inscritas:\n")
+        for disciplina in self.disciplinas_inscritas:
+            print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}")
+      
+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):
+        print("Alunos inscritos na disciplina:\n")
+        for aluno in self.alunos_matriculados:
+            print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}")
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.data_nascimento}"
+        
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+    def apresentar(self):
+        print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}")
+
+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):
+        print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}")
+      
+class Curso:
+    def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []):
+      self.nome = nome
+      self.codigo = codigo
+      self.disciplinas = disciplinas
+      
+    def adicionar_disciplina(self, disciplina: Disciplina):
+      if len(self.disciplinas) >= 2:
+        self.disciplinas = []
+      self.disciplinas.append(disciplina)
+    
+    def listar_disciplinas(self):
+      for disciplina in self.disciplinas:
+        print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}")
+        
+    def carga_horaria_total(self):
+      total = sum(disciplina.carga_horaria for disciplina in self.disciplinas)
+      return total
+        
+class Secretaria:        
+    def inscrever_aluno(aluno: Aluno, disciplina: Disciplina):
+        aluno.disciplinas_inscritas.append(disciplina)
+        disciplina.alunos_matriculados.append(aluno)
+        print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.")
+        
+# Testando as classes criadas
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente")
+print(funcionario.apresentar())
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
+
+
+#---------------------------------------------------
+curso = Curso("Engenharia de Software", "ES101")
+disc1 = Disciplina("Programação", "CS101", 60)
+disc2 = Disciplina("Banco de Dados", "CS102", 80)
+curso.adicionar_disciplina(disc1)
+curso.adicionar_disciplina(disc2)
+curso.listar_disciplinas()
+total_carga = curso.carga_horaria_total()
+print(f"Carga horária total do curso: {total_carga} horas")
+
+#---------------------------------------------------
+aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software")
+aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software")
+disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70)
+disciplina2 = Disciplina("Redes de Computadores", "CS202", 50)
+Secretaria.inscrever_aluno(aluno1, disciplina1)
+Secretaria.inscrever_aluno(aluno1, disciplina2)
+Secretaria.inscrever_aluno(aluno2, disciplina1)
+aluno1.listar_disciplinas()
+disciplina1.listar_alunos()
+disciplina2.listar_alunos()
\ No newline at end of file
diff --git a/respExercicio08.py b/respExercicio08.py
new file mode 100644
index 0000000..4d83042
--- /dev/null
+++ b/respExercicio08.py
@@ -0,0 +1,190 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        self.disciplinas_inscritas = disciplinas_inscritas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+    def listar_disciplinas(self):
+        print("Disciplinas inscritas:\n")
+        for disciplina in self.disciplinas_inscritas:
+            print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}")
+      
+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):
+        print("Alunos inscritos na disciplina:\n")
+        for aluno in self.alunos_matriculados:
+            print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}")
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.data_nascimento}"
+        
+class Funcionario(Pessoa):
+    def __init__(self, nome, cpf, data_nascimento, cargo):
+        super().__init__(nome, cpf, data_nascimento)
+        self.cargo = cargo
+    def apresentar(self):
+        print(f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}")
+
+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):
+        print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}")
+      
+class Curso:
+    def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []):
+      self.nome = nome
+      self.codigo = codigo
+      self.disciplinas = disciplinas
+      
+    def adicionar_disciplina(self, disciplina: Disciplina):
+      if len(self.disciplinas) >= 2:
+        self.disciplinas = []
+      self.disciplinas.append(disciplina)
+    
+    def listar_disciplinas(self):
+      for disciplina in self.disciplinas:
+        print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}")
+        
+    def carga_horaria_total(self):
+      total = sum(disciplina.carga_horaria for disciplina in self.disciplinas)
+      return total
+        
+class Secretaria:        
+    def inscrever_aluno(aluno: Aluno, disciplina: Disciplina):
+        aluno.disciplinas_inscritas.append(disciplina)
+        disciplina.alunos_matriculados.append(aluno)
+        print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.")
+        
+class Departamento:
+    def __init__(self, nome, sigla, professores: list[Professor] = []):
+        self.nome = nome
+        self.sigla = sigla
+        self.professores: list[Professor] = professores
+        
+    @classmethod
+    def criar_departamento_exatas(self, nome):
+        dept = Departamento(nome, "EXA")
+        dept.sigla = "EXA"
+        return dept
+      
+    @classmethod
+    def criar_departamento_humanas(self, nome):
+        dept = Departamento(nome, "HUM")
+        dept.sigla = "HUM"
+        return dept
+    
+    def adicionar_professor(self, professor: Professor):
+        self.professores.append(professor)
+    
+    def listar_professores(self):
+        for professor in self.professores:
+            print(f"Professor: {professor.nome}, Departamento: {professor.departamento}")
+        
+# Testando as classes criadas
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente")
+print(funcionario.apresentar())
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
+
+
+#---------------------------------------------------
+curso = Curso("Engenharia de Software", "ES101")
+disc1 = Disciplina("Programação", "CS101", 60)
+disc2 = Disciplina("Banco de Dados", "CS102", 80)
+curso.adicionar_disciplina(disc1)
+curso.adicionar_disciplina(disc2)
+curso.listar_disciplinas()
+total_carga = curso.carga_horaria_total()
+print(f"Carga horária total do curso: {total_carga} horas")
+
+#---------------------------------------------------
+aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software")
+aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software")
+disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70)
+disciplina2 = Disciplina("Redes de Computadores", "CS202", 50)
+Secretaria.inscrever_aluno(aluno1, disciplina1)
+Secretaria.inscrever_aluno(aluno1, disciplina2)
+Secretaria.inscrever_aluno(aluno2, disciplina1)
+aluno1.listar_disciplinas()
+disciplina1.listar_alunos()
+disciplina2.listar_alunos()
+
+#---------------------------------------------------
+dept_exatas = Departamento.criar_departamento_exatas("Departamento de Ciências Exatas")
+dept_humanas = Departamento.criar_departamento_humanas("Departamento de Ciências Humanas")
+
+print(f"Departamento: {dept_exatas.nome}, Sigla: {dept_exatas.sigla}")
+print(f"Departamento: {dept_humanas.nome}, Sigla: {dept_humanas.sigla}")
\ No newline at end of file
diff --git a/respExercicio09.py b/respExercicio09.py
new file mode 100644
index 0000000..be1f85a
--- /dev/null
+++ b/respExercicio09.py
@@ -0,0 +1,207 @@
+class Aluno:
+    def __init__ (self, nome, matricula, curso, notas=[], disciplinas_inscritas: list = []):
+        self.nome = nome
+        self.matricula = matricula
+        self.curso = curso
+        self.notas = notas
+        self.disciplinas_inscritas = disciplinas_inscritas
+        
+    def adicionar_nota(self, nota):
+        if len(self.notas) >= 2:
+            print("Número máximo de notas atingido.")
+            self.notas = []
+        self.notas.append(nota)
+        
+    def calcular_media(self):
+        print(self.notas)
+        return sum(self.notas) / len(self.notas)
+      
+    def status(self):
+        media = self.calcular_media()      
+        return "Aprovado" if media >= 7 else "Reprovado"
+      
+    def listar_disciplinas(self):
+        print("Disciplinas inscritas:\n")
+        for disciplina in self.disciplinas_inscritas:
+            print(f"Disciplina: {disciplina.nome}, Código: {disciplina.codigo}")
+            
+    def apresentar(self):
+      return f"Olá, sou o aluno {self.nome} e estudo no curso {self.curso}."
+      
+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):
+        print("Alunos inscritos na disciplina:\n")
+        for aluno in self.alunos_matriculados:
+            print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}")
+
+class Professor:
+    def __init__ (self, nome, departamento, salario):
+        self.nome = nome
+        self.departamento = departamento
+        self._salario = salario
+        
+    @property
+    def salario(self):
+        return self._salario
+      
+    @salario.setter
+    def salario(self, novo_salario):
+        if novo_salario > 0: 
+          self._salario = novo_salario
+        else:
+          print("Salário deve ser positivo.")
+    
+    def apresentar(self):
+      return f"Olá, sou o professor {self.nome} do departamento de {self.departamento}."
+          
+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"Nome: {self.nome}, CPF: {self.cpf}, Data de Nascimento: {self.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 apresentar(self):
+        return f"=== Dados do Funcionário ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nCargo: {self.cargo}\nSalário: R$ {self.salario:.2f}"
+
+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):
+        print(f"=== Dados do Tutor ===\nNome: {self.nome}\nCPF: {self.cpf}\nData de Nascimento: {self.data_nascimento}\nÁrea de Atuação: {self.area_atuacao}")
+      
+class Curso:
+    def __init__ (self, nome, codigo, disciplinas: list[Disciplina] = []):
+      self.nome = nome
+      self.codigo = codigo
+      self.disciplinas = disciplinas
+      
+    def adicionar_disciplina(self, disciplina: Disciplina):
+      if len(self.disciplinas) >= 2:
+        self.disciplinas = []
+      self.disciplinas.append(disciplina)
+    
+    def listar_disciplinas(self):
+      for disciplina in self.disciplinas:
+        print(f"Disciplina: {disciplina.nome}\nCódigo: {disciplina.codigo}")
+        
+    def carga_horaria_total(self):
+      total = sum(disciplina.carga_horaria for disciplina in self.disciplinas)
+      return total
+        
+class Secretaria:        
+    def inscrever_aluno(aluno: Aluno, disciplina: Disciplina):
+        aluno.disciplinas_inscritas.append(disciplina)
+        disciplina.alunos_matriculados.append(aluno)
+        print(f"Aluno {aluno.nome} inscrito na disciplina {disciplina.nome}.")
+        
+class Departamento:
+    def __init__(self, nome, sigla, professores: list[Professor] = []):
+        self.nome = nome
+        self.sigla = sigla
+        self.professores: list[Professor] = professores
+        
+    @classmethod
+    def criar_departamento_exatas(self, nome):
+        dept = Departamento(nome, "EXA")
+        dept.sigla = "EXA"
+        return dept
+      
+    @classmethod
+    def criar_departamento_humanas(self, nome):
+        dept = Departamento(nome, "HUM")
+        dept.sigla = "HUM"
+        return dept
+    
+    def adicionar_professor(self, professor: Professor):
+        self.professores.append(professor)
+    
+    def listar_professores(self):
+        for professor in self.professores:
+            print(f"Professor: {professor.nome}, Departamento: {professor.departamento}")
+        
+# Testando as classes criadas
+aluno = Aluno("João Silva", "2023001", "Engenharia de Software")
+
+aluno.adicionar_nota(8)
+aluno.adicionar_nota(7)
+
+aluno_media = aluno.calcular_media()
+
+print(f"Média do aluno: {aluno_media:.2f}")
+aluno.status()
+
+disciplina = Disciplina("Programação Orientada a Objetos", "CS101", 60)
+
+print(f"Aluno: {aluno.nome}, Matrícula: {aluno.matricula}, Curso: {aluno.curso}")
+
+print(f"Disciplina: {disciplina.nome}, Código: {disciplina. codigo}, Carga Horária: {disciplina.carga_horaria} horas")
+
+#---------------------------------------------------
+prof = Professor("Dr. Carlos", "Ciência da Computação", 5000)
+print(f"Salário do professor: R$ {prof.salario:.2f}")
+prof.salario = 6000
+print(f"Novo salário do professor: R$ {prof.salario:.2f}")
+prof.salario = -1000
+
+
+#---------------------------------------------------
+funcionario = Funcionario("Ana Souza", "123.456.789-00", "15/04/1985", "Gerente", 7000)
+print(funcionario.apresentar())
+
+tutor = Tutor("Carlos Pereira", "987.654.321-00", "22/09/1990", "Matemática")
+print(tutor.apresentar())
+
+
+#---------------------------------------------------
+curso = Curso("Engenharia de Software", "ES101")
+disc1 = Disciplina("Programação", "CS101", 60)
+disc2 = Disciplina("Banco de Dados", "CS102", 80)
+curso.adicionar_disciplina(disc1)
+curso.adicionar_disciplina(disc2)
+curso.listar_disciplinas()
+total_carga = curso.carga_horaria_total()
+print(f"Carga horária total do curso: {total_carga} horas")
+
+#---------------------------------------------------
+aluno1 = Aluno("Maria Oliveira", "2023002", "Engenharia de Software")
+aluno2 = Aluno("Pedro Santos", "2023003", "Engenharia de Software")
+disciplina1 = Disciplina("Estruturas de Dados", "CS201", 70)
+disciplina2 = Disciplina("Redes de Computadores", "CS202", 50)
+Secretaria.inscrever_aluno(aluno1, disciplina1)
+Secretaria.inscrever_aluno(aluno1, disciplina2)
+Secretaria.inscrever_aluno(aluno2, disciplina1)
+aluno1.listar_disciplinas()
+disciplina1.listar_alunos()
+disciplina2.listar_alunos()
+
+#---------------------------------------------------
+dept_exatas = Departamento.criar_departamento_exatas("Departamento de Ciências Exatas")
+dept_humanas = Departamento.criar_departamento_humanas("Departamento de Ciências Humanas")
+
+print(f"Departamento: {dept_exatas.nome}, Sigla: {dept_exatas.sigla}")
+print(f"Departamento: {dept_humanas.nome}, Sigla: {dept_humanas.sigla}")
+
+#---------------------------------------------------
+pessoas = [
+    Aluno("João Silva", "2023001", "Engenharia de Software"),
+    Professor("Dr. Maria", "Computação", 8000),
+    Funcionario("Carlos Santos", "123.456.789-00", "01/01/1980", "Secretário", 7000),
+]
+
+for pessoa in pessoas:
+    print(pessoa.apresentar())
\ No newline at end of file
diff --git a/respExercicio1.py b/respExercicio1.py
new file mode 100644
index 0000000..e69de29
diff --git a/respExercicio11.py b/respExercicio11.py
new file mode 100644
index 0000000..33e3ee6
--- /dev/null
+++ b/respExercicio11.py
@@ -0,0 +1,27 @@
+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:Funcionario, descontos):
+        return funcionario.salario - descontos
+      
+class GeradorRelatorio:
+    def gerar_relatorio(self, funcionario:Funcionario):
+        return f"Relatório do Funcionário:\nNome: {funcionario.nome}\nCargo: {funcionario.cargo}\nSalário: {funcionario.salario}"
+      
+class RepositorioFuncionario:
+    def salvar(self, funcionario:Funcionario):
+        print(f"Funcionário {funcionario.nome} salvo no repositório.")
+        
+if __name__ == "__main__": 
+  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(funcionario)
\ No newline at end of file
diff --git a/respExercicio12.py b/respExercicio12.py
new file mode 100644
index 0000000..ed137b5
--- /dev/null
+++ b/respExercicio12.py
@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+
+class CalculadorDesconto():
+    @abstractmethod
+    def aplicar_desconto(self, valor: float) -> float:
+        pass
+      
+class DescontoEstudante(CalculadorDesconto):
+    def calcular(self, valor: float) -> float:
+        return valor * 0.9  # 20% de desconto para estudantes
+
+class DescontoFuncionario(CalculadorDesconto):
+    def calcular(self, valor: float) -> float:
+        return valor * 0.85  # 15% de desconto para funcionários
+      
+class DescontoVIP(CalculadorDesconto):
+    def calcular(self, valor: float) -> float:
+        return valor * 0.8  # 20% de desconto para clientes VIP
+
+class ProcessadorPagamento:
+    def processar(self, valor: float, estrategia_desconto) -> float:
+        return estrategia_desconto.calcular(valor)
+
+# 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}")
\ No newline at end of file
diff --git a/respExercicio13.py b/respExercicio13.py
new file mode 100644
index 0000000..469ba2a
--- /dev/null
+++ b/respExercicio13.py
@@ -0,0 +1,78 @@
+from abc import ABC
+from abc import abstractmethod
+
+class Veiculo(ABC):
+    @abstractmethod
+    def acelerar(self):
+        pass
+
+    @abstractmethod
+    def frear(self):
+        pass
+
+    @abstractmethod
+    def get_velocidade(self):
+        pass
+
+class Carro(Veiculo):
+    def __init__(self):
+        self.velocidade = 0
+
+    def acelerar(self):
+        self.velocidade += 10
+
+    def frear(self):
+        self.velocidade -= 10
+        if self.velocidade < 0:
+            self.velocidade = 0
+
+    def get_velocidade(self):
+        return self.velocidade
+
+class Bicicleta(Veiculo):
+    def __init__(self):
+        self.velocidade = 0
+
+    def acelerar(self):
+        self.velocidade += 5
+
+    def frear(self):
+        self.velocidade -= 5
+        if self.velocidade < 0:
+            self.velocidade = 0
+
+    def get_velocidade(self):
+        return self.velocidade
+
+class Aviao(Veiculo):
+    def __init__(self):
+        self.velocidade = 0
+
+    def acelerar(self):
+        self.velocidade += 50
+
+    def frear(self):
+        self.velocidade -= 50
+        if self.velocidade < 0:
+            self.velocidade = 0
+
+    def get_velocidade(self):
+        return self.velocidade
+
+
+def testar_veiculo(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")
+
+# Todos os veículos devem funcionar da mesma forma
+carro = Carro()
+bicicleta = Bicicleta()
+aviao = Aviao()
+
+testar_veiculo(carro)
+testar_veiculo(bicicleta)
+testar_veiculo(aviao)
\ No newline at end of file
diff --git a/respExercicio14.py b/respExercicio14.py
new file mode 100644
index 0000000..ec6999a
--- /dev/null
+++ b/respExercicio14.py
@@ -0,0 +1,74 @@
+from abc import ABC, abstractmethod
+
+# Classe Abstrata
+class Trabalhavel(ABC):
+    def __init__(self, nome):
+        self.nome = nome
+
+    @abstractmethod
+    def trabalhar(self):
+        pass
+
+class Alimentavel(ABC):
+    @abstractmethod
+    def comer(self):
+        pass
+      
+class Programavel(ABC):
+    @abstractmethod
+    def programar(self):
+        pass
+      
+class Descansavel(ABC):
+    @abstractmethod
+    def dormir(self):
+        pass
+
+
+# Classe Específica
+class Desenvolvedor(Trabalhavel, Alimentavel, Programavel, Descansavel):
+    def trabalhar(self):
+        print(f"{self.nome} está trabalhando.")
+
+    def comer(self):
+        print(f"{self.nome} está comendo.")
+
+    def programar(self):
+        print(f"{self.nome} está programando.")
+
+    def dormir(self):
+        print(f"{self.nome} está dormindo.")
+        
+class Gerente(Trabalhavel, Alimentavel, Descansavel):
+    def trabalhar(self):
+        print(f"{self.nome} está gerenciando.")
+
+    def comer(self):
+        print(f"{self.nome} está comendo.")
+
+    def dormir(self):
+        print(f"{self.nome} está dormindo.")
+
+class Robo(Trabalhavel, Programavel):
+    def trabalhar(self):
+        print(f"{self.nome} está trabalhando.")
+
+    def programar(self):
+        print(f"{self.nome} está programando.")
+
+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/respExercicio15.py b/respExercicio15.py
new file mode 100644
index 0000000..d04fd34
--- /dev/null
+++ b/respExercicio15.py
@@ -0,0 +1,33 @@
+class NotificacaoService:
+    def __init__(self, metodo_notificacao):
+        self.metodo_notificacao = metodo_notificacao
+
+    def notificar(self, mensagem):
+        self.metodo_notificacao.enviar(mensagem)
+        
+class EmailService:
+    def enviar(self, mensagem):
+        print(f"Enviando email com a mensagem: {mensagem}")
+        
+class SMSService:
+    def enviar(self, mensagem):
+        print(f"Enviando SMS com a mensagem: {mensagem}")
+        
+class PushService:
+    def enviar(self, mensagem):
+        print(f"Enviando notificação push com a mensagem: {mensagem}")
+
+# Diferentes implementações podem ser injetadas
+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
diff --git a/respExercicio16.py b/respExercicio16.py
new file mode 100644
index 0000000..5e6465e
--- /dev/null
+++ b/respExercicio16.py
@@ -0,0 +1,39 @@
+class ProcessadorPagamento:
+    def processar_pagamento(self, valor, conta):
+        raise NotImplementedError("Este método deve ser implementado pelas subclasses.")
+
+class ProcessadorPagamentoInterno(ProcessadorPagamento):
+    def processar_pagamento(self, valor, conta):
+        print(f"Processando pagamento interno de R${valor} para a conta {conta}.")
+
+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, paypal_api):
+        self.paypal_api = paypal_api
+
+    def processar_pagamento(self, valor, conta):
+        resultado = self.paypal_api.make_payment(valor, conta)
+        print(resultado)
+        
+class SistemaPagamento:
+    def __init__(self, processador: ProcessadorPagamento):
+        self.processador = processador
+
+    def realizar_pagamento(self, valor, conta):
+        self.processador.processar_pagamento(valor, conta)
+
+# 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
diff --git a/respExercicio17.py b/respExercicio17.py
new file mode 100644
index 0000000..8fcfd42
--- /dev/null
+++ b/respExercicio17.py
@@ -0,0 +1,47 @@
+class Bebida:
+    def __init__(self, descricao, preco):
+        self.descricao = descricao
+        self.preco = preco     
+    def get_descricao(self):
+        return self.descricao
+    def get_preco(self):
+        return self.preco 
+      
+# Decorator base
+class Cafe(Bebida):
+    def __init__(self):
+        super().__init__("Café", 5.0)
+        
+class Cha(Bebida):
+    def __init__(self):
+        super().__init__("Chá", 4.0)
+
+# Decorator com decorators
+class LeiteDecorator(Bebida):
+    def __init__(self, bebida):
+        descricao = bebida.get_descricao() + ", Leite"
+        preco = bebida.get_preco() + 1.5
+        super().__init__(descricao, preco)
+        
+class AcucarDecorator(Bebida):
+    def __init__(self, bebida):
+        descricao = bebida.get_descricao() + ", Açúcar"
+        preco = bebida.get_preco() + 0.5
+        super().__init__(descricao, preco)
+        
+class ChantillyDecorator(Bebida):
+    def __init__(self, bebida):
+        descricao = bebida.get_descricao() + ", Chantilly"
+        preco = bebida.get_preco() + 2.0
+        super().__init__(descricao, preco)
+# Bebida simples
+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 = ChantillyDecorator(AcucarDecorator(LeiteDecorator(Cafe())))
+print(f"{cafe_especial.get_descricao()} - R$ {cafe_especial.get_preco()}")
\ No newline at end of file
diff --git a/respExercicio18.py b/respExercicio18.py
new file mode 100644
index 0000000..f1af9e2
--- /dev/null
+++ b/respExercicio18.py
@@ -0,0 +1,71 @@
+class LigarFuncao:
+    def __init__(self, nome):
+        self.nome = nome
+
+    def ligar(self):
+        print(f"Ligando {self.nome}...")
+
+class Amplificador(LigarFuncao):
+    def __init__(self):
+        super().__init__("Amplificador")
+
+    def definir_volume(self, volume):
+        print(f"Definindo volume do Amplificador para {volume}.")
+        
+class DVDPlayer(LigarFuncao):
+    def __init__(self):
+        super().__init__("DVD Player")
+
+    def reproduzir(self, filme):
+        print(f"Reproduzindo filme: {filme}.")
+
+class Projetor(LigarFuncao):
+    def __init__(self):
+        super().__init__("Projetor")
+
+    def modo_widescreen(self):
+        print("Configurando Projetor para modo widescreen.")
+
+class Luzes(LigarFuncao):
+    def __init__(self):
+        super().__init__("Luzes")
+
+    def diminuir(self, nivel):
+        print(f"Diminuindo luzes para o nível {nivel}.")
+        
+class PipocaPopper(LigarFuncao):
+    def __init__(self):
+        super().__init__("Pipoca Popper")
+
+    def fazer_pipoca(self):
+        print("Fazendo pipoca.")
+
+class HomeTheaterFacade:
+    def __init__(self):
+        self.amplificador = Amplificador()
+        self.dvd_player = DVDPlayer()
+        self.projetor = Projetor()
+        self.luzes = Luzes()
+        self.pipoca_popper = PipocaPopper()
+
+    def assistir_filme(self, filme):
+        print("Preparando para assistir ao filme...")
+        self.pipoca_popper.ligar()
+        self.pipoca_popper.fazer_pipoca()
+        self.luzes.diminuir(10)
+        self.projetor.ligar()
+        self.projetor.modo_widescreen()
+        self.amplificador.ligar()
+        self.amplificador.definir_volume(5)
+        self.dvd_player.ligar()
+        self.dvd_player.reproduzir(filme)
+        print("Aproveite o filme!")
+
+    def fim_filme(self):
+        print("Desligando o Home Theater...")
+        print("Home Theater desligado.")
+
+# Usando o sistema diretamente        
+home_theater = HomeTheaterFacade()
+home_theater.assistir_filme("Inception")
+home_theater.fim_filme()
\ No newline at end of file
diff --git a/respExercicio19.py b/respExercicio19.py
new file mode 100644
index 0000000..4478f96
--- /dev/null
+++ b/respExercicio19.py
@@ -0,0 +1,52 @@
+class Observer:
+  def update(self, temperature, humidity, pressure):
+    pass
+
+class EstacaoMeteorologica:
+  def __init__(self):
+    self.observers = []
+    self.temperature = 0
+    self.humidity = 0
+    self.pressure = 0
+
+  def register_observer(self, observer):
+    self.observers.append(observer)
+
+  def remove_observer(self, observer):
+    self.observers.remove(observer)
+
+  def notify_observers(self):
+    for observer in self.observers:
+      observer.update(self.temperature, self.humidity, self.pressure)
+
+  def set_measurements(self, temperature, humidity, pressure):
+    self.temperature = temperature
+    self.humidity = humidity
+    self.pressure = pressure
+    self.notify_observers()
+  
+class DisplayTemperatura(Observer):
+  def update(self, temperature, humidity, pressure):
+    print(f"Temperatura Atual: {temperature}°C")
+    
+class DisplayUmidade(Observer):
+  def update(self, temperature, humidity, pressure):
+    print(f"Umidade Atual: {humidity}%")
+
+class DisplayCompleto(Observer):
+  def update(self, temperature, humidity, pressure):
+    print(f"Temperatura: {temperature}°C, Umidade: {humidity}%, Pressão: {pressure} hPa")
+    
+if __name__ == "__main__":
+  estacao = EstacaoMeteorologica()
+  
+  display_temp = DisplayTemperatura()
+  display_umid = DisplayUmidade()
+  display_completo = DisplayCompleto()
+  
+  estacao.register_observer(display_temp)
+  estacao.register_observer(display_umid)
+  estacao.register_observer(display_completo)
+  
+  estacao.set_measurements(25, 65, 1013)
+  estacao.set_measurements(28, 70, 1012)
\ No newline at end of file
diff --git a/respExercicio20.py b/respExercicio20.py
new file mode 100644
index 0000000..3652396
--- /dev/null
+++ b/respExercicio20.py
@@ -0,0 +1,39 @@
+class EstrategiaFrete:
+    def calcular_frete(self, peso, distancia):
+        raise NotImplementedError("Este método deve ser implementado pelas subclasses.")
+
+class FreteNormal(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return (peso * 2) + (distancia * 0.1)  + 5 # Exemplo de cálculo para frete normal
+    
+class FreteExpresso(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return (peso * 3) + (distancia * 0.2) + 15 # Exemplo de cálculo para frete expresso
+  
+class FreteEconomico(EstrategiaFrete):
+    def calcular_frete(self, peso, distancia):
+        return (peso * 1.0) + (distancia * 0.05) + 2  # Exemplo de cálculo para frete econômico
+  
+class CalculadoraFrete:
+    def __init__(self, estrategia: EstrategiaFrete):
+        self.estrategia = estrategia
+      
+    def definir_estrategia(self, estrategia: EstrategiaFrete):
+        self.estrategia = estrategia
+
+    def calcular(self, peso, distancia):
+        return self.estrategia.calcular_frete(peso, distancia)
+  
+# Exemplo de uso
+if __name__ == "__main__":
+    peso = 10  # em kg
+    distancia = 100  # em km
+
+    calculadora = CalculadoraFrete(FreteNormal())
+    print("Frete Normal: R$ ", calculadora.calcular(peso, distancia))
+
+    calculadora.definir_estrategia(FreteExpresso())
+    print("Frete Expresso: R$ ", calculadora.calcular(peso, distancia))
+
+    calculadora.definir_estrategia(FreteEconomico())
+    print("Frete Econômico: R$ ", calculadora.calcular(peso, distancia))
\ No newline at end of file