Get to know the brief and start building your calculators from scratch while recapping important object-oriented and software engineering principles such as the Don't Repeat Yourself (DRY) principle. 

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

Introduction to the Case Study

The basics are done, and now it's time to spruce them up! Continue with adding documentation and automated testing, and extend the functionality even further.

Documenting your new class

Using docstring

Using dir()

Overview of Automated Testing

Using doctest

Features of doctest

Custom Class

Using dir on a class

Add a method to an inherited class

Write a Python Module

The main code is written so now it's time to make sure everything works as it should and follows the best practices. Learn how to review, refactor, and improve your code, as well as run more comprehensive tests. 

Maintainability

Using good variable names

Pylint

Reviewing and refactoring code

Code Review

Refactor Code

Testing

Benefits of Unit Testing

Test the code using pytest

Congratulations!


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.

Importações absolutas

Estudo de Caso: Construindo Software em Python

exercicio interativo prático