Tilbake
1.5
Programmering og modellering

1.5 Programmering og modellering

Bruk programmering til å modellere og utforske naturfaglige fenomener.

55 min
6 oppgaver
ProgrammeringPythonModelleringSimulering
Du leser den tradisjonelle versjonen
Din fremgang i kapitlet
0 / 6 oppgaver

Programmering i naturfag - eit kraftig verktøy

Moderne naturvitskap er uløyseleg knytt til datamaskiner og programmering. Frå å føreseie vêr til å simulere klimaendringar, frå å analysere DNA-sekvensar til å modellere pandemiar - programmering gjer det mogleg å utforske fenomen som ville vore umogleg å studere på andre måtar.

Kvifor programmering i naturfag?
- Berekningar: Gjer tusenvis av berekningar på sekund
- Visualisering: Lag grafar og animasjonar av data
- Simulering: Test "kva viss"-scenario utan verkelege eksperiment
- Automatisering: Gjenta analysar med ulike verdiar
- Modellering: Bygg matematiske modellar av naturfenomen

I dette kapittelet skal du lære:
- Grunnleggjande programmering i Python
- Korleis bruke variablar, løkker og vilkår
- Korleis lage enkle naturvitskaplege modellar
- Korleis visualisere data med grafar
- Kritisk vurdering av programmodellar

Grunnleggjande Python - variablar og berekningar
Variablar er "boksar" som lagrar verdiar.

# Variabler med ulike datatyper
masse = 5.0          # Desimaltall (float)
antall = 10          # Heltall (int)
navn = "Natrium"     # Tekst (string)
er_metall = True     # Sann/usann (boolean)

# Beregninger
avstand = 100        # meter
tid = 10             # sekunder
fart = avstand / tid # beregning
print(f"Farten er {fart} m/s")  # Utskrift: Farten er 10.0 m/s

Matematiske operatorar:

OperatorTydingDøme
+Addisjon5 + 3 = 8
-Subtraksjon5 - 3 = 2
Multiplikasjon5 3 = 15
/Divisjon5 / 2 = 2.5
Potens5 2 = 25
//Heiltalsdivisjon5 // 2 = 2
%Rest (modulo)5 % 2 = 1

Nyttige funksjonar:
import math
math.sqrt(16)    # Kvadratrot: 4.0
math.pi          # Pi: 3.14159...
abs(-5)          # Absoluttverdi: 5
round(3.7)       # Avrunding: 4
✏️Døme: Berekne energi og bølgjelengd

Lag eit program som bereknar energien til ein foton gitt bølgjelengda, og omvendt.

Formelen: E = h · f = h · c / λ

Der:
- E = energi (Joule)
- h = Plancks konstant (6.626 × 10⁻³⁴ J·s)
- c = lyshastigheita (3 × 10⁸ m/s)
- λ = bølgjelengd (meter)

# Konstanter
h = 6.626e-34  # Plancks konstant (J·s)
c = 3e8        # Lyshastighet (m/s)

# Funksjon for å beregne energi fra bølgelengde
def energi_fra_bolgelengde(bolgelengde):
    """Beregner fotonenergi gitt bølgelengde i meter"""
    return h * c / bolgelengde

# Funksjon for å beregne bølgelengde fra energi
def bolgelengde_fra_energi(energi):
    """Beregner bølgelengde gitt fotonenergi i Joule"""
    return h * c / energi

# Test med synlig lys (grønt, ca. 550 nm)
bolgelengde = 550e-9  # 550 nm i meter
energi = energi_fra_bolgelengde(bolgelengde)
print(f"Bølgelengde: {bolgelengde*1e9} nm")
print(f"Energi: {energi:.3e} J")
print(f"Energi: {energi * 6.242e18:.2f} eV")  # Konverter til elektronvolt

# Resultat:
# Bølgelengde: 550.0 nm
# Energi: 3.614e-19 J
# Energi: 2.26 eV

Forklaring: Grønt lys med bølgjelengd 550 nm har ein fotonenergi på ca. 2.26 eV.

📝Oppgave 1

Skriv eit program som bereknar fart (v), gitt avstand (s) og tid (t). Test programmet med s = 150 m og t = 12 s.

Løkker - gjenta kode mange gonger
For-løkke - når du veit kor mange gonger:

# Tell fra 1 til 5
for i in range(1, 6):
    print(f"Telling: {i}")

# Summere tall
total = 0
for tall in [10, 20, 30, 40]:
    total = total + tall
print(f"Sum: {total}")  # 100

While-løkke - når du ikkje veit kor mange gonger:

# Halvering til under 1
verdi = 100
antall = 0
while verdi >= 1:
    print(f"Steg {antall}: {verdi}")
    verdi = verdi / 2
    antall = antall + 1
print(f"Antall halveringer: {antall}")

range()-funksjonen:

range(5)        # 0, 1, 2, 3, 4
range(1, 6)     # 1, 2, 3, 4, 5
range(0, 10, 2) # 0, 2, 4, 6, 8 (steg 2)

Lister - samle mange verdiar:

temperaturer = [18, 20, 22, 19, 21]
print(temperaturer[0])    # Første element: 18
print(len(temperaturer))  # Antall elementer: 5
temperaturer.append(23)   # Legg til element
📝Oppgave 2

Skriv eit program som bereknar gjennomsnittleg temperatur frå ei liste med målingar: [18.5, 19.2, 20.1, 18.8, 19.5]

Vilkår - ta val i koden
If-setningar lèt programmet ta avgjerder:

temperatur = 25

if temperatur > 30:
    print("Varmt!")
elif temperatur > 20:
    print("Behagelig")
elif temperatur > 10:
    print("Kjølig")
else:
    print("Kaldt!")

Samanlikningsoperatorar:

OperatorTyding
==Er lik
!=Er ikkje lik
>Større enn
<Mindre enn
>=Større enn eller lik
<=Mindre enn eller lik

Kombinere vilkår:
alder = 16
har_billett = True

if alder >= 15 and har_billett:
    print("Velkommen til filmen!")
elif alder < 15:
    print("Du er for ung.")
else:
    print("Du trenger billett.")
OperatorTyding
andBegge må vere sanne
orMinst éin må vere sann
notSnur sann til usann
✏️Døme: Modellere radioaktiv nedbryting

Lag eit program som simulerer radioaktiv nedbryting med halveringstid på 10 år, og plottar resultatet.

import matplotlib.pyplot as plt

# Startbetingelser
N0 = 1000           # Startmengde (antall atomer)
halveringstid = 10  # År

# Lister for å lagre data til plotting
tider = []
mengder = []

# Simuler i 50 år
for tid in range(51):
    # Formel: N = N0 * 0.5^(t/halveringstid)
    mengde = N0 * (0.5 ** (tid / halveringstid))
    tider.append(tid)
    mengder.append(mengde)

    # Skriv ut for hvert 10. år
    if tid % 10 == 0:
        print(f"År {tid}: {mengde:.1f} atomer ({mengde/N0*100:.1f}%)")

# Plot resultatet
plt.figure(figsize=(10, 6))
plt.plot(tider, mengder, 'b-', linewidth=2)
plt.axhline(y=500, color='r', linestyle='--', label='50% (1 halveringstid)')
plt.axhline(y=250, color='g', linestyle='--', label='25% (2 halveringstider)')
plt.xlabel('Tid (år)', fontsize=12)
plt.ylabel('Antall atomer', fontsize=12)
plt.title('Radioaktiv nedbrytning', fontsize=14)
plt.legend()
plt.grid(True)
plt.show()

Utskrift:

År 0: 1000.0 atomer (100.0%)
År 10: 500.0 atomer (50.0%)
År 20: 250.0 atomer (25.0%)
År 30: 125.0 atomer (12.5%)
År 40: 62.5 atomer (6.2%)
År 50: 31.2 atomer (3.1%)

Forklaring: Mengda halverast kvart 10. år. Etter 5 halveringstider (50 år) er berre 3.1% igjen.

📝Oppgave 3

Modifiser programmet for radioaktiv nedbryting til å finne ut kor mange år det tek før berre 1% av stoffet er igjen. (Start med 1000 einingar, halveringstid 10 år)

Visualisering med matplotlib
Matplotlib er eit bibliotek for å lage grafar og diagram.

import matplotlib.pyplot as plt

# Data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Linjediagram
plt.plot(x, y, 'b-', label='Lineær sammenheng')
plt.xlabel('X-verdier')
plt.ylabel('Y-verdier')
plt.title('Enkel graf')
plt.legend()
plt.grid(True)
plt.show()

Formatstrengar for utsjånad:

KodeTyding
'b-'Blå linje
'r--'Raud stipla
'go'Grøne sirklar
'k^'Svarte trekantar
'b-o'Blå linje med sirklar

Fleire nyttige funksjonar:
plt.figure(figsize=(10, 6))  # Størrelse på figur
plt.subplot(1, 2, 1)         # Flere grafer ved siden av hverandre
plt.scatter(x, y)            # Punktdiagram
plt.bar(x, y)                # Stolpediagram
plt.savefig('graf.png')      # Lagre som bilde
📝Oppgave 4

Lag eit program som simulerer eksponentiell folkevekst med 2% årleg vekst. Start med 1000 individ og simuler 50 år. Plott resultatet.

Oppsummering

Grunnleggjande Python:
- Variablar: Lagrar verdiar (tal, tekst, lister)
- Operatorar: +, -, , /, (potens)
-
Print: Skriv ut resultat

Løkker:
-
for: Når du veit antal gjentakingar
-
while: Når du ikkje veit antal gjentakingar
-
Lister: Samle mange verdiar

Vilkår:
-
if/elif/else: Ta avgjerder i koden
-
Samanlikningar: ==, !=, >, <, >=, <=
-
Logiske: and, or, not

Visualisering med matplotlib:
- plt.plot() for linjediagram
- plt.xlabel(), plt.ylabel(), plt.title() for tekst
- plt.grid(), plt.legend(), plt.show()

Modellering i naturfag:
- Radioaktiv nedbryting: N = N₀ · 0.5^(t/t½)
- Eksponentiell vekst: N = N₀ · (1+r)^t
- Fotonenergi: E = h·c/λ

Det viktigaste å hugse:*
- Programmering automatiserer berekningar
- Modellar er forenklingar - vurder alltid avgrensingar
- Visualisering gjer data lettare å forstå

📝Oppgave 5

Lag eit program som simulerer ein rovdyr-byttedyr-modell (Lotka-Volterra).

Startbetingelsar:
- Byttedyr (kaninar): 100
- Rovdyr (revar): 20
- Reproduksjonsrate kaninar: 0.1 per månad
- Dødsrate kaninar pga. revar: 0.01 per møte
- Dødsrate revar (utan mat): 0.1 per månad
- Reproduksjonsrate revar (med mat): 0.005 per fanga kanin

Simuler 100 månader og plott begge populasjonane.

📝Oppgave 6

Vurder følgjande programmodell kritisk:

# Modell for å forutsi karakterer basert på studietimer
studietimer = 10
karakter = studietimer * 0.5 + 1
print(f"Forventet karakter: {karakter}")

a) Kva føreseier modellen for 10 timar studering?
b) Kva er avgrensingane med denne modellen?
c) Korleis kunne modellen forbetrast?

Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.