Videregående programmering: gratis øving, teori og oppgaver

1. Objektorientering

Hva handler det om?

Objektorientert programmering (OOP) lar deg samle data og funksjonene som hører til dataene, i én enhet: et objekt. En klasse er oppskriften, og et objekt er en konkret instans av den. Som ingeniør bruker du dette til å modellere ting i den virkelige verden – en sensor, en komponent, en simulering – slik at koden speiler problemet og blir lettere å bygge videre på.

Begreper og formler

• Klasse vs objekt: klassen class Bil: er oppskriften, b = Bil() lager et objekt (en instans).
• Instansattributt: satt med self.x = ... i __init__, unikt for hvert objekt.
• Klassevariabel: satt rett i klassekroppen (utenfor metoder), delt av alle objekter av klassen, med mindre et objekt får sin egen versjon via self.navn = ....
• Magiske metoder (dunder): __init__ (konstruktør), __str__ (teksten som brukes av print(obj)), __eq__ (==), __len__ (len(obj)).
• @staticmethod: en metode uten self, hører logisk til klassen men trenger ikke noe objekt.
• @classmethod: tar cls i stedet for self og virker på klassen selv (f.eks. en alternativ konstruktør).
• Arv og overstyring: en underklasse kan definere en metode med samme navn som foreldreklassen; da brukes underklassens versjon når metoden kalles (polymorfi).

Slik løser du oppgavene

1. Finn ut om et attributt er en klassevariabel (delt) eller en instansvariabel (satt med self. i __init__).
2. Følg hvert objekt for seg: hvilke metoder kalles på hvilket objekt, og i hvilken rekkefølge?
3. Ved arv: sjekk hvilken klasses versjon av metoden som faktisk kjører (den mest spesifikke som er definert for det objektet).
4. Ved en klassevariabel: husk at en endring gjort via ett objekt kan påvirke alle andre, med mindre det lages en ny instansvariabel med samme navn.

Eksempel

class Konto:
    rente = 0.02          # klassevariabel, delt av alle kontoer
    def __init__(self, saldo):
        self.saldo = saldo  # instansvariabel

    def legg_til_rente(self):
        self.saldo += self.saldo * Konto.rente

a = Konto(1000)
b = Konto(500)
Konto.rente = 0.05
a.legg_til_rente()
print(round(a.saldo), round(b.saldo))

1. a og b får hver sin saldo (instansvariabler): 1000 og 500.
2. Konto.rente = 0.05 endrer klassevariabelen for alle objekter, siden ingen av dem har fått sin egen rente.
3. Bare a.legg_til_rente() kalles: $1000 + 1000\cdot 0{,}05 = 1050$.
4. b.saldo er uendret siden legg_til_rente aldri ble kalt på b.

Utskriften blir 1050 500.

Vanlige feil

• Å tro at en klassevariabel er privat for hvert objekt. Den er delt helt til noen setter en instansvariabel med samme navn.
• Å glemme self som første parameter i en vanlig metode.
• Å glemme parentes ved arv: class ElBil(Bil):, ikke class ElBil: Bil.
• Å blande sammen __init__ (kjøres automatisk når objektet lages) med en vanlig metode du selv må kalle.
• Å tro at @staticmethod har tilgang til self eller objektets attributter – det har den ikke.

Begreper i denne delen

Øv på objektorientering i appen →

2. Algoritmer og datastrukturer

Hva handler det om?

Når data blir store, er det ikke nok at koden virker – den må også være rask nok. Kompleksitetsanalyse (Big-O) gir deg et språk for å beskrive hvor mye arbeid en algoritme bruker når mengden data $n$ vokser, uavhengig av datamaskinen. Som ingeniør trenger du dette for å velge riktig datastruktur og algoritme før koden blir treg med ekte, store datasett – for eksempel måleserier med millioner av punkter.

Begreper og formler

• Amortisert kompleksitet: liste.append(x) er $O(1)$ i gjennomsnitt, selv om lista av og til må kopieres til et større minneområde.
• liste.insert(0, x) og liste.pop(0) er $O(n)$: alle elementene bak innsettingspunktet må flyttes.
• En rekursiv funksjon trenger et basistilfelle for å stoppe, ellers gir den RecursionError. Antall rekursive kall henger ofte sammen med hvor stor inndataen er.
• Inversjon: et par elementer som står i feil rekkefølge i en liste. Innsettingssortering bytter naboelementer helt til alle inversjoner er borte.
• Vanlige kompleksitetsklasser fra raskest til tregest: $O(1) < O(\log n) < O(n) < O(n\log n) < O(n^2) < O(2^n)$.
• To nøstede løkker som begge går $n$ ganger, gir til sammen $O(n^2)$ (kvadratisk).

Slik løser du oppgavene

