Zapoznaj się z założeniami projektu i zacznij budować kalkulatory od podstaw, przypominając sobie ważne zasady programowania obiektowego i inżynierii oprogramowania – w tym zasadę DRY (Don't Repeat Yourself).

Przedstawiamy wyzwanie

BasicCalculator

FinancialCalculator

Zasady inżynierii oprogramowania

Opcje

Inżynieria oprogramowania

Spoza inżynierii oprogramowania

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

Importy względne

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

Importy absolutne

Dziedziczenie pozwala na ponowne wykorzystanie kodu

Dziedziczenie wielopoziomowe

Tworzenie klasy kalkulatora hipotecznego

Wprowadzenie do studium przypadku

Podstawy masz już za sobą – czas je udoskonalić! Dodaj dokumentację i automatyczne testy, a następnie rozszerz funkcjonalność swojego kodu.

Dokumentowanie nowej klasy

Używanie docstringa

Używanie dir()

Przegląd testowania automatycznego

Używanie modułu doctest

Funkcje modułu doctest

Własna klasa

Użycie dir na klasie

Dodaj metodę do klasy dziedziczącej

Napisz moduł Pythona

Główny kod jest już gotowy – czas sprawdzić, czy wszystko działa poprawnie i jest zgodne z najlepszymi praktykami. Dowiedz się, jak przeglądać, refaktoryzować i ulepszać kod, a także przeprowadzać bardziej kompleksowe testy.

Łatwość utrzymania kodu

Stosowanie dobrych nazw zmiennych

Pylint

Przeglądanie i refaktoryzacja kodu

Przegląd kodu

Refaktoryzacja kodu

Testowanie

Zalety testowania jednostkowego

Testowanie kodu przy użyciu pytest

Gratulacje!

Utrzymywalność kodu


Naucz się budować prawdziwą aplikację – kalkulator kredytu hipotecznego – opanowując przy tym podstawowe zasady inżynierii oprogramowania. Zaprojektujesz modularny kod w Pythonie, użyjesz dziedziczenia do rozszerzania funkcjonalności i zadbasz o jakość, stosując najlepsze praktyki: zasadę DRY, zgodność z PEP 8 oraz automatyczne testowanie za pomocą pytest. Po ukończeniu kursu będziesz potrafić tworzyć wydajne, łatwe w utrzymaniu i skalowalne rozwiązania programistyczne.

Ten kurs oferuje praktyczne wprowadzenie do inżynierii oprogramowania, prowadząc Cię przez tworzenie praktycznej aplikacji: kalkulatora kredytu hipotecznego. Nauczysz się, jak obliczać miesięczne płatności na podstawie kluczowych danych, takich jak kwota kredytu, oprocentowanie i okres kredytowania. Po drodze zastosujesz kluczowe zasady inżynierii oprogramowania, aby tworzyć kod wydajny, modułowy i łatwy w utrzymaniu.<br><br>
<h2>Co zbudujesz</h2>
Korzystając z Pythona, zaprojektujesz i zaimplementujesz kalkulator kredytu hipotecznego, który rozwinie się z prostego narzędzia w solidne rozwiązanie. Zaczynając od prostych modułów, rozszerzysz funkcjonalność za pomocą dziedziczenia, aby tworzyć zaawansowane kalkulatory, w tym taki, który obsługuje obliczenia finansowe. Ten praktyczny projekt pomoże Ci zrozumieć techniki tworzenia oprogramowania stosowane w rzeczywistych warunkach oraz to, jak strukturyzować skalowalny kod.<br><br>
<h2>Techniki, których będziesz używać</h2>
Przez cały kurs będziesz stosować najlepsze praktyki, takie jak zasada DRY (Don’t Repeat Yourself) i modularność, aby skutecznie organizować swój kod. Będziesz przestrzegać standardów PEP 8, korzystać z narzędzi takich jak Pylint, aby utrzymać wysoką jakość kodu, oraz pisać zautomatyzowane testy z użyciem pytest, aby zapewnić niezawodność swojej aplikacji. Po ukończeniu kursu będziesz mieć umiejętności potrzebne do projektowania, wdrażania i testowania rzeczywistych rozwiązań programistycznych z pewnością siebie.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Twórz aplikacje w Pythonie, stosując OOP i zasady inżynierii oprogramowania dla czystego kodu.

Studium przypadku: tworzenie oprogramowania w Pythonie

Twórz praktyczne aplikacje w Pythonie — ćwicz OOP i zasady inżynierii oprogramowania, by pisać czysty, łatwy w utrzymaniu kod.

Dziedziczenie wielopoziomowe

Studium przypadku: tworzenie oprogramowania w Pythonie

Interaktywne ćwiczenie praktyczne