"**Med færre multiplikasjoner vil VERSJON 2 spare både strøm og tid i forhold til VERSJON 1, dvs. koden utfører mindre jobb og går raskere selv om det er flere kodelinjer.**"
]
},
{
"cell_type": "markdown",
"metadata": {
"heading_collapsed": true,
"run_control": {
"frozen": true
}
},
"source": [
"## b) Bruke variable i beregninger "
]
},
{
"attachments": {},
"cell_type": "markdown",
...
...
%% Cell type:markdown id: tags:
# Variable
**Læringsmål:**
* Enkel bruk av variable
* Korrekt navngivning av variable
%% Cell type:markdown id: tags:
## Tutorial del 1: variable - grunnleggende intro
%% Cell type:markdown id: tags:
Hvorfor trenger vi variable? Poenget med variable er å **huske data underveis** i utførelsen av et program.
Variable er derfor et sentralt konsept i programmering, ikke bare i Python men uansett hva slags språk man programmerer i.
Uten variable støter vi fort på en rekke problemer fordi programmet vårt ikke kan huske noe, f.eks. at
* vi må be brukeren gi inn opplysninger på nytt som brukeren har gitt tidligere
* vi må regne ut på nytt data vi allerede har regnet ut tidligere
Dette sløser tid og strøm og vil i mange tilfeller gjøre programmet fullstendig ubrukelig.
I det lille eksempelprogrammet under, klarer vi oss uten noen variabel, fordi navnet som skrives ut kun blir benyttet én gang.
```python
print('Pi, med seks desimaler er 3.141592')
```
```
Pi, med seks desimaler er 3.141592
>>>>
```
Men ofte skal samme data brukes flere ganger, og etter at vi har gjort andre ting i mellomtiden. Da må data huskes i variable. Anta at vi ønsker en bare litt mer avansert dialog.
```
Pi, med seks desimaler er 3.141592
3.141592 er pi, avrundet til seks desimaler.
>>>>
```
Her vil vi bruke verdien til pi i to påfølgende print-setninger. Hvis vi prøver samme triks som tidligere med å sette tallet direkte i print-setning, får vi koden:
```python
print('Pi, med seks desimaler er 3.141592')
print('3.141592 er pi, avrundet til seks desimaler.')
```
```
Pi, med seks desimaler er 3.141592
3.141592 er Pi, avrundet til seks desimaler.
```
Ikke noe katastrofalt problem her, men tenk deg et program hvor samme opplysning skal brukes 100 ganger eller mer i en kritisk arbeidsoppgave som haster. Da kan det bli tungvindt å for eksempel skrive 3.141592 100 ganger.
Kan vi løse det på en bedre måte? JA - med en variabel for å huske navnet. Koden blir da
%% Cell type:code id: tags:
``` python
# Vi definerer en variabel kalt pi som husker på tallet 3.141592.
pi=3.141592
# Når vi leser innholdet i variabelen, leser vi en kopi
print('Pi, med seks desimaler er',pi)
print(pi,'er pi, avrundet til seks desimaler')
# Variabelen inneholder verdien helt til vi sletter den
del(pi)
# Denne linjen vil feil
print(pi,'er pi, avrundet til seks desimaler')
# Definerer variabelen på nytt
pi=3.14
print(pi,'er pi, avrundet til 2 desimaler')
```
%% Output
Pi, med seks desimaler er 3.141592
3.141592 er pi, avrundet til seks desimaler
3.14 er pi, avrundet til 2 desimaler
%% Cell type:code id: tags:
``` python
# Les data from tastaturet og lagre i en variabel
navn=input("Hva er ditt navn?")
print("Hei",navn,"! Velkommen til Python!")
alder=input("Hvor gammel er du"+navn+"?")
print("Din alder er",alder)
```
%% Output
Hei Majid ! Velkommen til Python!
Din alder er 30
%% Cell type:markdown id: tags:
### Rask intro til f-strenger
%% Cell type:markdown id: tags:
F-strenger, som brukt i print-setningenge ovenfor, er lett å gjenkjenne ved at strengen starter med en "f" før fnuttene. F-en står for "format". F-strings gjør det veldig lett for oss å formatere strengene våre. Som du ser i eksempelet over inneholder strengen noen krøllparenteser (`{}`). Innimellom disse krøllparentesene er vi ikke lenger inne i strengen, og at vi skriver inne i disse er "vanlig" Python kode. I eksempelet over settes variabelen `pi` inn i disse krøllparentesene. Dette gjøres slik at verdien variabelen `pi` inneholder kan bli satt inn i strengen. Som sagt er det "vanlig" Python kode som skrives inne i disse krøllparentesene. Vi kan for eksempel gjøre matteoperasjoner i de:
%% Cell type:code id: tags:
``` python
print(f'1 + 1 = {1+1}')
print(f'2 * 2 = {2*5}')# Her er det noe feil. Kan du fikse opp?
alder=29
navn="Ola Martin"
print(f"{navn} er {alder} gammel!")
```
%% Output
1 + 1 = 2
2 * 2 = 10
Ola Martin er 29 gammel!
%% Cell type:markdown id: tags:
## Tutorial del 2 - bruk av variable i beregninger
%% Cell type:markdown id: tags:
Variable brukes ikke bare i sammenheng med `input()`, men i alle mulige slags program. I matematiske beregninger skal resultatet av en beregning ofte brukes videre i nye beregninger. Da må disse tallene huskes i variable.
Koden under viser samme eksempel gjort på to måter, nemlig utregning av areal for en sirkel, samt volum for en sylinder som har denne sirkelen som grunnflate. Versjon 1 er gjort uten variable, mens Versjon 2 bruker variable.
**Sirkel og sylinder**
%% Cell type:code id: tags:
``` python
importmath
# VERSJON 1, uten variable
print("Areal av sirkelen:",math.pi*5.4**2)
print("Volum av sylinderen:",math.pi*5.4**2*7.9)
print()
# VERSJON 2, med variable
r=5.4# radius for en sirkel
a_sirkel=math.pi*r**2
print("Areal av sirkelen:",a_sirkel)
h=7.9# høyde sylinder hvor sirkelen er grunnflate
v_syl=a_sirkel*h
print("Volum av sylinderen:",v_syl)
```
%% Cell type:markdown id: tags:
Hvis du kjører koden, vil du se at begge gir samme resultat. Hva er da forskjellen?
* Versjon 2 er vesentlig lenger (6 kodelinjer, mot bare 2) fordi det brukes ekstra linjer på variable. Lenger kode er en mulig ulempe. MEN:
* Formlene i Versjon 2 er lettere å forstå fordi det er intuitive navn som `r`, `h`, `a_sirkel` heller enn bare tall direkte.
* Koden i V2 er mer fleksibel for å kjapt endre verdier. Hvis radius skal byttes fra 5.4 til 6.2 må dette tallet bare endres ett sted i V2, mens flere i V1.
* Versjon 1 utfører **5 operasjoner** av type `*` og `**`, mens Versjon 2 bare utfører ***3***. Dette fordi Versjon 2 husker arealet i A_sirkel og deretter kan bruke dette, mens Versjon 1 må regne ut `math.pi * 5.4**2` på nytt.
**Med færre multiplikasjoner vil VERSJON 2 spare både strøm og tid i forhold til VERSJON 1, dvs. koden utfører mindre jobb og går raskere selv om det er flere kodelinjer.**
%% Cell type:markdown id: tags:
## b) Bruke variable i beregninger
%% Cell type:markdown id: tags:
Nedenfor står et program hvor vi regner ut omkrets og areal for en sirkel etter de velkjente formlene $O=2\pi{r}$ og $A = \pi r^2$. Bortsett fra **numpy** konstanten `np.pi` og den innebygde konstanten `math.tau` (=2π) bruker vi ingen variable. Dette gjør at når vi skal regne ut arealet av en sylinder hvor sirkelen er grunnflate, må vi gjøre om igjen flere beregninger som vi allerede har gjort tidligere.
Arealet av sylinderen med høyde h vil være `omkrets_sirkel * h + 2 * areal_sirkel`, hvor det første leddet er arealet av sylinderveggen og det siste leddet er topp- og bunnlokket.
***Oppgave: Endre koden ved å tilordne og deretter bruke variable for radiusen, høyden, sirkelens omkrets og areal, slik at programmet unngår å gjøre på nytt beregninger som allerede er gjort før.***
%% Cell type:code id: tags:
``` python
importnumpyasnp
importmath
print("Har en sirkel med radius",5.4,"som er grunnflate i en sylinder med høyde",7.9)
print("Omkrets av sirkelen:",math.tau*5.4)#tau er det samme som 2 pi
print("Areal av sirkelen:",np.pi*5.4**2)
print("Areal av sylinderen:",math.tau*5.4*7.9+2*math.pi*5.4**2)
```
%% Cell type:markdown id: tags:
Resultatet av kjøring av koden skal være uendret, dvs utskrift skal bli som vist nedenfor (men hvis du vil, kan du gjerne i tillegg avrunde svarene til én desimal).
```
Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9
Omkrets av sirkelen: 33.929200658769766
Areal av sirkelen: 91.60884177867838
Areal av sylinderen: 451.25836876163794
```
%% Cell type:markdown id: tags:
## Tutorial del 3: Navngiving av variable
%% Cell type:markdown id: tags:
En variabel er et navn som representerer en verdi som lagres i datamaskinens minne. Den vanligste måten å opprette en variabel på er ved en tilordningssetning:
`variable = expression`
I dette tilfellet er variable navnet til variabelen, mens expression er verdien. Noen regler for slike tilordningssetninger:
* variabelen som opprettes skal alltid stå på venstre side av uttrykket, og venstre side skal kun inneholde denne variabelen, ikke noe annet
* høyde side kan alt fra en enkelt verdi (f.eks. et tall) eller en enkelt variabel, til mer sammensatte uttrykk som må beregnes. Hvis høyre side inneholder variable, må dette være variable som allerede er opprettet tidligere i koden.
* variabelnavnet må tilfredsstille følgende regler:
* ord som er reserverte ord i Python, f.eks. `if`, `def`, eller som er navn på standardfunksjoner som `print`, `min`, `max`, ... bør unngås som varibelnavn
* variabelnavn må begynne med en bokstav eller tegnet _ (understrek)
* kan ellers inneholde bokstaver, tall og understrek, dvs. kan f.eks. ikke inneholde blanke tegn.
* Python skiller mellom små og store bokstaver, så `Areal` og `areal` vil være to ulike variable.
Det anbefales å lage variabelnavn som er intuitivt forståelige, f.eks. er `areal` et bedre navn enn `x` på en variabel som inneholder et areal. Sammensatte variabelnavn skrives typisk som pukkelord (eng.: camelCase) eller med understrek for å vise hvor ett ord slutter og det neste begynner, f.eks. `startTime`, `pricePerLiter` eller `start_time`, `price_per_liter`, siden direkte sammensetning uten noe som helst skille vil gi lange variabelnavn som blir vanskelige å lese.
Kodeblokka under viser eksempler på variable som funker og ikke funker:
