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 - et kraftig verktøy

Moderne naturvitenskap er uløselig knyttet til datamaskiner og programmering. Fra å forutsi vær til å simulere klimaendringer, fra å analysere DNA-sekvenser til å modellere pandemier - programmering gjør det mulig å utforske fenomener som ville vært umulige å studere på andre måter.

Hvorfor programmering i naturfag?
- Beregninger: Gjør tusenvis av beregninger på sekunder
- Visualisering: Lag grafer og animasjoner av data
- Simulering: Test "hva hvis"-scenarier uten virkelige eksperimenter
- Automatisering: Repeter analyser med ulike verdier
- Modellering: Bygg matematiske modeller av naturfenomener

I dette kapittelet skal du lære:
- Grunnleggende programmering i Python
- Hvordan bruke variabler, løkker og betingelser
- Hvordan lage enkle naturvitenskapelige modeller
- Hvordan visualisere data med grafer
- Kritisk vurdering av programmodeller

Grunnleggende Python - variabler og beregninger
Variabler er "bokser" som lagrer verdier.

# 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 operatorer:

OperatorBetydningEksempel
+Addisjon5 + 3 = 8
-Subtraksjon5 - 3 = 2
Multiplikasjon5 3 = 15
/Divisjon5 / 2 = 2.5
Potens5 2 = 25
//Heltallsdivisjon5 // 2 = 2
%Rest (modulo)5 % 2 = 1

Nyttige funksjoner:
import math
math.sqrt(16)    # Kvadratrot: 4.0
math.pi          # Pi: 3.14159...
abs(-5)          # Absoluttverdi: 5
round(3.7)       # Avrunding: 4
✏️Eksempel: Beregne energi og bølgelengde

Lag et program som beregner energien til en foton gitt bølgelengden, og omvendt.

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

Der:
- E = energi (Joule)
- h = Plancks konstant (6.626 × 10⁻³⁴ J·s)
- c = lyshastigheten (3 × 10⁸ m/s)
- λ = bølgelengde (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ølgelengde 550 nm har en fotonenergi på ca. 2.26 eV.

📝Oppgave 1

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

Løkker - gjenta kode mange ganger
For-løkke - når du vet hvor mange ganger:

# 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 ikke vet hvor mange ganger:

# 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 verdier:

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 et program som beregner gjennomsnittlig temperatur fra en liste med målinger: [18.5, 19.2, 20.1, 18.8, 19.5]

Betingelser - ta valg i koden
If-setninger lar programmet ta beslutninger:

temperatur = 25

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

Sammenligningsoperatorer:

OperatorBetydning
==Er lik
!=Er ikke lik
>Større enn
<Mindre enn
>=Større enn eller lik
<=Mindre enn eller lik

Kombinere betingelser:
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.")
OperatorBetydning
andBegge må være sanne
orMinst én må være sann
notSnur sann til usann
✏️Eksempel: Modellere radioaktiv nedbrytning

Lag et program som simulerer radioaktiv nedbrytning med halveringstid på 10 år, og plotter 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: Mengden halveres hver 10. år. Etter 5 halveringstider (50 år) er bare 3.1% igjen.

📝Oppgave 3

Modifiser programmet for radioaktiv nedbrytning til å finne ut hvor mange år det tar før bare 1% av stoffet er igjen. (Start med 1000 enheter, halveringstid 10 år)

Visualisering med matplotlib
Matplotlib er et bibliotek for å lage grafer og diagrammer.

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

Formatstrenger for utseende:

KodeBetydning
'b-'Blå linje
'r--'Rød stiplet
'go'Grønne sirkler
'k^'Svarte trekanter
'b-o'Blå linje med sirkler

Flere nyttige funksjoner:
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 et program som simulerer eksponentiell befolkningsvekst med 2% årlig vekst. Start med 1000 individer og simuler 50 år. Plot resultatet.

Oppsummering

Grunnleggende Python:
- Variabler: Lagrer verdier (tall, tekst, lister)
- Operatorer: +, -, , /, (potens)
-
Print: Skriv ut resultater

Løkker:
-
for: Når du vet antall gjentakelser
-
while: Når du ikke vet antall gjentakelser
-
Lister: Samle mange verdier

Betingelser:
-
if/elif/else: Ta beslutninger i koden
-
Sammenligninger: ==, !=, >, <, >=, <=
-
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 nedbrytning: N = N₀ · 0.5^(t/t½)
- Eksponentiell vekst: N = N₀ · (1+r)^t
- Fotonenergi: E = h·c/λ

Det viktigste å huske:*
- Programmering automatiserer beregninger
- Modeller er forenklinger - vurder alltid begrensninger
- Visualisering gjør data lettere å forstå

📝Oppgave 5

Lag et program som simulerer en rovdyr-byttedyr-modell (Lotka-Volterra).

Startbetingelser:
- Byttedyr (kaniner): 100
- Rovdyr (rever): 20
- Reproduksjonsrate kaniner: 0.1 per måned
- Dødsrate kaniner pga. rever: 0.01 per møte
- Dødsrate rever (uten mat): 0.1 per måned
- Reproduksjonsrate rever (med mat): 0.005 per fanget kanin

Simuler 100 måneder og plot begge populasjonene.

📝Oppgave 6

Vurder følgende programmodell kritisk:

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

a) Hva forutsier modellen for 10 timers studier?
b) Hva er begrensningene med denne modellen?
c) Hvordan kunne modellen forbedres?

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.