Skip to content
Snippets Groups Projects
Commit 25c3a2ad authored by Majid Rouhani's avatar Majid Rouhani
Browse files

upd

parent 23d970a6
No related branches found
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
lectures/chap2/lab/funksjoner_og_kalkulasjoner.ipynb
+ 2
− 238
View file @ 25c3a2ad
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
# Funksjoner og kalkulasjoner # Funksjoner og kalkulasjoner
**Læringsmål**: **Læringsmål**:
* Aritmetikk * Aritmetikk
* Matematiske utrykk i Python
* Funksjoner * Funksjoner
I denne oppgaven skal du lære hvordan du skriver matematiske uttrykk for å gjøre utregninger i Python. I tillegg skal du lære enkel bruk og opprettelse av funksjoner. I denne oppgaven skal du lære hvordan du skriver matematiske uttrykk for å gjøre utregninger i Python. I tillegg skal du lære enkel bruk og opprettelse av funksjoner.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens ### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens
Les gjerne denne før du starter med oppgavene Les gjerne denne før du starter med oppgavene
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller. Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.
Tabellen under oppsummerer det mest grunnleggende: Tabellen under oppsummerer det mest grunnleggende:
Matematikk | Python | Merknad Matematikk | Python | Merknad
--- | --- | --- --- | --- | ---
a + b | a + b | Det er vanlig å sette et mellomrom på hver side av + men ikke påkrevd. <br> Kunne også ha skrevet a+b. Samme gjelder for andre regneoperatorer. <br> Smak og behag, men litt luft gjør ofte uttrykk lettere å lese. a + b | a + b | Det er vanlig å sette et mellomrom på hver side av + men ikke påkrevd. <br> Kunne også ha skrevet a+b. Samme gjelder for andre regneoperatorer. <br> Smak og behag, men litt luft gjør ofte uttrykk lettere å lese.
a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus
a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon
ab|<span style="color:red">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates ab|<span style="color:red">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates
a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek. a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.
a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre. a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.
[(a + b) * c - d]|((a + b) * c - d)|I matematisk notasjon brukes av og til ulike parentessymboler () [] {} <br> hvis det er uttrykk med flere nivåer av parenteser nøstet inn i hverandre. <br> I Python må vanlig parentes () brukes for **alle** nivåer. [] og {} har en annen betydning. [(a + b) * c - d]|((a + b) * c - d)|I matematisk notasjon brukes av og til ulike parentessymboler () [] {} <br> hvis det er uttrykk med flere nivåer av parenteser nøstet inn i hverandre. <br> I Python må vanlig parentes () brukes for **alle** nivåer. [] og {} har en annen betydning.
**Presedens** mellom operatorer fungerer som i matematikken. **Presedens** mellom operatorer fungerer som i matematikken.
* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon. * Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.
* 3 + 2 * 5 blir 13, fordi * gjøres før +. * 3 + 2 * 5 blir 13, fordi * gjøres før +.
* 5 - 1 / 2 blir 4.5, fordi / gjøres før -. * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.
* Potens har høyere presedens enn multiplikasjon og divisjon. * Potens har høyere presedens enn multiplikasjon og divisjon.
* 5 * 2 ** 3 blir 40, fordi ** gjøres før *. * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.
* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene: * Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:
* (3 + 2) * 5 blir 25, fordi + gjøres før *. * (3 + 2) * 5 blir 25, fordi + gjøres før *.
* (5 - 1) / 2 blir 2, fordi - gjøres før /. * (5 - 1) / 2 blir 2, fordi - gjøres før /.
* (5 * 2) ** 3 blir 343, fordi * nå gjøres før **. * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.
* Hvis du skal "oversette" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden. * Hvis du skal "oversette" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.
**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** **I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:**
$$\frac{2-x}{2+x}$$ $$\frac{2-x}{2+x}$$
Horisontal brøkstrek viser tydelig at hele 2-x er teller og hele 3+x nevner. Med Pythons skråstrek for divisjon må man bruke parenteser her: (2 - x) / (3 + x) Horisontal brøkstrek viser tydelig at hele 2-x er teller og hele 3+x nevner. Med Pythons skråstrek for divisjon må man bruke parenteser her: (2 - x) / (3 + x)
$$3^{xy+1}$$ $$3^{xy+1}$$
Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1). Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1).
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### a) Korrekt programmering av aritmetiske utrykk ### a) Korrekt programmering av aritmetiske utrykk
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Skriv følgende matematikk-setninger korrekt i Python: Skriv følgende matematikk-setninger korrekt i Python:
La $a$ være $2$ La $a$ være $2$
La $b$ være $3$ La $b$ være $3$
La $c$ være $5a + b$ La $c$ være $5a + b$
La $d$ være $a * b + c$ La $d$ være $a * b + c$
La $e$ være $\frac{-b + 4}{a - 4}$
La $f$ være $5^{a * b + 2}$
La $g$ være $[(a + b) * c - d]$
**_Skriv koden din i kodeblokken under_** **_Skriv koden din i kodeblokken under_**
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# Skriv koden din her # Skriv koden din her
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være: Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:
```python ```python
2 2
3 3
13 13
19 19
-0.5
390625
46
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett # Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett
print(a) print(a)
print(b) print(b)
print(c) print(c)
print(d) print(d)
print(e)
print(f)
print(g)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Tutorial - Funksjoner: ### Tutorial - Funksjoner:
Les gjerne denne før du begynner på oppgaven Les gjerne denne før du begynner på oppgaven
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
I tillegg til likheter mellom matematikk og Python med hensyn til aritmetiske uttrykk, finnes det likheter for funksjoner. I matematikken mapper funksjoner en input $X$ til en output $Y$. Vi kan for eksempel ha funksjonen $f(x) = 2x + 3$, som mapper inputen $x$ til $2x + 3$. Setter man inn en verdi i denne funksjonen, f.eks $2$, vil man få outputen $2 * 2 + 3 = 4 + 3 = 7$. I tillegg til likheter mellom matematikk og Python med hensyn til aritmetiske uttrykk, finnes det likheter for funksjoner. I matematikken mapper funksjoner en input $X$ til en output $Y$. Vi kan for eksempel ha funksjonen $f(x) = 2x + 3$, som mapper inputen $x$ til $2x + 3$. Setter man inn en verdi i denne funksjonen, f.eks $2$, vil man få outputen $2 * 2 + 3 = 4 + 3 = 7$.
Det samme gjelder for funksjoner i Python. Forskjellen mellom funksjoner i Python og funksjoner i matematikken er at i Python trenger ikke nødvendigvis funksjonene å være matematiske. I tillegg er det en forskjell i opprettelsen av funksjonene. Denne øvingen vil gi en smakebit på bruk av funksjoner i Python, resten kommer i en senere øving. Det samme gjelder for funksjoner i Python. Forskjellen mellom funksjoner i Python og funksjoner i matematikken er at i Python trenger ikke nødvendigvis funksjonene å være matematiske. I tillegg er det en forskjell i opprettelsen av funksjonene. Denne øvingen vil gi en smakebit på bruk av funksjoner i Python, resten kommer i en senere øving.
I denne øvingen skal du lære å skrive matetmatiske funksjoner, som over, i Python. En funksjon i Python defineres med `def`-nøkkelordet. Deretter kommer et funksjonsnavn, for eksempel `f`. Funksjonsnavnet kan være hva som helst, så lenge det følger de vanlige reglene for variabelnavn. Funksjonsdefinisjonen avsluttes med parenteser `()` og kolon `:`. Parentesene kan være tomme, eller de kan inneholde _parametere_ som i matematikken. Et parameter i matematikken er gjerne `x`, og er et tall. I Python kan parameterene være av hvilken som helst variabeltype, og er en helt vanlig variabel. I denne øvingen skal du lære å skrive matetmatiske funksjoner, som over, i Python. En funksjon i Python defineres med `def`-nøkkelordet. Deretter kommer et funksjonsnavn, for eksempel `f`. Funksjonsnavnet kan være hva som helst, så lenge det følger de vanlige reglene for variabelnavn. Funksjonsdefinisjonen avsluttes med parenteser `()` og kolon `:`. Parentesene kan være tomme, eller de kan inneholde _parametere_ som i matematikken. Et parameter i matematikken er gjerne `x`, og er et tall. I Python kan parameterene være av hvilken som helst variabeltype, og er en helt vanlig variabel.
Etter definisjonen av funksjonen kommer funksjonskroppen. Her skiller funksjonene i Python seg mest ut fra matematiske funksjoner. Matematiske funksjoner git deg kun et output. De gjør kun én ting. Funksjoner i Python kan være lengre og gjøre flere ting før den gir output. Dette kan f.eks være å sjekke at parameteren som gis med i funksjonen er korrekt, eller mellomlagre verdier og gjøre flere utregninger. Etter definisjonen av funksjonen kommer funksjonskroppen. Her skiller funksjonene i Python seg mest ut fra matematiske funksjoner. Matematiske funksjoner git deg kun et output. De gjør kun én ting. Funksjoner i Python kan være lengre og gjøre flere ting før den gir output. Dette kan f.eks være å sjekke at parameteren som gis med i funksjonen er korrekt, eller mellomlagre verdier og gjøre flere utregninger.
Når en funksjon i Python skal gi output brukes `return`-nøkkelordet. Her sier man "returner denne verdien". Den returnerte verdien kan være av hvilken som helst variabeltype, i motsetning til matematikken som gir et tall som output. Når en funksjon i Python skal gi output brukes `return`-nøkkelordet. Her sier man "returner denne verdien". Den returnerte verdien kan være av hvilken som helst variabeltype, i motsetning til matematikken som gir et tall som output.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python: Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def f(x): # Definerer funksjonen def f(x): # Definerer funksjonen
return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3 return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3
``` ```
%% Cell type:markdown id: tags:
Når en funksjon står for seg selv, som funksjonen over, får vi ingen output når vi kjører koden. Funksjonen er kun _definert_, akkurat som når man oppretter seg en variabel. På samme måte som man ikke kan bruke variabler før de er definert, kan man ikke bruke funksjoner før de er definert:
```py
# Her kan man ikke bruke a eller min_funksjon
a = 1.3 # Assosierer navnet a med et flyttallsobjekt i minnet
# Her kan man bruke a, men ikke min_funksjon
def min_funksjon(): # Assosierer navnet min_funksjon med et funksjonsobjekt i minnet
# Her kan man bruke begge
```
Prøv å kjøre kodeblokken over og se at du ikke får noe output.
Når en funksjon er defniert, kan vi _kalle_ på den. Dette kan man gjøre ved å skrive funksjonsnavnet, etterfulgt av parenteser og eventuelle _argumenter_ i parentesene. Kodeblokken under kaller på funksjonen `f(x)`, med argumentet $2$. Prøv å kjøre den!
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
f(2) f(2)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### b) Skrive funksjonsuttrykk riktig i Python ### b) Skrive funksjonsuttrykk riktig i Python
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
**Skriv følgende matematiske funksjoner i Python:** **Skriv følgende matematiske funksjoner i Python:**
$f(x) = 2x + 1$ $f(x) = 2x + 1$
$g(x) = \frac{-4x + 2}{5x + 3}$
$h(x) = x^2 + 2x + 1$
$i(x) = \sqrt(x)$
$j(x) = \sin{x} + \cos{x}$
**_Skriv koden din i kodeblokken under_** **_Skriv koden din i kodeblokken under_**
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere **Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# Skriv koden din her # Skriv koden din her
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være: Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:
```python ```python
21 21
-0.6428571428571429
16
2.0
-0.6752620891999122
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
print(f(10)) print(f(10))
print(g(5))
print(h(3))
print(i(4))
print(j(5))
```
%% Cell type:markdown id: tags:
### Tutorial - Matteoperasjoner del 2: Heltallsdivisjon og Modulo:
Les gjerne denne før du begynner på neste oppgave
%% Cell type:markdown id: tags:
I tillegg til vanlig divisjon / har Python også heltallsdivisjon som skrives // og modulo som skrives med operatoren %.
Heltallsdivisjon og modulo minner om måten du lærte divisjon på barneskolen før du hadde lært desimaltall, altså med hele tall og rest.
Tabellen under illustrerer hvordan disse operatorene virker:
**Utrykk i Python**|**Resultat**|**Forklaring**
---|---|---
17 / 5 |3.4 |Vanlig divisjon
17 // 5| 3 |Heltallsdivisjon, gir hvor mange hele ganger nevneren 5 går opp i telleren 17
17 % 5 |2| Modulo, gir resten av 17 // 5, dvs. de 2 som blir til over
7.75 / 2.5 |3.1| Vanlig divisjon
7.75 // 2.5 |3.0| Heltallsdivisjon, gir hvor mange hele ganger nevneren 2.5 går opp i 7.75.<br> Her blir svaret et flyttall (3.0) heller enn heltallet 3, fordi teller og nevner er flyttall.
7.75 % 2.5 |0.25| Modulo, Resten av 7.75//2.5 er 0.25 fordi 2.5 * 3.0 er 7.5
Heltallsdivisjon og modulo har en rekke nyttige bruksområder i programmering.
Ett eksempel er regning med enheter som aggregeres på andre måter enn det typiske 10, 100, 1000, slik som 60 sekund per minutt, 60 minutt per time, 24 timer per døgn, 7 døgn per uke.
Koden under viser hvordan // og % kan brukes til slike beregninger. Prøv å kjør den.
%% Cell type:code id: tags:
``` python
def antall_hele_uker(dager):
return dager // 7
def antall_uker_dager(dager):
uker = dager // 7
dager = dager % 7
return uker, dager
print(antall_hele_uker(10))
print(antall_uker_dager(15))
```
%% Cell type:markdown id: tags:
Det fins også mange andre nyttige anvendelser av // og %, som vil vise seg etter hvert som vi kommer til mer avanserte problemer.
%% Cell type:markdown id: tags:
### c) Bruk av heltallsdivisjon og modulo
%% Cell type:markdown id: tags:
Lag tre funksjoner `antall_minutt_sekund(sek)`, `antall_dogn_timer(timer)` og `antall_timer_minutt_sekund(sek)`, som gjør om sekunder til hele minutter, timer til hele døgn og sekunder til timer og resterende minutter.
**_Skriv koden din i kodeblokken under_**
%% Cell type:code id: tags:
``` python
# Skriv koden din her
```
%% Cell type:markdown id: tags:
Kjør kodeblokken under for å se at koden din fugerer som forventet
%% Cell type:code id: tags:
``` python
print(antall_minutt_sekund(120))
print(antall_dogn_timer(75))
print(antall_timer_minutt_sekund(19832))
```
%% Cell type:markdown id: tags:
**Riktig utskrift hvis du har fått det til, skal bli**
```
2
3
(5, 30) #siden 19832 sekunder tilsvarer 5 timer, 30 min, 32 sek.
```
%% Cell type:markdown id: tags:
### d) Konvertering av minutter
Skriv et program som finner ut hvor mange måneder, dager, timer og minutter er i et gitt antall minutter (f.eks. hvor mange måneder, dager, timer og minutter er 1252300 minutter?)
%% Cell type:code id: tags:
``` python
# Skriv koden din her
``` ```
......
lectures/chap2/lab/logiske_operatorer_uttrykk.ipynb
+ 0
− 162
View file @ 25c3a2ad
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
# Logiske operatorer og logiske uttrykk # Logiske operatorer og logiske uttrykk
**Læringsmål:** **Læringsmål:**
- Logiske uttrykk - Logiske uttrykk
- Betingelser - Betingelser
- Kodeforståelse - Kodeforståelse
- Funksjoner - Funksjoner
I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`. I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
## Generelt om logiske operatorer og logiske uttrykk ## Generelt om logiske operatorer og logiske uttrykk
Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner. Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
I de tidligere oppgavene i denne øvingen var alle betingelsene enkle betingelser hvor vi typisk sammenlignet to verdier. De vanlige operatorene vi har for å sammenligne verdier er: I de tidligere oppgavene i denne øvingen var alle betingelsene enkle betingelser hvor vi typisk sammenlignet to verdier. De vanlige operatorene vi har for å sammenligne verdier er:
- `==` (som betyr "er lik", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren) - `==` (som betyr "er lik", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)
- `!=` (som betyr "ulik", altså det motsatte av ==) - `!=` (som betyr "ulik", altså det motsatte av ==)
- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik) - `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)
Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel. Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.
Ved hjelp av logiske operatorer kan vi teste for flere betingelser i samme if-setning. Eksemplet nedenfor viser et lite program som leser inn temperatur og vind og så skal skrive et varsel om ekstremvær hvis det er kaldere enn -30, varmere enn 40, eller mer vind enn 20 m/s. Ved hjelp av logiske operatorer kan vi teste for flere betingelser i samme if-setning. Eksemplet nedenfor viser et lite program som leser inn temperatur og vind og så skal skrive et varsel om ekstremvær hvis det er kaldere enn -30, varmere enn 40, eller mer vind enn 20 m/s.
Her viser vi dette løst på to alternative måter, først med enkle betingelser og en if-elif-setning (linje 5-10), deretter med en enkelt if-setning med en sammensatt betingelse med `or` mellom (linje 13-14). **OBS:** Trykk på View -> Toggle Line Numbers i menyen på toppen for å se linjenummer. Her viser vi dette løst på to alternative måter, først med enkle betingelser og en if-elif-setning (linje 5-10), deretter med en enkelt if-setning med en sammensatt betingelse med `or` mellom (linje 13-14). **OBS:** Trykk på View -> Toggle Line Numbers i menyen på toppen for å se linjenummer.
Når det står `or` mellom betingelser er det nok at en av dem er sann for at hele uttrykket skal bli sant (men også sant om begge er sanne); den sammensatte varianten vil dermed gi samme resultat som if-elif-setningen bare at vi med vilje har droppet utropstegn i siste print så du lett skal se hva som er hva. Når det står `or` mellom betingelser er det nok at en av dem er sann for at hele uttrykket skal bli sant (men også sant om begge er sanne); den sammensatte varianten vil dermed gi samme resultat som if-elif-setningen bare at vi med vilje har droppet utropstegn i siste print så du lett skal se hva som er hva.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
########## Eksempel 1 ########## ########## Eksempel 1 ##########
# VARIANT MED if-elif # VARIANT MED if-elif
def ekstremvær_if_elif(temp, vind): def ekstremvær_if_elif(temp, vind):
if temp < -30: if temp < -30:
return "VARSEL: Ekstremvær!" return "VARSEL: Ekstremvær!"
elif temp > 40: elif temp > 40:
return "VARSEL: Ekstremvær!" return "VARSEL: Ekstremvær!"
elif vind > 20: elif vind > 20:
return "VARSEL: Ekstremvær!" return "VARSEL: Ekstremvær!"
ekstremvær_if_elif(50, 2) ekstremvær_if_elif(50, 2)
``` ```
%% Output %% Output
'VARSEL: Ekstremvær!' 'VARSEL: Ekstremvær!'
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
########## Eksempel 2 ########## ########## Eksempel 2 ##########
# VARIANT MED SAMMENSATT BETINGELSE # VARIANT MED SAMMENSATT BETINGELSE
def ekstremvær_sammensatt(temp, vind): def ekstremvær_sammensatt(temp, vind):
if temp < -30 or temp > 40 or vind > 20: if temp < -30 or temp > 40 or vind > 20:
return "VARSEL: Ekstremvær" return "VARSEL: Ekstremvær"
ekstremvær_sammensatt(10, 40) ekstremvær_sammensatt(10, 40)
``` ```
%% Output %% Output
'VARSEL: Ekstremvær' 'VARSEL: Ekstremvær'
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Merk at varianten med sammensatt betingelse kun funker her fordi det er samme tekst som skal skrives i alle de tre tilfellene. Hvis utskriften skulle ha vært mer spesifikk (f.eks. ekstremt kaldt / ekstremt varmt / ...), måtte vi ha brukt if-elif... Merk at varianten med sammensatt betingelse kun funker her fordi det er samme tekst som skal skrives i alle de tre tilfellene. Hvis utskriften skulle ha vært mer spesifikk (f.eks. ekstremt kaldt / ekstremt varmt / ...), måtte vi ha brukt if-elif...
Tilsvarende kan vi i noen tilfeller unngå nøstede if-setninger (linje 5-7 i eksemplet under) ved å sette sammen betingelser med `and` (linje 10-11 under). Når det er `and` mellom to betingelser, må **begge** være sanne for at hele uttrykket skal bli sant. Tilsvarende kan vi i noen tilfeller unngå nøstede if-setninger (linje 5-7 i eksemplet under) ved å sette sammen betingelser med `and` (linje 10-11 under). Når det er `and` mellom to betingelser, må **begge** være sanne for at hele uttrykket skal bli sant.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
########## Eksempel 3 ########## ########## Eksempel 3 ##########
def paraply(regn, vind): def paraply(regn, vind):
print(f"Regn i mm: {regn}") print(f"Regn i mm: {regn}")
print(f"Vind i sekundmeter: {vind}") print(f"Vind i sekundmeter: {vind}")
# VARIANT MED NØSTEDE if-setninger # VARIANT MED NØSTEDE if-setninger
if regn > 0.2: if regn > 0.2:
if vind < 7.0: if vind < 7.0:
return "Anbefaler paraply." return "Anbefaler paraply."
return "Anbefaler ikke paraply" return "Anbefaler ikke paraply"
anbefaling = paraply(0.3, 6.0) anbefaling = paraply(0.3, 6.0)
print(anbefaling) print(anbefaling)
``` ```
%% Output %% Output
Regn i mm: 0.3 Regn i mm: 0.3
Vind i sekundmeter: 6.0 Vind i sekundmeter: 6.0
Anbefaler paraply. Anbefaler paraply.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
########## Eksempel 4 ########## ########## Eksempel 4 ##########
def paraply_sammensatt(regn, vind): def paraply_sammensatt(regn, vind):
print(f"Regn i mm: {regn}") print(f"Regn i mm: {regn}")
print(f"Vind i sekundmeter: {vind}") print(f"Vind i sekundmeter: {vind}")
# VARIANT MED SAMMENSATT BETINGELSE # VARIANT MED SAMMENSATT BETINGELSE
if regn > 0.2 and vind < 7.0: if regn > 0.2 and vind < 7.0:
return "Anbefaler paraply." return "Anbefaler paraply."
return "Anbefaler ikke paraply" return "Anbefaler ikke paraply"
anbefaling = paraply_sammensatt(0.3, 6.0) anbefaling = paraply_sammensatt(0.3, 6.0)
print(anbefaling) print(anbefaling)
``` ```
%% Output %% Output
Regn i mm: 0.3 Regn i mm: 0.3
Vind i sekundmeter: 6.0 Vind i sekundmeter: 6.0
Anbefaler paraply. Anbefaler paraply.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
I begge de foregående eksemplene vil nok de fleste si at variantene med sammensatte betingelser er klart å foretrekke framfor if-elif eller nøstet if. Bruk av sammensatte betingelser gjør koden kortere og enklere å forstå. I begge de foregående eksemplene vil nok de fleste si at variantene med sammensatte betingelser er klart å foretrekke framfor if-elif eller nøstet if. Bruk av sammensatte betingelser gjør koden kortere og enklere å forstå.
Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not` Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`
Disse virker på følgende måte: Disse virker på følgende måte:
- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant) - betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)
- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False - betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False
- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True - `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True
- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. - Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem.
Presedensregler: `not` har større presedens enn `and`, som har større enn `or`. Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.
F.eks. anta at F.eks. anta at
`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply `if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply
Ifølge presedensreglene vil `not` evalueres først, deretter `and`, og til slutt `or`. Uttrykket kan dermed ses som to alternative måter for å anbefale paraply (delt av `or` i midten), nemlig: Ifølge presedensreglene vil `not` evalueres først, deretter `and`, og til slutt `or`. Uttrykket kan dermed ses som to alternative måter for å anbefale paraply (delt av `or` i midten), nemlig:
ENTEN at både `regn > 0.2` og `vind < 0.7` er sanne. Det spiller da ingen rolle hvilken verdi vi har for solbrentfare osv. (siden den har `or` foran seg) ENTEN at både `regn > 0.2` og `vind < 0.7` er sanne. Det spiller da ingen rolle hvilken verdi vi har for solbrentfare osv. (siden den har `or` foran seg)
ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann) ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)
I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn. I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.
Merk at selv om sammensatte betingelser gjorde koden kortere og enklere å forstå i eksemplene over, er ikke dette alltid tilfelle. Hvis man ender med veldig store sammensatte betingelser, vil disse i seg selv være vanskelig å forstå, slik at kanskje noe oppsplitting med if-elif... eller nøsting av if-setninger kunne ha vært bedre. Merk at selv om sammensatte betingelser gjorde koden kortere og enklere å forstå i eksemplene over, er ikke dette alltid tilfelle. Hvis man ender med veldig store sammensatte betingelser, vil disse i seg selv være vanskelig å forstå, slik at kanskje noe oppsplitting med if-elif... eller nøsting av if-setninger kunne ha vært bedre.
Men se først om det er mulig å skrive betingelsen enklere. Dette gjelder særlig hvis det er mye bruk av `not`. Akkurat som mye bruk av negasjoner i vanlig norsk vil gjøre en tekst vanskelig å forstå, vil mye bruk av `not` gjøre Python-betingelser vanskelige å forstå - og kunne kanskje vært unngått. F.eks. Men se først om det er mulig å skrive betingelsen enklere. Dette gjelder særlig hvis det er mye bruk av `not`. Akkurat som mye bruk av negasjoner i vanlig norsk vil gjøre en tekst vanskelig å forstå, vil mye bruk av `not` gjøre Python-betingelser vanskelige å forstå - og kunne kanskje vært unngått. F.eks.
- `not a < 10` kan like gjerne skrives `a >= 10` - `not a < 10` kan like gjerne skrives `a >= 10`
- `not a == 10` kan like gjerne skrives `a != 10` - `not a == 10` kan like gjerne skrives `a != 10`
- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`. - `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.
Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes. Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes.
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
## a) ## a)
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`? Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?
Uttrykk 1: `-5 < z and 5 > z` Uttrykk 1: `-5 < z and 5 > z`
Uttrykk 2: `not y == 8` Uttrykk 2: `not y == 8`
Uttrykk 3: `x == 8 or y == 8` Uttrykk 3: `x == 8 or y == 8`
Uttrykk 4: `not (x <= 3 or y >= 9)` Uttrykk 4: `not (x <= 3 or y >= 9)`
Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z`
Dobbelklikk på teksten under og skriv svaret ditt der: Dobbelklikk på teksten under og skriv svaret ditt der:
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Svar: < dobbeltklikk her> Svar: < dobbeltklikk her>
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
#### Hint #### Hint
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Om du sliter kan du sjekke ved å skrive et program som gir x, y og z verdiene 3, 8, -3 og bruke `print(<logisk uttrykk>)`. Om du sliter kan du sjekke ved å skrive et program som gir x, y og z verdiene 3, 8, -3 og bruke `print(<logisk uttrykk>)`.
Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`.
Du kan teste kode her: Du kan teste kode her:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
## b) ## b)
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Nedenfor følger en funksjon der brukeren skal gi to tall innenfor et lovlig verdiområde. Det lovlige verdiområdet er mellom 40-50 eller mellom 70-90. Om ikke begge tallene som gis som argumenter harlovlig verdi, skal koden i else-blokken returneres. Nedenfor følger en funksjon der brukeren skal gi to tall innenfor et lovlig verdiområde. Det lovlige verdiområdet er mellom 40-50 eller mellom 70-90. Om ikke begge tallene som gis som argumenter harlovlig verdi, skal koden i else-blokken returneres.
Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene. Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.
***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller*** ***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
print("Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:" ) print("Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:" )
def gyldige_tall(a, b): def gyldige_tall(a, b):
if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)): if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)):
return "Tallene er begge i gyldige intervall!" return "Tallene er begge i gyldige intervall!"
else: else:
return "Minst ett av tallene er utenfor et gyldig intervall :(" return "Minst ett av tallene er utenfor et gyldig intervall :("
``` ```
%% Output %% Output
Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>: Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
#### Hint #### Hint
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Husk parenteser! Husk parenteser!
%% Cell type:markdown id: tags:
## c)
%% Cell type:markdown id: tags:
Du skal i denne oppgaven fullføre funksjonen gitt nedenfor slik at den fungerer korrekt. Det er blitt laget 10 pannekaker, noe som er mer enn datamaskinen klarer å spise, og den ønsker å dele noen av dem med deg. Men om du er grådig og spør om å få flere enn 10, vil du få beskjed om at det ikke er mulig. Om du derimot ønsker å gi datamaskinen pannekaker (skriver inn et negativt tall som argument til funksjonen), vil du også få beskjed om at det ikke er mulig. ***Endre på koden under***
%% Cell type:code id: tags:
``` python
print("Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg")
def antall_pannekaker(n):
if ...: #Kode mangler her
return "Beklager, men det er nok ikke mulig"
else:
r = 10-p
return f"Da blir det {p} på deg og {r} på meg :D"
```
%% Cell type:markdown id: tags:
**Eksempel på kjøring**
```
Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg
antall_pannekaker(4)
Da blir det 4 på deg og 6 på meg :D
```
```
Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^
antall_pannekaker(100)
Beklager, men det er nok ikke mulig
```
%% Cell type:markdown id: tags:
## d)
%% Cell type:markdown id: tags:
I denne deloppgaven skal pannekakefunksjonen utvides. Det skal nå også ta inn et argument om personen liker pannekaker og lagre det i en boolsk variabel, som vist i koden under (merk: `'J'` betyr at personen liker pannekaker, og `'N'` betyr at personen ikke liker pannekaker:
```python
print("Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg")
def antall_pannekaker(n, liker):
if liker == 'J':
liker_pannekaker = True
else:
liker_pannekaker = False
...
```
Pannekakeprogrammet elsker pannekaker og er lite forståelsesfull ovenfor de som ikke gjør det. Derfor, om `liker_pannekaker` er `False`, skal det også svare "...ikke mulig" selv om brukeren ber om et antall pannekaker innenfor lovlig intervall <0,10>.
Din jobb er å samle alle disse betingelsene i et logisk uttrykk og skrive dette logiske uttrykk inn i koden nedenfor (der ... står), slik at programmet får rett oppførsel. ***Endre på koden under***
%% Cell type:code id: tags:
``` python
print("Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^")
def antall_pannekaker(n, liker):
if liker == 'J':
liker_pannekaker = True
else:
liker_pannekaker = False
if ...: #Kode mangler her
return "Beklager, men det er nok ikke mulig"
else:
r = 10-p
return f"Da blir det {p} på deg og {r} på meg :D"
```
%% Output
Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^
%% Cell type:markdown id: tags:
**Eksempel på kjøring**
```
Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg
antall_pannekaker(5, 'J')
Da blir det 5 på deg og 5 på meg :D
```
```
Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^
antall_pannekaker(7, 'N')
Beklager, men det er nok ikke mulig
```
%% Cell type:code id: tags:
``` python
```
......
lectures/chap2/lab/ulike_typer_if_setninger.ipynb
+ 0
− 1014
View file @ 25c3a2ad
This diff is collapsed.
lectures/chap2/notes/slides/lecture-2.md deleted 100644 → 0
+ 0
− 151
View file @ 23d970a6
---
marp: true
size: 4:3
paginate: true
---
<!-- https://marpit.marp.app/directives -->
# Leksjon 2
**Læringsutbytte**
* Kunne skrive enkle matematiske uttrykk i Python
* Lære å definere funksjoner i Python
* Kunne sette opp logiske uttrykk
* Lære å bruke if-setningen i Python.
---
# Funksjoner og kalkulasjoner
**Aritmetikk**
**Presedens mellom operatorer fungerer som i matematikken.**
* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.
* 3 + 2 * 5 blir 13, fordi * gjøres før +.
* 5 - 1 / 2 blir 4.5, fordi / gjøres før -.
* Potens har høyere presedens enn multiplikasjon og divisjon:
5 * 2 ** 3 blir 40, fordi ** gjøres før *.
---
* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:
* (3 + 2) * 5 blir 25, fordi + gjøres før *.
* (5 - 1) / 2 blir 2, fordi - gjøres før /.
* (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.
* Hvis du skal "oversette" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.
---
## Funksjoner
Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:
```python
def f(x): # Definerer funksjonen
return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3
# Kall/bruk funksjonen
print(f(1))
print(f(2))
y = f(3)
print(y)
```
---
# Moduler og pakker
* En modul i Python er en python-fil
* En modul inneholder python-code, som regel funksjoner.
* Eksempel på en modul er 'math'
* Vi kan bruke moduler i våre programmer:
```python
import math
print(math.pi) # printer ut verdien av variabelen pi som ligger i modulen math
print(math.pow(4,2)) # printer 4*4 = 16
```
```python
import math as m
print(m.pi) # printer ut verdien av variabelen pi som ligger i modulen math
print(m.pow(4,2)) # printer 4*4 = 16
```
---
```python
from math import pi, pow
print(pi) # printer ut verdien av variabelen pi som ligger i modulen math
print(pow(4,2)) # printer 4*4 = 16
```
---
# Pakker
* Pakker består av flere moduler
* Vi kan importere hele eller deler av en pakke
* De fleste pakkene må installeres i miljøet før de kan tas i bruk.
* På Jupyter har vi allerede installert det meste av det som trengs i dette kurset.
* For å installere en pakke, start terminal vindu og skriv:
```python
pip install <<pakkenavn>>
```
Eksempel:
```python
pip install matplotlib
```
---
# Eksempler på bruk av pakker
```python
import matplotlib.pyplot as plt
import random as rnd
dager = range(7)
regn_mm = [rnd.randint(0,10) for i in dager]
plt.plot(dager,regn_mm)
```
---
## Logiske operatorer
* `==` (betyr "er lik", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)
* `!=` (betyr "ulik", altså det motsatte av ==)
* `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)
```python
a = 10
b = 15
er_lik = a == b
print (er_lik)
er_storre = a > b
print (er_storre)
er_ulik = a != b
print (er_ulik)
```
---
# if-setninger
* Bruker til å finne ut resultatet av logiske uttrukk blir
```python
a = 10
b = 15
if a == b:
print ('a er lik b')
if a > b
print ('a er større enn b')
if a != b:
print ('a er ulik b')
```
\ No newline at end of file
lectures/chap2/notes/slides/lecture-2.pdf deleted 100644 → 0
+ 0
− 0
View file @ 23d970a6
File deleted
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment