1.5 Programmering og modellering
Bruk programmering til å modellere og utforske naturfaglige fenomener.
55 min
6 oppgaver
ProgrammeringPythonModelleringSimulering
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.
avstand = 100 # meter
tid = 10 # sekunder
fart = avstand / tid # beregning
print(f"Farten er {fart} m/s") # Utskrift: Farten er 10.0 m/s
`
``pythonVariabler 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:
Operator Betydning Eksempel + Addisjon 5 + 3 = 8 - Subtraksjon 5 - 3 = 2 Multiplikasjon 5 3 = 15 / Divisjon 5 / 2 = 2.5 Potens 5 2 = 25 // Heltallsdivisjon 5 // 2 = 2 % Rest (modulo) 5 % 2 = 1
Nyttige funksjoner:
python
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 / λ
def energifrabolgelengde(bolgelengde):
"""Beregner fotonenergi gitt bølgelengde i meter"""
return h c / bolgelengde
def bolgelengdefraenergi(energi):
"""Beregner bølgelengde gitt fotonenergi i Joule"""
return h c / energi
bolgelengde = 550e-9 # 550 nm i meter
energi = energifrabolgelengde(bolgelengde)
print(f"Bølgelengde: {bolgelengde1e9} nm")
print(f"Energi: {energi:.3e} J")
print(f"Energi: {energi 6.242e18:.2f} eV") # Konverter til elektronvolt
``
Der:
- E = energi (Joule)
- h = Plancks konstant (6.626 × 10⁻³⁴ J·s)
- c = lyshastigheten (3 × 10⁸ m/s)
- λ = bølgelengde (meter)
``pythonKonstanter
h = 6.626e-34 # Plancks konstant (J·s)
c = 3e8 # Lyshastighet (m/s)
Funksjon for å beregne energi fra bølgelengde
def energifrabolgelengde(bolgelengde):
"""Beregner fotonenergi gitt bølgelengde i meter"""
return h c / bolgelengde
Funksjon for å beregne bølgelengde fra energi
def bolgelengdefraenergi(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 = energifrabolgelengde(bolgelengde)
print(f"Bølgelengde: {bolgelengde1e9} 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:
total = 0
for tall in [10, 20, 30, 40]:
total = total + tall
print(f"Sum: {total}") # 100
`
``pythonTell 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:
python
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:
python
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:
python
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:
Kombinere betingelser:
`
``python
temperatur = 25
if temperatur > 30:
print("Varmt!")
elif temperatur > 20:
print("Behagelig")
elif temperatur > 10:
print("Kjølig")
else:
print("Kaldt!")
`
Sammenligningsoperatorer:
| Operator | Betydning |
|---|---|
| == | Er lik |
| != | Er ikke lik |
| > | Større enn |
| < | Mindre enn |
| >= | Større enn eller lik |
| <= | Mindre enn eller lik |
Kombinere betingelser:
`
python
alder = 16
harbillett = True
if alder >= 15 and harbillett:
print("Velkommen til filmen!")
elif alder < 15: print("Du er for ung.")
else:
print("Du trenger billett.")
``| Operator | Betydning |
|---|---|
| and | Begge må være sanne |
| or | Minst én må være sann |
| not | Snur sann til usann |
✏️Eksempel: Modellere radioaktiv nedbrytning
Lag et program som simulerer radioaktiv nedbrytning med halveringstid på 10 år, og plotter resultatet.
``python
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
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.
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
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()
`
``python
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:
Kode Betydning 'b-' Blå linje 'r--' Rød stiplet 'go' Grønne sirkler 'k^' Svarte trekanter 'b-o' Blå linje med sirkler
Flere nyttige funksjoner:
python
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) # Stolpediagramplt.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:
``python``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?
Oppsummering
I dette kapittelet har du lært:
- Programmering i naturfag: Hvordan Python brukes som verktøy for beregninger, visualisering og modellering av naturfaglige fenomener
- Grunnleggende Python: Variabler, matematiske operatorer, print-funksjonen og nyttige importerte funksjoner
- Løkker og lister: For-løkker, while-løkker og lister for å gjenta beregninger og samle data
- Betingelser: If/elif/else-setninger for å ta beslutninger i programmet
- Visualisering med matplotlib: Lage grafer og diagrammer for å presentere data
- Modellering: Simulere naturvitenskapelige fenomener som radioaktiv nedbrytning og befolkningsvekst
Nøkkelbegreper
| Begrep | Forklaring |
|---|---|
| Variabel | En «boks» som lagrer verdier (tall, tekst, lister) |
| For-løkke | Gjenta kode et bestemt antall ganger |
| While-løkke | Gjenta kode så lenge en betingelse er sann |
| Matplotlib | Python-bibliotek for å lage grafer og diagrammer |
| Modellering | Bruke programkode til å simulere naturfaglige fenomener |