1.3 Python for fysikk | Fysikk 1

Variabler, lister, løkker og if-tester i Python brukt på formler og måledata: tabeller, gjennomsnitt, modeller og plott.

70 min

9 oppgaver

PythonVariablerLister og løkkerIf-testerMåledataPlotting

Du leser den tradisjonelle versjonen

Din fremgang i kapitlet

0 / 9 oppgaver

Python for fysikk

I fysikk gjør vi ofte den samme beregningen mange ganger: kinetisk energi ved flere farter, fart mellom mange målepunkter, en formel for en hel rekke tider. Et program gjør slike beregninger raskt og uten regnefeil, og det kan tegne grafer av resultatene.

Vi bruker Python. Programmene i dette kapitlet er korte og bruker bare noen få byggesteiner:
- variabler som tar vare på tall, med enheter i en kommentar
- lister med mange verdier, for eksempel måletider og posisjoner
- løkker som gjør det samme for hver verdi
- if-tester som bare gjør noe når en betingelse er oppfylt
- plott av måledata og modeller

I kapittel 3.4 bruker vi de samme byggesteinene til å regne ut bevegelse steg for steg når akselerasjonen ikke er konstant.

Variabler og beregninger

En variabel er et navn på en verdi. Python regner bare med tall, så enheten skriver vi i en kommentar etter #. Alle verdier bør stå i SI-enheter, eller i samme enheter gjennom hele programmet.

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

Regnetegn

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

Python følger vanlig regnerekkefølge: potenser først, så gange og dele, så pluss og minus. Bruk parenteser når du er i tvil: s / (2 * a) er ikke det samme som s / 2 * a.

Utskrift

print skriver ut verdier. Med en f-streng bestemmer vi antallet desimaler: {Ek:.1f} skriver Ek med én desimal.

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

Python bruker desimalpunktum, både i koden og i utskriften. Svaret skriver vi med desimalkomma når vi fører det.

Liste og løkke

En liste er en ordnet samling verdier, for eksempel t = [0.0, 0.2, 0.4] . Elementene nummereres fra 0: t[0] er det første, t[-1] det siste, og len(t) er antallet. En for-løkke gjør de samme linjene én gang for hver verdi: for v in farter: går gjennom lista, og for i in range(n): gir i = 0, 1, \dots, n - 1 . En while-løkke gjentar linjene så lenge en betingelse er sann. Linjene som hører til løkka, har innrykk.

✏️Eksempel 1: Kinetisk energi ved fire farter

En bil har masse 1200 kg. Lag et program som regner ut den kinetiske energien $E_k = \tfrac{1}{2}mv^2$ ved 30, 50, 80 og 110 km/h, og som skriver svarene i kJ. Hvor mange ganger 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 ganger så stor som ved 30 km/h, fordi energien er proporsjonal med $v^2$ .

Lister og løkker

Lage en tabell fra en formel

Med en løkke over en liste av tider kan vi regne ut en formel for hver tid og skrive resultatet som en tabell. Formatet {t:5.1f} setter av fem plasser og skriver én desimal, så kolonnene står rett under hverandre.

Bygge en liste i løkka

append legger en ny verdi bakerst i en liste. Slik kan vi samle resultater underveis:

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ører verdiene i to lister sammen, for eksempel tid og posisjon fra de samme målingene, bruker vi nummeret i:

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

Skal vi regne med to verdier som følger etter hverandre, starter vi på i = 1 og bruker s[i] - s[i-1]. Da blir det én verdi mindre enn antallet målinger.

Gjennomsnitt

sum(liste) legger sammen alle verdiene, og sum(liste) / len(liste) er gjennomsnittet.

✏️Eksempel 2: Tabell for fritt fall

En stein slippes fra ro. Uten luftmotstand er falt strekning $s = \tfrac{1}{2}gt^2$ og farten $v = gt$ . Lag et program som skriver en tabell over $s$ og $v$ for $t = 0$ , 0,5, 1,0, 1,5 og 2,0 s. Hvor mye øker strekningen fra 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: Strekningen øker fra 4,91 m til 19,62 m, til fire ganger så mye, fordi $s$ er proporsjonal med $t^2$ . Farten blir dobbelt så stor.

If-tester og while-løkker

If-test

En if-test kjører linjene med innrykk bare når betingelsen er sann. Med elif og else velger programmet mellom flere muligheter:

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

Sammenligninger skrives <, >, <=, >=, == (er lik) og != (er ikke lik).

While-løkke

En while-løkke brukes når vi ikke vet på forhånd hvor mange ganger noe skal gjentas. Den går så lenge betingelsen er sann:

h = 2.0              # høyde i m
n = 0                # antall sprett
while h > 0.5:
    h = 0.7 * h      # ballen når 70 % av forrige høyde
    n = n + 1
print(n, round(h, 3))

Programmet skriver ut 4 0.48: etter tre sprett er høyden 0,686 m, som fortsatt er over 0,5 m, og etter fire sprett er den 0,480 m. Noe inne i løkka må endre seg slik at betingelsen til slutt blir usann, ellers går løkka for alltid.

Måledata, modeller og plott

Regne med måledata

Måledata fra et forsøk legger vi i lister. Fra posisjoner målt med jevne mellomrom finner vi gjennomsnittsfarten i hvert intervall:

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

Modell fra en formel

En modell er en formel som skal beskrive målingene, for eksempel

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

for en vogn som starter fra ro med konstant akselerasjon. Vi bestemmer konstanten

a

fra målingene, regner ut modellen for mange tider og sammenligner.

Plotte

Biblioteket matplotlib tegner grafer. Målinger tegner vi som punkter ("o"), modellen som en sammenhengende 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()

Sett alltid størrelse og enhet på aksene. Ligger målepunktene nær kurven uten et system i avvikene, beskriver modellen målingene godt.

✏️Eksempel 3: Vogn ned et skråplan

En vogn slippes fra ro øverst på et skråplan, og posisjonen måles med en bevegelsessensor:

$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 et program som regner ut gjennomsnittsfarten i hvert intervall. Hva viser fartene om bevegelsen?
b) Bruk

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

til å regne ut

a

for hvert målepunkt, og finn gjennomsnittet.

c) Plott målingene og modellen $s = \tfrac{1}{2}at^2$ i samme koordinatsystem. Passer modellen?

a), b) og c) i ett program. Fra

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) Fartene er 0,25, 0,70, 1,23, 1,65 og 2,20 m/s. Farten øker med omtrent like mye, ca. 0,5 m/s, hvert 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) Verdiene 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ålepunktene ligger på kurven $s = 1{,}21t^2$ innenfor 1 cm, så modellen med konstant akselerasjon passer.

Vanlige feil i Python

- Komma i desimaltall: 0,5 blir to tall. Skriv 0.5.
- ^ i stedet for **: v^2 er ikke $v^2$ i Python. Skriv v**2.
- Innrykk: linjene i en løkke eller if-test må ha samme innrykk. En linje uten innrykk hører ikke lenger til løkka.
- Nummerering fra 0: t[1] er det andre elementet. range(1, 4) gir 1, 2 og 3, ikke 4.
- Enheter: del fart i km/h på 3,6 før du regner videre i SI-enheter.
- Parenteser: s / 2 * a er $\displaystyle \frac{s}{2} \cdot a$ , ikke $\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.