1.3 Python for fysikk | Fysikk 1

Variablar, lister, løkker og if-testar i Python brukte på formlar og måledata: tabellar, gjennomsnitt, modellar og plott.

70 min

9 oppgaver

PythonVariablarLister og løkkerIf-testarMåledataPlotting

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 9 oppgaver

Python for fysikk

I fysikk gjer vi ofte den same utrekninga mange gonger: kinetisk energi ved fleire fartar, fart mellom mange målepunkt, ein formel for ei heil rekkje tider. Eit program gjer slike utrekningar raskt og utan reknefeil, og det kan teikne grafar av resultata.

Vi brukar Python. Programma i dette kapittelet er korte og brukar berre nokre få byggjesteinar:
- variablar som tek vare på tal, med einingar i ein kommentar
- lister med mange verdiar, til dømes måletider og posisjonar
- løkker som gjer det same for kvar verdi
- if-testar som berre gjer noko når eit vilkår er oppfylt
- plott av måledata og modellar

I kapittel 3.4 brukar vi dei same byggjesteinane til å rekne ut rørsle steg for steg når akselerasjonen ikkje er konstant.

Variablar og utrekningar

Ein variabel er eit namn på ein verdi. Python reknar berre med tal, så eininga skriv vi i ein kommentar etter #. Alle verdiar bør stå i SI-einingar, eller i same einingar gjennom heile programmet.

m = 0.50          # masse i kg
v = 12.0          # fart i m/s
Ek = 0.5 * m * v**2
print(Ek)         # 36.0

Rekneteikn

Python	Tyder	Eksempel
`+` `-`	pluss og minus	`v0 + a * t`
`*`	gonge	`m * g`
`/`	dele	`s / t`
`**`	opphøgd i	`v**2` er $v^2$
`sqrt(x)`	kvadratrot (krev `from math import sqrt`)	`sqrt(2 * h / g)`

Python følgjer vanleg rekkjefølgje: potensar først, så gonge og dele, så pluss og minus. Bruk parentesar når du er i tvil: s / (2 * a) er ikkje det same som s / 2 * a.

Utskrift

print skriv ut verdiar. Med ein f-streng bestemmer vi talet på desimalar: {Ek:.1f} skriv Ek med éin desimal.

print(f"Kinetisk energi: {Ek:.1f} J")      # Kinetisk energi: 36.0 J

Python brukar desimalpunktum, både i koden og i utskrifta. Svaret skriv vi med desimalkomma når vi fører det.

Liste og løkke

Ei liste er ei ordna samling verdiar, til dømes t = [0.0, 0.2, 0.4] . Elementa blir nummererte frå 0: t[0] er det første, t[-1] det siste, og len(t) er talet på element. Ei for-løkke gjer dei same linjene éin gong for kvar verdi: for v in farter: går gjennom lista, og for i in range(n): gir i = 0, 1, \dots, n - 1 . Ei while-løkke gjentek linjene så lenge eit vilkår er sant. Linjene som høyrer til løkka, har innrykk.

✏️Eksempel 1: Kinetisk energi ved fire fartar

Ein bil har masse 1200 kg. Lag eit program som reknar ut den kinetiske energien $E_k = \tfrac{1}{2}mv^2$ ved 30, 50, 80 og 110 km/h, og som skriv svara i kJ. Kor mange gonger så stor er energien ved 110 km/h som ved 30 km/h?

m = 1200                        # masse i kg
farter = [30, 50, 80, 110]      # km/h

for fart in farter:
    v = fart / 3.6              # m/s
    Ek = 0.5 * m * v**2         # J
    print(f"{fart} km/h: {Ek / 1000:.1f} kJ")

Utskrift:

30 km/h: 41.7 kJ
50 km/h: 115.7 kJ
80 km/h: 296.3 kJ
110 km/h: 560.2 kJ

$\frac{560{,}2 \text{ kJ}}{41{,}7 \text{ kJ}} = 13{,}4 \qquad \left(\frac{110}{30}\right)^2 = 13{,}4$

Svar: 41,7 kJ, 115,7 kJ, 296,3 kJ og 560,2 kJ. Ved 110 km/h er energien 13,4 gonger så stor som ved 30 km/h, fordi energien er proporsjonal med $v^2$ .

Lister og løkker

Lage ein tabell frå ein formel

Med ei løkke over ei liste av tider kan vi rekne ut ein formel for kvar tid og skrive resultatet som ein tabell. Formatet {t:5.1f} set av fem plassar og skriv éin desimal, så kolonnane står rett under kvarandre.

Byggje ei liste i løkka

append legg ein ny verdi bakarst i ei liste. Slik kan vi samle resultat undervegs:

farter = []                       # tom liste
for t in [0.0, 1.0, 2.0, 3.0]:
    farter.append(9.81 * t)
print(farter)                     # [0.0, 9.81, 19.62, 29.43]

Gå gjennom to lister samtidig

Høyrer verdiane i to lister saman, til dømes tid og posisjon frå dei same målingane, brukar vi nummeret i:

for i in range(len(t)):
    print(t[i], s[i])

Skal vi rekne med to verdiar som følgjer etter kvarandre, startar vi på i = 1 og brukar s[i] - s[i-1]. Då blir det éin verdi mindre enn talet på målingar.

Gjennomsnitt

sum(liste) legg saman alle verdiane, og sum(liste) / len(liste) er gjennomsnittet.

✏️Eksempel 2: Tabell for fritt fall

Ein stein blir sleppt frå ro. Utan luftmotstand er falle strekning $s = \tfrac{1}{2}gt^2$ og farten $v = gt$ . Lag eit program som skriv ein tabell over $s$ og $v$ for $t = 0$ , 0,5, 1,0, 1,5 og 2,0 s. Kor mykje aukar strekninga frå 1,0 s til 2,0 s?

g = 9.81                        # m/s^2
tider = [0.0, 0.5, 1.0, 1.5, 2.0]   # s

print("t (s)   s (m)   v (m/s)")
for t in tider:
    s = 0.5 * g * t**2
    v = g * t
    print(f"{t:5.1f} {s:7.2f} {v:8.2f}")

Utskrift:

t (s)   s (m)   v (m/s)
  0.0    0.00     0.00
  0.5    1.23     4.91
  1.0    4.91     9.81
  1.5   11.04    14.71
  2.0   19.62    19.62

$\frac{19{,}62 \text{ m}}{4{,}91 \text{ m}} = 4{,}0$

Svar: Strekninga aukar frå 4,91 m til 19,62 m, til fire gonger så mykje, fordi $s$ er proporsjonal med $t^2$ . Farten blir dobbelt så stor.

If-testar og while-løkker

If-test

Ein if-test køyrer linjene med innrykk berre når vilkåret er sant. Med elif og else vel programmet mellom fleire moglegheiter:

if v > 0:
    print("beveger seg i positiv retning")
elif v < 0:
    print("beveger seg i negativ retning")
else:
    print("i ro")

Samanlikningar blir skrivne <, >, <=, >=, == (er lik) og != (er ikkje lik).

While-løkke

Ei while-løkke blir brukt når vi ikkje veit på førehand kor mange gonger noko skal gjentakast. Ho går så lenge vilkåret er sant:

h = 2.0              # høgd i m
n = 0                # talet på sprett
while h > 0.5:
    h = 0.7 * h      # ballen når 70 % av førre høgd
    n = n + 1
print(n, round(h, 3))

Programmet skriv ut 4 0.48: etter tre sprett er høgda 0,686 m, som framleis er over 0,5 m, og etter fire sprett er ho 0,480 m. Noko inne i løkka må endre seg slik at vilkåret til slutt blir usant, elles går løkka for alltid.

Måledata, modellar og plott

Rekne med måledata

Måledata frå eit forsøk legg vi i lister. Frå posisjonar målte med jamne mellomrom finn vi gjennomsnittsfarten i kvart intervall:

$\bar v = \frac{\Delta s}{\Delta t} = \frac{s_i - s_{i-1}}{t_i - t_{i-1}}$

Modell frå ein formel

Ein modell er ein formel som skal beskrive målingane, til dømes

s = \tfrac{1}{2}at^2

for ei vogn som startar frå ro med konstant akselerasjon. Vi bestemmer konstanten

a

frå målingane, reknar ut modellen for mange tider og samanliknar.

Plotte

Biblioteket matplotlib teiknar grafar. Målingar teiknar vi som punkt ("o"), modellen som ei samanhengande kurve:

import matplotlib.pyplot as plt

plt.plot(t, s, "o", label="måling")
plt.plot(t_modell, s_modell, label="modell")
plt.xlabel("t (s)")
plt.ylabel("s (m)")
plt.legend()
plt.show()

Set alltid storleik og eining på aksane. Ligg målepunkta nær kurva utan eit system i avvika, beskriv modellen målingane godt.

✏️Eksempel 3: Vogn ned eit skråplan

Ei vogn blir sleppt frå ro øvst på eit skråplan, og posisjonen blir målt med ein rørslesensor:

$t$ (s)	0,0	0,2	0,4	0,6	0,8	1,0
$s$ (m)	0,000	0,050	0,190	0,435	0,765	1,205

a) Lag eit program som reknar ut gjennomsnittsfarten i kvart intervall. Kva viser fartane om rørsla?
b) Bruk

s = \tfrac{1}{2}at^2

til å rekne ut

a

for kvart målepunkt, og finn gjennomsnittet.

c) Plott målingane og modellen $s = \tfrac{1}{2}at^2$ i same koordinatsystem. Passar modellen?

a), b) og c) i eitt program. Frå

s = \tfrac{1}{2}at^2

a = \dfrac{2s}{t^2}

import matplotlib.pyplot as plt

t = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]               # s
s = [0.000, 0.050, 0.190, 0.435, 0.765, 1.205]   # m

for i in range(1, len(t)):
    v = (s[i] - s[i-1]) / (t[i] - t[i-1])
    print(f"{t[i-1]:.1f}-{t[i]:.1f} s: {v:.2f} m/s")

a_liste = []
for i in range(1, len(t)):
    a_liste.append(2 * s[i] / t[i]**2)
a = sum(a_liste) / len(a_liste)
print(f"a = {a:.2f} m/s^2")

t_modell = []
s_modell = []
for i in range(101):
    tm = i * 0.01
    t_modell.append(tm)
    s_modell.append(0.5 * a * tm**2)

plt.plot(t, s, "o", label="måling")
plt.plot(t_modell, s_modell, label="modell")
plt.xlabel("t (s)")
plt.ylabel("s (m)")
plt.legend()
plt.show()

Utskrift:

0.0-0.2 s: 0.25 m/s
0.2-0.4 s: 0.70 m/s
0.4-0.6 s: 1.23 m/s
0.6-0.8 s: 1.65 m/s
0.8-1.0 s: 2.20 m/s
a = 2.42 m/s^2

Svar: a) Fartane er 0,25, 0,70, 1,23, 1,65 og 2,20 m/s. Farten aukar med omtrent like mykje, ca. 0,5 m/s, kvart 0,2 s, så akselerasjonen er omtrent konstant.

$a = \frac{2 \cdot 0{,}050}{0{,}2^2} = 2{,}50 \qquad a = \frac{2 \cdot 1{,}205}{1{,}0^2} = 2{,}41$

Svar: b) Verdiane er 2,50, 2,38, 2,42, 2,39 og 2,41 m/s², og gjennomsnittet er $a = 2{,}42$ m/s².

Svar: c) Målepunkta ligg på kurva $s = 1{,}21t^2$ innanfor 1 cm, så modellen med konstant akselerasjon passar.

Vanlege feil i Python

- Komma i desimaltal: 0,5 blir to tal. Skriv 0.5.
- ^ i staden for **: v^2 er ikkje $v^2$ i Python. Skriv v**2.
- Innrykk: linjene i ei løkke eller ein if-test må ha same innrykk. Ei linje utan innrykk høyrer ikkje lenger til løkka.
- Nummerering frå 0: t[1] er det andre elementet. range(1, 4) gir 1, 2 og 3, ikkje 4.
- Einingar: del fart i km/h på 3,6 før du reknar vidare i SI-einingar.
- Parentesar: s / 2 * a er $\displaystyle \frac{s}{2} \cdot a$ , ikkje $\displaystyle \frac{s}{2a}$ .

Oppgaver

Lett3 oppgaver

1Opplasting

2Opplasting

3Python

Medium4 oppgaver

4Opplasting

5Python

6Opplasting

7Python

Vanskelig2 oppgaver

8Opplasting

9Python

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.