1. Finn hvilken del av koden som gjentas flest ganger når $n$ vokser – det er den som dominerer kompleksiteten.
2. Tell løkker i dybden: én løkke over $n$ gir $O(n)$, en løkke inni en løkke gir $O(n^2)$.
3. For rekursjon: skriv opp kallene helt til basistilfellet er nådd, og tell dem.
4. For sortering: følg algoritmen steg for steg med en konkret liste, og noter hver sammenligning og hvert bytte.

Eksempel

Innsettingssortering bytter et element bakover til det står riktig, ett steg om gangen:

def sorter(a):
    bytter = 0
    for i in range(1, len(a)):
        j = i
        while j > 0 and a[j-1] > a[j]:
            a[j-1], a[j] = a[j], a[j-1]
            j -= 1
            bytter += 1
    return bytter

print(sorter([3, 1, 2]))

1. $i=1$: sammenlign $a[0]=3$ og $a[1]=1$. $3>1$, så de byttes: $[1, 3, 2]$, bytter = 1.
2. $i=2$: sammenlign $a[1]=3$ og $a[2]=2$. $3>2$, bytt: $[1, 2, 3]$, bytter = 2. Nå er $a[0]=1 \leq a[1]=2$, så den indre løkka stopper.
3. Lista er sortert, og funksjonen returnerer 2.

Utskriften blir 2, som er antall inversjoner i den opprinnelige lista (parene 3–1 og 3–2).

Vanlige feil

• Å tro at append og insert(0, x) er like raske. De er hhv. $O(1)$ og $O(n)$.
• Å glemme basistilfellet i en rekursiv funksjon.
• Å telle bare den ytre løkka og glemme at en indre løkke multipliserer arbeidet.
• Å blande sammen antall sammenligninger og antall bytter i en sorteringsalgoritme – de er ikke alltid like mange.
• Å tro at $O(n\log n)$ og $O(n^2)$ er omtrent like raske for store $n$. Forskjellen blir enorm.

Begreper i denne delen

Øv på algoritmer og datastrukturer i appen →

3. Numerikk med NumPy

Hva handler det om?

NumPy gir Python rask, vektorisert regning med tallarrayer – uunnværlig for ingeniørberegninger med store datasett, som måleserier og simuleringer. I tillegg lærer du numeriske grunnmetoder: Newtons metode for å finne nullpunkter til en funksjon, og Eulers metode for å løse differensialligninger tilnærmet, steg for steg. try/except lar programmet håndtere feil i data uten å krasje.

Begreper og formler

• np.array: regneoperatorene + - * / virker elementvis, ikke som matrisemultiplikasjon. Bruk @ eller np.dot for matriseprodukt.
• Boolsk indeksering: a[a > k] gir en ny array med bare de elementene som oppfyller betingelsen.
• Broadcasting: arrayer med lik form, eller der én dimensjon er 1, kan regnes sammen elementvis. Ulike og ukompatible former gir ValueError.
• np.mean, np.std, np.sum, a.min()/a.max(): statistikk over en array.
• Newtons metode: $x_{n+1} = x_n - f(x_n)/f'(x_n)$, følger tangenten ned til nullpunktet.
• Eulers eksplisitte metode: $y_{n+1} = y_n + h\,f(t_n, y_n)$ for $y' = f(t, y)$.
• try: ... except NavnPåFeil: ... fanger en bestemt feiltype. En generell except: fanger alt, også feil du egentlig burde ha oppdaget.

Slik løser du oppgavene

1. Se om koden regner elementvis eller er matriseregning – sjekk om det står * eller @/np.dot.
2. Med boolsk indeksering: regn ut betingelsen for hvert element først, og hent ut bare de som er True.
3. For Newton/Euler: sett inn tallene i formelen, ett steg om gangen, og hold styr på hvilken verdi som er $x_n$/$y_n$ i neste steg.
4. Sjekk formene til arrayene før du legger dem sammen – stemmer de, eller kan de broadcaste?

Eksempel

En sensor logger 5 målinger. Vi vil vite gjennomsnittet av målingene som er over 20:

import numpy as np
a = np.array([15, 24, 31, 18, 27])
over = a[a > 20]
print(over, round(over.mean(), 2))

1. a > 20 gir en boolsk array [False, True, True, False, True].
2. a[a > 20] bruker den til å hente ut verdiene der betingelsen er sann: [24, 31, 27].
3. Gjennomsnittet er $(24+31+27)/3 = 27{,}33$.

Utskriften blir [24 31 27] 27.33.

Vanlige feil

• Å forveksle * (elementvis) med @/np.dot (matrisemultiplikasjon).
• Å tro at boolsk indeksering gir True/False-verdier tilbake i stedet for de faktiske tallene.
• Å legge sammen arrayer med ukompatible former og bli overrasket over ValueError.
• Å bruke en generell except: som fanger og skjuler feil du egentlig burde ha oppdaget.
• Å dele på f'(x) uten å sjekke at den ikke er null eller veldig liten i Newtons metode.

Begreper i denne delen

Øv på numerikk med numpy i appen →