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. 

Introducing the challenge

BasicCalculator

FinancialCalculator

Software engineering principles

Options

Software Engineering

Not software engineering

Principles of Software Engineering

"""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)

Relative imports

# 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)

Absolute imports

Inheritance reuses code

Multilevel inheritance

Create the mortgage calculator class

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!


Learn to build a real-world application—a mortgage calculator—while mastering core software engineering principles. You’ll design modular Python code, use inheritance to expand functionality, and ensure quality through best practices like the DRY principle, PEP 8 compliance, and automated testing with pytest. By the end, you’ll have the skills to create efficient, maintainable, and scalable software solutions for real-world challenges.

This course offers a hands-on introduction to software engineering by guiding you through the development of a practical application: a mortgage calculator. You’ll learn how to calculate monthly payments based on key inputs like loan amount, interest rate, and loan term. Along the way, you’ll apply essential software engineering principles to create code that is efficient, modular, and maintainable.<br><br>
<h2>What You’ll Build</h2>
Using Python, you’ll design and implement a mortgage calculator that evolves from a basic tool into a robust solution. Starting with simple modules, you’ll expand the functionality using inheritance to create advanced calculators, including one that handles financial computations. This hands-on project will help you understand real-world software development techniques and how to structure scalable code.<br><br>
<h2>Techniques You’ll Use</h2>
Throughout the course, you’ll follow best practices like the DRY (Don’t Repeat Yourself) principle and modularity to organize your code effectively. You’ll adhere to PEP 8 standards, use tools like Pylint to maintain code quality and write automated tests with pytest to ensure your application’s reliability. By the end of the course, you’ll have the skills to design, implement, and test real-world software solutions with confidence.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Build real-world applications with Python—practice using OOP and software engineering principles to write clean and maintainable code.

Multilevel inheritance

Case Study: Building Software in Python

Uygulamalı interaktif egzersiz