5.7 Styresystemer og regulering

La oss følge prosessen for et program som analyserer temperaturdata:

Steg 1 – Pseudokode:

LES temperaturer fra CSV-fil
BEREGN gjennomsnitt, min, maks
TELL dager med frost (under 0)
LAG linjediagram av temperaturene
LAGRE rapport til tekstfil

Steg 2 – Identifiser funksjoner:
- les_data(filnavn) – leser CSV og returnerer lister
- beregn_statistikk(temperaturer) – returnerer gjennomsnitt, min, maks
- lag_graf(datoer, temperaturer) – lager og viser grafen
- skriv_rapport(statistikk, filnavn) – skriver rapport til fil

Steg 3 – Kode:

import csv
import matplotlib.pyplot as plt

def les_data(filnavn):
    """Leser temperaturdata fra en CSV-fil."""
    datoer = []
    temperaturer = []
    with open(filnavn, "r") as fil:
        leser = csv.reader(fil)
        next(leser)  # Hopp over overskrift
        for rad in leser:
            datoer.append(rad[0])
            temperaturer.append(float(rad[1]))
    return datoer, temperaturer

def beregn_statistikk(temperaturer):
    """Beregner og returnerer statistikk som en dictionary."""
    return {
        "antall": len(temperaturer),
        "gjennomsnitt": sum(temperaturer) / len(temperaturer),
        "maks": max(temperaturer),
        "min": min(temperaturer),
        "frost": sum(1 for t in temperaturer if t < 0),
    }

def lag_graf(datoer, temperaturer):
    """Lager et linjediagram av temperaturene."""
    plt.figure(figsize=(12, 5))
    plt.plot(temperaturer, "b-", linewidth=1.5)
    plt.axhline(y=0, color="red", linestyle="--", alpha=0.5)
    plt.xlabel("Dag nr.")
    plt.ylabel("Temperatur (°C)")
    plt.title("Daglige temperaturer")
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig("temperaturgraf.png", dpi=150)
    plt.show()

def skriv_rapport(statistikk, filnavn):
    """Skriver en rapport med statistikk til fil."""
    with open(filnavn, "w") as fil:
        print("TEMPERATURRAPPORT", file=fil)
        print("=" * 30, file=fil)
        for nokkel, verdi in statistikk.items():
            if isinstance(verdi, float):
                print(f"{nokkel:15s}: {verdi:8.1f}", file=fil)
            else:
                print(f"{nokkel:15s}: {verdi:8d}", file=fil)

# Hovedprogram
datoer, temperaturer = les_data("temperaturer.csv")
statistikk = beregn_statistikk(temperaturer)
lag_graf(datoer, temperaturer)
skriv_rapport(statistikk, "temperaturrapport.txt")

print("Analyse fullført!")

Legg merke til at hovedprogrammet på slutten er svært lesbart – hver linje beskriver ett steg i analysen.

Her tester vi en funksjon som beregner karaktergjennomsnitt:

def beregn_snitt(karakterer):
    """Beregner gjennomsnittet av en liste med karakterer (1-6)."""
    if len(karakterer) == 0:
        return 0.0
    return sum(karakterer) / len(karakterer)

# === TESTER ===

# Test 1: Vanlig tilfelle
resultat = beregn_snitt([4, 5, 3, 6, 4])
forventet = 4.4
print(f"Test 1: {resultat} == {forventet}? {'OK' if abs(resultat - forventet) < 0.01 else 'FEIL'}")

# Test 2: Alle like
resultat = beregn_snitt([5, 5, 5])
forventet = 5.0
print(f"Test 2: {resultat} == {forventet}? {'OK' if abs(resultat - forventet) < 0.01 else 'FEIL'}")

# Test 3: Bare én karakter
resultat = beregn_snitt([6])
forventet = 6.0
print(f"Test 3: {resultat} == {forventet}? {'OK' if abs(resultat - forventet) < 0.01 else 'FEIL'}")

# Test 4: Tom liste (grensetilfelle)
resultat = beregn_snitt([])
forventet = 0.0
print(f"Test 4: {resultat} == {forventet}? {'OK' if abs(resultat - forventet) < 0.01 else 'FEIL'}")

Utskrift:

Test 1: 4.4 == 4.4? OK
Test 2: 5.0 == 5.0? OK
Test 3: 6.0 == 6.0? OK
Test 4: 0.0 == 0.0? OK

Legg merke til at vi bruker abs(resultat - forventet) < 0.01 for å sammenligne desimaltall – direkte sammenligning med == kan gi feil på grunn av avrunding.

Her er et komplett miniprosjekt med god struktur og dokumentasjon:

"""
BMI-kalkulator med statistikk

Programmet lar brukeren registrere BMI for flere personer,
beregner statistikk og lager et stolpediagram.

Forfatter: Elev Elevesen
Dato: 2024-03-20
"""

import matplotlib.pyplot as plt

def beregn_bmi(vekt_kg, hoyde_m):
    """Beregner BMI basert på vekt (kg) og høyde (m)."""
    return vekt_kg / (hoyde_m ** 2)

def bmi_kategori(bmi):
    """Returnerer BMI-kategori som tekst."""
    if bmi < 18.5:
        return "Undervekt"
    elif bmi < 25:
        return "Normalvekt"
    elif bmi < 30:
        return "Overvekt"
    else:
        return "Fedme"

def les_inn_data():
    """Leser inn navn, vekt og høyde for flere personer."""
    navn_liste = []
    bmi_liste = []

    print("BMI-kalkulator (skriv 'ferdig' for å avslutte)")
    while True:
        navn = input("Navn: ")
        if navn.lower() == "ferdig":
            break
        try:
            vekt = float(input("Vekt (kg): "))
            hoyde = float(input("Høyde (m): "))
            bmi = beregn_bmi(vekt, hoyde)
            navn_liste.append(navn)
            bmi_liste.append(bmi)
            print(f"  BMI: {bmi:.1f} ({bmi_kategori(bmi)})")
        except ValueError:
            print("  Ugyldig input – prøv igjen.")

    return navn_liste, bmi_liste

def vis_statistikk(navn_liste, bmi_liste):
    """Skriver ut en oppsummering av BMI-dataene."""
    print("\nOPPSUMMERING")
    print("=" * 35)
    for navn, bmi in zip(navn_liste, bmi_liste):
        print(f"  {navn:15s} BMI: {bmi:5.1f} ({bmi_kategori(bmi)})")
    print("-" * 35)
    print(f"  Gjennomsnitt: {sum(bmi_liste) / len(bmi_liste):.1f}")

def lag_diagram(navn_liste, bmi_liste):
    """Lager et stolpediagram over BMI-verdiene."""
    farger = ["green" if 18.5 <= b < 25 else "orange" for b in bmi_liste]
    plt.figure(figsize=(8, 5))
    plt.bar(navn_liste, bmi_liste, color=farger)
    plt.axhline(y=18.5, color="gray", linestyle="--", alpha=0.5)
    plt.axhline(y=25, color="gray", linestyle="--", alpha=0.5)
    plt.ylabel("BMI")
    plt.title("BMI-oversikt")
    plt.tight_layout()
    plt.savefig("bmi_oversikt.png", dpi=150)
    plt.show()

# === HOVEDPROGRAM ===
navn, bmi = les_inn_data()
if len(navn) > 0:
    vis_statistikk(navn, bmi)
    lag_diagram(navn, bmi)
else:
    print("Ingen data registrert.")

Programmet viser alle elementene i et godt prosjekt: filhode, docstrings, feilhåndtering, modulær oppbygging med funksjoner, og en tydelig hovedprogramdel.