Bruk programmering til å modellere og utforske naturfaglige fenomener.
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
# 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/sMatematiske operatorar:
| Operator | Tyding | Døme |
|---|---|---|
| + | Addisjon | 5 + 3 = 8 |
| - | Subtraksjon | 5 - 3 = 2 |
| Multiplikasjon | 5 3 = 15 | |
| / | Divisjon | 5 / 2 = 2.5 |
| Potens | 5 2 = 25 | |
| // | Heiltalsdivisjon | 5 // 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: 4Lag eit program som bereknar energien til ein foton gitt bølgjelengda, og omvendt.
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 eVForklaring: Grønt lys med bølgjelengd 550 nm har ein fotonenergi på ca. 2.26 eV.
Skriv eit program som bereknar fart (v), gitt avstand (s) og tid (t). Test programmet med s = 150 m og t = 12 s.
# 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}") # 100While-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 elementSkriv eit program som bereknar gjennomsnittleg temperatur frå ei liste med målingar: [18.5, 19.2, 20.1, 18.8, 19.5]
temperatur = 25
if temperatur > 30:
print("Varmt!")
elif temperatur > 20:
print("Behagelig")
elif temperatur > 10:
print("Kjølig")
else:
print("Kaldt!")Samanlikningsoperatorar:
| Operator | Tyding |
|---|---|
| == | 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.")| Operator | Tyding |
|---|---|
| and | Begge må vere sanne |
| or | Minst éin må vere sann |
| not | Snur sann til usann |
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.
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)
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:
| Kode | Tyding |
|---|---|
| '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 bildeLag 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å
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.
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.