Conheça o enunciado e comece a construir suas calculadoras do zero enquanto revisa princípios importantes de orientação a objetos e engenharia de software, como o princípio Don't Repeat Yourself (DRY). 

Apresentando o desafio

BasicCalculator

FinancialCalculator

Princípios de engenharia de software

Opções

Engenharia de Software

Não é engenharia de software

Princípios de Engenharia de Software

"""A module to implement the BasicCalcualtor.
"""
import numpy as np

class BasicCalculator:
    """A class for arithmetic operations on numbers    
    """
    def add(self, x, y):
        return np.add(x, y)

    def subtract(self, x, y):
        return np.subtract(x, y)

    def multiply(self, x, y):
        return np.multiply(x, y)

    def divide(self, x, y):
        return np.divide(x, y)

    def power(self, x, y):
        return np.power(x, y)

# Use a relative import to import BasicCalculator from basic_calculator in the same directory
from ____ import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

# Message
print("We'll write code for main.py in the next exercise.")

# Use a relative import to import BasicCalculator from basic_calculator in the same directory
from .basic_calculator import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

Importações relativas

# Relative import
from .basic_calculator import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

# Import the financial_calculator module in the calculators package using an absolute import
from ____ import FinancialCalculator

financial_calculator = FinancialCalculator()
monthly_interest = financial_calculator.monthly_interest(0.06)

# Print the monthly interest
print(____)

# Import the financial_calculator module in the calculators package using an absolute import
from calculators.financial_calculator import FinancialCalculator

financial_calculator = FinancialCalculator()
monthly_interest = financial_calculator.monthly_interest(0.06)

# Print the monthly interest
print(monthly_interest)

Importações absolutas

Herança reutiliza código

Herança multinível

Crie a classe de calculadora de hipoteca

Introdução ao estudo de caso

O básico está pronto — agora é hora de aprimorar! Siga adicionando documentação e testes automatizados e estenda ainda mais as funcionalidades.

Documentando sua nova classe

Usando docstring

Usando dir()

Visão geral de testes automatizados

Usando doctest

Recursos do doctest

Classe personalizada

Usando dir em uma classe

Adicionar um método a uma classe herdada

Escrevendo um módulo Python

O código principal está escrito, então agora é hora de garantir que tudo funcione como deveria e siga as melhores práticas. Aprenda a revisar, refatorar e melhorar seu código, além de executar testes mais abrangentes. 

Manutenibilidade

Usando bons nomes de variáveis

Pylint

Revisando e refatorando código

Revisão de código

Refatorar código

Testes

Benefícios dos testes de unidade

Teste o código usando pytest

Parabéns!

Mantenibilidade


Aprenda a criar uma aplicação do mundo real — uma calculadora de hipoteca — enquanto domina princípios essenciais de engenharia de software. Você vai projetar código Python modular, usar herança para expandir funcionalidades e garantir qualidade com boas práticas como o princípio DRY, conformidade com o PEP 8 e testes automatizados com pytest. Ao final, você terá as habilidades para criar soluções de software eficientes, fáceis de manter e escaláveis para desafios reais.

Este curso oferece uma introdução prática à engenharia de software, guiando você pelo desenvolvimento de um aplicativo prático: uma calculadora de hipotecas. Você vai aprender a calcular os pagamentos mensais com base em informações importantes, como valor do empréstimo, taxa de juros e prazo do empréstimo. Ao longo do caminho, você vai aplicar princípios essenciais de engenharia de software para criar um código eficiente, modular e fácil de manter.<br><br>
<h2>O que você vai construir</h2>
Usando Python, você vai criar e implementar uma calculadora de hipotecas que vai evoluir de uma ferramenta básica para uma solução robusta. Começando com módulos simples, você vai expandir a funcionalidade usando herança para criar calculadoras avançadas, incluindo uma que lida com cálculos financeiros. Esse projeto prático vai te ajudar a entender as técnicas reais de desenvolvimento de software e como estruturar um código escalável.<br><br>
<h2>Técnicas que você vai usar</h2>
Ao longo do curso, você vai seguir as melhores práticas, como o princípio DRY (Don't Repeat Yourself, ou Não se repita) e a modularidade, para organizar seu código de forma eficaz. Você vai seguir os padrões PEP 8, usar ferramentas como o Pylint para manter a qualidade do código e escrever testes automatizados com o pytest para garantir a confiabilidade da sua aplicação. Ao final do curso, você vai ter as habilidades necessárias para projetar, implementar e testar soluções de software do mundo real com confiança.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Desenvolva apps reais com Python: pratique POO e princípios de engenharia para um código limpo e sustentável.

Estudo de Caso: Construindo Software em Python

Crie aplicativos reais com Python — pratique usando OOP e princípios de engenharia de software para escrever código limpo e fácil de manter.

BasicCalculator

Estudo de Caso: Construindo Software em Python

Exercício interativo prático