Seznám se se zadáním a začni budovat své kalkulačky od nuly – a přitom si zopakuješ důležité principy objektově orientovaného programování a softwarového inženýrství, jako je princip DRY (neopakuj se).

Představení výzvy

BasicCalculator

FinancialCalculator

Principy softwarového inženýrství

Možnosti

Softwarové inženýrství

Není softwarové inženýrství

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

Relativní importy

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

Absolutní importy

Dědičnost umožňuje znovupoužití kódu

Víceúrovňová dědičnost

Vytvoř třídu hypoteční kalkulačky

Úvod do případové studie

Základy máš za sebou – teď je čas je vylepšit! Pokračuj přidáváním dokumentace a automatizovaných testů a rozšiř funkcionalitu ještě dál.

Dokumentace nové třídy

Použití docstringu

Použití dir()

Přehled automatizovaného testování

Použití doctestu

Vlastnosti doctestu

Vlastní třída

Použití dir na třídě

Přidání metody do zděděné třídy

Vytvoření pythonového modulu

Hlavní kód je napsaný, takže teď je čas zkontrolovat, že vše funguje správně a odpovídá osvědčeným postupům. Naučíš se, jak kód revidovat, refaktorovat a vylepšovat, a také jak spouštět důkladnější testy.

Udržovatelnost kódu

Správné pojmenování proměnných

Pylint

Revize a refaktorování kódu

Code Review

Refaktoring kódu

Testování

Výhody unit testování

Otestuj kód pomocí pytest

Gratulujeme!


Nauč se vytvářet reálnou aplikaci – kalkulačku hypoték – a zároveň si osvojíš základní principy softwarového inženýrství. Budeš navrhovat modulární kód v Pythonu, využívat dědičnost k rozšíření funkcionality a dbát na kvalitu pomocí osvědčených postupů, jako jsou princip DRY, soulad s PEP 8 a automatizované testování s pytest. Na konci kurzu budeš mít dovednosti potřebné k vytváření efektivních, udržovatelných a škálovatelných softwarových řešení pro reálné problémy.

Tento kurz nabízí praktický úvod do softwarového inženýrství tím, že vás provede vývojem praktické aplikace: hypoteční kalkulačky. Naučíte se, jak vypočítat měsíční splátky na základě klíčových vstupů, jako jsou výše úvěru, úroková sazba a doba splatnosti úvěru. Cestou budete uplatňovat základní principy softwarového inženýrství, abyste vytvářeli kód, který je efektivní, modulární a snadno udržovatelný.<br><br>
<h2>Co vytvoříte</h2>
Pomocí Pythonu navrhnete a implementujete hypoteční kalkulačku, která se vyvine z jednoduchého nástroje v robustní řešení. Začnete s jednoduchými moduly a pomocí dědičnosti rozšíříte jejich funkčnost, abyste vytvořili pokročilé kalkulačky, včetně jedné, která zvládá finanční výpočty. Tento praktický projekt vám pomůže porozumět technikám vývoje softwaru v reálném světě a tomu, jak strukturovat škálovatelný kód.<br><br>
<h2>Techniky, které budete používat</h2>
V průběhu kurzu budeš dodržovat osvědčené postupy, jako je princip DRY (Don’t Repeat Yourself) a modularita, abys svůj kód efektivně uspořádal. Budete dodržovat standardy PEP 8, používat nástroje jako Pylint k udržení kvality kódu a psát automatizované testy pomocí pytestu, abyste zajistili spolehlivost své aplikace. Na konci kurzu budeš mít dovednosti navrhovat, implementovat a testovat softwarová řešení z reálného světa s jistotou.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Vytvářejte aplikace v Pythonu: procvičte OOP a principy softwarového inženýrství pro čistý kód.

Případová studie: Tvorba softwaru v Pythonu

Tvořte reálné aplikace v Pythonu—procvičte si OOP a principy softwarového inženýrství pro čistý a udržovatelný kód.

Víceúrovňová dědičnost

Případová studie: Tvorba softwaru v Pythonu

Interaktivní praktické cvičení