Bekanta dig med uppgiften och börja bygga dina kalkylatorer från grunden, samtidigt som du repeterar viktiga principer inom objektorienterad programmering och mjukvaruutveckling – till exempel Don't Repeat Yourself (DRY)-principen.

Introduktion till utmaningen

BasicCalculator

FinancialCalculator

Principer för mjukvaruutveckling

Alternativ

Mjukvaruteknik

Inte mjukvaruteknik

Principer inom mjukvaruteknik

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

Relativa importer

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

Absoluta importer

Arv återanvänder kod

Flernivåarv

Skapa klassen för bolånekalkylatorn

Introduktion till fallstudien

Grunderna är på plats – nu är det dags att förfina dem! Fortsätt med att lägga till dokumentation och automatiserad testning, och bygg ut funktionaliteten ytterligare.

Dokumentera din nya klass

Använda docstrings

Använda dir()

Översikt över automatiserad testning

Använda doctest

Funktioner i doctest

Anpassad klass

Använda dir på en klass

Lägg till en metod i en ärvd klass

Skriv en Python-modul

Huvudkoden är skriven, så nu gäller det att se till att allt fungerar som det ska och följer bästa praxis. Lär dig att granska, refaktorisera och förbättra din kod, samt köra mer omfattande tester.

Underhållbarhet

Bra variabelnamn

Pylint

Granska och refaktorera kod

Kodgranskning

Refaktorera koden

Testning

Fördelar med enhetstestning

Testa koden med pytest

Grattis!


Lär dig bygga en verklig applikation – en bolånekalkylator – och bemästra centrala principer inom mjukvaruutveckling. Du utformar modulär Python-kod, använder arv för att utöka funktionaliteten och säkerställer kvalitet genom bästa praxis som DRY-principen, PEP 8 och automatiserad testning med pytest. När kursen är klar har du verktygen för att skapa effektiva, underhållsvänliga och skalbara programvarulösningar för verkliga utmaningar.

Den här kursen ger en praktisk introduktion till mjukvaruteknik genom att guida dig genom utvecklingen av en användbar applikation: en bolånekalkylator. Du kommer att lära dig hur du beräknar månatliga betalningar utifrån viktiga indata som lånebelopp, räntesats och lånetid. På vägen kommer du att tillämpa viktiga principer för mjukvaruutveckling för att skapa kod som är effektiv, modulär och lätt att underhålla.<br><br>
<h2>Vad du kommer att bygga</h2>
Med Python kommer du att designa och implementera en bolånekalkylator som utvecklas från ett enkelt verktyg till en robust lösning. Med enkla moduler som utgångspunkt bygger du ut funktionaliteten med arv för att skapa avancerade kalkylatorer, inklusive en som hanterar finansiella beräkningar. Detta praktiska projekt hjälper dig att förstå verkliga tekniker för mjukvaruutveckling och hur du strukturerar skalbar kod.<br><br>
<h2>Tekniker du kommer att använda</h2>
Under hela kursen kommer du att följa bästa praxis som DRY-principen (Don’t Repeat Yourself) och modularitet för att organisera din kod effektivt. Du kommer att följa PEP 8-standarder, använda verktyg som Pylint för att upprätthålla kodkvaliteten och skriva automatiserade tester med pytest för att säkerställa att din applikation är tillförlitlig. I slutet av kursen kommer du att ha färdigheterna att designa, implementera och testa verkliga mjukvarulösningar med självförtroende.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Bygg applikationer med Python—använd OOP och mjukvaruingenjörsprinciper för ren och underhållbar kod.

Fallstudie: Bygga programvara i Python

Bygg verkliga applikationer med Python—öva OOP och mjukvarutekniska principer för att skriva ren och underhållbar kod.

Flernivåarv

Fallstudie: Bygga programvara i Python

Interaktiv övning med praktiskt arbete