From 757010f790634b3fce4981024374f2ab9bd8b5b8 Mon Sep 17 00:00:00 2001 From: rouhani <majid.rouhani@ntnu.no> Date: Tue, 19 Sep 2023 06:55:10 +0200 Subject: [PATCH] added solutions --- lectures/chap1/lab/lf/intro_til_jupyter.ipynb | 373 +++++ lectures/chap1/lab/lf/lab-1.md | 14 + .../lab/lf/tall_og_typekonvertering.ipynb | 1047 ++++++++++++ lectures/chap1/lab/lf/variabler.ipynb | 566 +++++++ lectures/chap2/lab/lf/aarstider.ipynb | 142 ++ .../lab/lf/funksjoner_og_kalkulasjoner.ipynb | 366 ++++ lectures/chap2/lab/lf/lab-2.md | 15 + .../lab/lf/logiske_operatorer_uttrykk.ipynb | 462 ++++++ .../lab/lf/ulike_typer_if_setninger.ipynb | 366 ++++ .../\303\270ving_2/stud1/.DS_Store" | Bin 0 -> 6148 bytes .../\303\270ving_2/stud1/aarstider.ipynb" | 159 ++ .../stud1/funksjoner_og_kalkulasjoner.ipynb" | 368 ++++ .../\303\270ving_2/stud1/lab-2.md" | 15 + .../stud1/logiske_operatorer_uttrykk.ipynb" | 506 ++++++ .../stud1/ulike_typer_if_setninger.ipynb" | 407 +++++ .../\303\270ving_2/stud10/aarstider.ipynb" | 176 ++ .../stud10/funksjoner_og_kalkulasjoner.ipynb" | 652 ++++++++ .../\303\270ving_2/stud10/lab-2.md" | 15 + .../stud10/logiske_operatorer_uttrykk.ipynb" | 601 +++++++ .../stud10/ulike_typer_if_setninger.ipynb" | 1476 +++++++++++++++++ .../\303\270ving_2/stud11/aarstider.ipynb" | 146 ++ .../stud11/funksjoner_og_kalkulasjoner.ipynb" | 362 ++++ .../\303\270ving_2/stud11/lab-2.md" | 15 + .../stud11/logiske_operatorer_uttrykk.ipynb" | 484 ++++++ .../stud11/ulike_typer_if_setninger.ipynb" | 368 ++++ .../stud12/intro_til_jupyter.ipynb" | 370 +++++ .../\303\270ving_2/stud12/lab-1.md" | 14 + .../stud12/tall_og_typekonvertering.ipynb" | 1212 ++++++++++++++ .../\303\270ving_2/stud12/variabler.ipynb" | 589 +++++++ .../\303\270ving_2/stud13/aarstider.ipynb" | 175 ++ .../stud13/funksjoner_og_kalkulasjoner.ipynb" | 362 ++++ .../\303\270ving_2/stud13/lab-2.md" | 15 + .../stud13/logiske_operatorer_uttrykk.ipynb" | 488 ++++++ .../stud13/ulike_typer_if_setninger.ipynb" | 398 +++++ .../\303\270ving_2/stud14/aarstider.ipynb" | 145 ++ .../stud14/funksjoner_og_kalkulasjoner.ipynb" | 363 ++++ .../\303\270ving_2/stud14/lab-2.md" | 15 + .../stud14/logiske_operatorer_uttrykk.ipynb" | 480 ++++++ .../stud14/ulike_typer_if_setninger.ipynb" | 399 +++++ .../stud15/Funksjoner og Kalkulasjoner.ipynb" | 366 ++++ .../stud15/Logiske Operatorer Uttrykk.ipynb" | 505 ++++++ .../stud15/Ulike Typer if-setninger.ipynb" | 392 +++++ .../stud15/\303\205rstider.ipynb" | 163 ++ .../\303\270ving_2/stud16/aarstider.ipynb" | 141 ++ .../stud16/funksjoner_og_kalkulasjoner.ipynb" | 360 ++++ .../\303\270ving_2/stud16/lab-2.md" | 15 + .../stud16/logiske_operatorer_uttrykk.ipynb" | 479 ++++++ .../stud16/ulike_typer_if_setninger.ipynb" | 392 +++++ .../\303\270ving_2/stud17/aarstider.ipynb" | 162 ++ .../stud17/funksjoner_og_kalkulasjoner.ipynb" | 354 ++++ .../\303\270ving_2/stud17/lab-2.md" | 15 + .../stud17/logiske_operatorer_uttrykk.ipynb" | 498 ++++++ .../stud17/ulike_typer_if_setninger.ipynb" | 377 +++++ .../\303\270ving_2/stud18/aarstider.ipynb" | 150 ++ .../stud18/funksjoner_og_kalkulasjoner.ipynb" | 360 ++++ .../\303\270ving_2/stud18/lab-2.md" | 15 + .../stud18/logiske_operatorer_uttrykk.ipynb" | 470 ++++++ .../stud18/ulike_typer_if_setninger.ipynb" | 395 +++++ .../\303\270ving_2/stud19/aarstider.ipynb" | 111 ++ .../stud19/funksjoner_og_kalkulasjoner.ipynb" | 326 ++++ .../\303\270ving_2/stud19/lab-2.md" | 15 + .../stud19/logiske_operatorer_uttrykk.ipynb" | 454 +++++ .../stud19/ulike_typer_if_setninger.ipynb" | 369 +++++ .../\303\270ving_2/stud2/aarstider.ipynb" | 165 ++ .../stud2/funksjoner_og_kalkulasjoner.ipynb" | 357 ++++ .../stud2/logiske_operatorer_uttrykk.ipynb" | 478 ++++++ .../stud2/ulike_typer_if_setninger.ipynb" | 392 +++++ .../\303\270ving_2/stud20/aarstider.ipynb" | 139 ++ .../stud20/funksjoner_og_kalkulasjoner.ipynb" | 372 +++++ .../stud20/logiske_operatorer_uttrykk.ipynb" | 456 +++++ .../stud20/ulike_typer_if_setninger.ipynb" | 383 +++++ .../\303\270ving_2/stud3/aarstider.ipynb" | 165 ++ .../stud3/funksjoner_og_kalkulasjoner.ipynb" | 357 ++++ .../stud3/logiske_operatorer_uttrykk.ipynb" | 478 ++++++ .../stud3/ulike_typer_if_setninger.ipynb" | 392 +++++ .../\303\270ving_2/stud4/aarstider.ipynb" | 142 ++ .../stud4/funksjoner_og_kalkulasjoner.ipynb" | 351 ++++ .../stud4/logiske_operatorer_uttrykk.ipynb" | 487 ++++++ .../stud4/ulike_typer_if_setninger.ipynb" | 404 +++++ .../\303\270ving_2/stud5/aarstider.ipynb" | 157 ++ .../stud5/funksjoner_og_kalkulasjoner.ipynb" | 361 ++++ .../\303\270ving_2/stud5/lab-2.md" | 15 + .../stud5/logiske_operatorer_uttrykk.ipynb" | 481 ++++++ .../stud5/ulike_typer_if_setninger.ipynb" | 401 +++++ .../\303\270ving_2/stud6/aarstider.ipynb" | 137 ++ .../stud6/funksjoner_og_kalkulasjoner.ipynb" | 644 +++++++ .../stud6/logiske_operatorer_uttrykk.ipynb" | 652 ++++++++ .../stud6/ulike_typer_if_setninger.ipynb" | 1416 ++++++++++++++++ .../stud7/.vscode/settings.json" | 3 + .../\303\270ving_2/stud7/aarstider.ipynb" | 155 ++ .../stud7/funksjoner_og_kalkulasjoner.ipynb" | 363 ++++ .../\303\270ving_2/stud7/lab-2.md" | 15 + .../\303\270ving_2/stud7/lab-2.zip" | Bin .../stud7/logiske_operatorer_uttrykk.ipynb" | 465 ++++++ .../\303\270ving_2/stud7/oving2.py" | 92 + .../stud7/ulike_typer_if_setninger.ipynb" | 396 +++++ .../\303\270ving_2/stud8/aarstider.ipynb" | 233 +++ .../stud8/funksjoner_og_kalkulasjoner.ipynb" | 362 ++++ .../\303\270ving_2/stud8/lab-2.md" | 15 + .../stud8/logiske_operatorer_uttrykk.ipynb" | 616 +++++++ .../stud8/ulike_typer_if_setninger.ipynb" | 433 +++++ .../\303\270ving_2/stud9/aarstider.ipynb" | 155 ++ .../stud9/funksjoner_og_kalkulasjoner.ipynb" | 371 +++++ .../\303\270ving_2/stud9/lab-2.md" | 15 + .../stud9/logiske_operatorer_uttrykk.ipynb" | 488 ++++++ .../stud9/ulike_typer_if_setninger.ipynb" | 383 +++++ 106 files changed, 35352 insertions(+) create mode 100644 lectures/chap1/lab/lf/intro_til_jupyter.ipynb create mode 100644 lectures/chap1/lab/lf/lab-1.md create mode 100644 lectures/chap1/lab/lf/tall_og_typekonvertering.ipynb create mode 100644 lectures/chap1/lab/lf/variabler.ipynb create mode 100644 lectures/chap2/lab/lf/aarstider.ipynb create mode 100644 lectures/chap2/lab/lf/funksjoner_og_kalkulasjoner.ipynb create mode 100644 lectures/chap2/lab/lf/lab-2.md create mode 100644 lectures/chap2/lab/lf/logiske_operatorer_uttrykk.ipynb create mode 100644 lectures/chap2/lab/lf/ulike_typer_if_setninger.ipynb create mode 100644 "\303\270vinger/\303\270ving_2/stud1/.DS_Store" create mode 100644 "\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud1/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud1/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud1/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud1/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud10/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud10/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud10/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud10/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud10/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud11/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud11/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud11/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud11/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud11/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud12/intro_til_jupyter.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud12/lab-1.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud12/tall_og_typekonvertering.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud12/variabler.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud13/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud13/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud13/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud13/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud13/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud14/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud14/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud14/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud14/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud14/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud15/Funksjoner og Kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud15/Logiske Operatorer Uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud15/Ulike Typer if-setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud15/\303\205rstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud16/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud16/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud16/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud16/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud16/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud17/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud17/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud17/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud17/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud17/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud18/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud18/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud18/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud18/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud18/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud19/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud19/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud19/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud19/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud19/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud2/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud2/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud2/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud2/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud20/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud20/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud20/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud20/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud3/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud3/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud3/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud3/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud4/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud4/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud4/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud4/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud5/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud5/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud5/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud5/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud5/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud6/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud6/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud6/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud6/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/.vscode/settings.json" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/lab-2.md" rename lectures/chap2/lab/lab-2.zip => "\303\270vinger/\303\270ving_2/stud7/lab-2.zip" (100%) create mode 100644 "\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/oving2.py" create mode 100644 "\303\270vinger/\303\270ving_2/stud7/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud8/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud8/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud8/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud8/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud8/ulike_typer_if_setninger.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud9/aarstider.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud9/funksjoner_og_kalkulasjoner.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud9/lab-2.md" create mode 100644 "\303\270vinger/\303\270ving_2/stud9/logiske_operatorer_uttrykk.ipynb" create mode 100644 "\303\270vinger/\303\270ving_2/stud9/ulike_typer_if_setninger.ipynb" diff --git a/lectures/chap1/lab/lf/intro_til_jupyter.ipynb b/lectures/chap1/lab/lf/intro_til_jupyter.ipynb new file mode 100644 index 0000000..a640702 --- /dev/null +++ b/lectures/chap1/lab/lf/intro_til_jupyter.ipynb @@ -0,0 +1,373 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Introduksjon til Jupyter\n", + "\n", + "Hei, og velkommen til Jupyter, en annen måte å skrive kode på! Jupyter er et system som lar deg lage dokumenter som inneholder både tekst og kode på en gang. Det fine her er at du kan kjøre koden i dokumentet og se resultatet umiddelbart. Dette kan du prøve ut nå. \n", + "\n", + "**oppgave a)** Klikk på kodeblokken under og trykk `ctrl + enter` på tastaturet for å kjøre koden. (Det er også mulig å klikke på kodeblokken for så å klikke `run` i menyen på toppen)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velkommen til Jupyter\n" + ] + } + ], + "source": [ + "print(\"Velkommen til Jupyter\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser kommer resultatet av koden ut rett nedenfor kodeblokken. Dette er veldig praktisk og du kan kjøre koden så mange ganger du vil! Hvis du trykker på `ctrl + enter` i kodeblokken over en gang til vil du se at tallet til venstre for kodeblokken øker. Dette tallet brukes bare som referanse og er ikke noe du trenger å tenke på til vanlig.\n", + "\n", + "Alle kodeblokker i et dokument kan endres på, og dette oppfordres på det sterkeste! Det er mye god læring i å endre kode, tenke seg til hva som skal skje og sjekke om dette faktisk skjer. Du kan for eksempel prøve å kjøre programmet under med `ctrl + enter`, gjøre et par endringer og sjekke om den nye versjonen din gjør det du hadde tenkt." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave b)** Endre første linje i koden under til `print(\"Dette er mitt første Jupyter-program\")`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dette er mitt første Jupyter-program\n", + "Nå skal programmet stille et spørsmål\n", + "Hei Ola\n", + "Da er du 35 år gammel om 5 år\n" + ] + } + ], + "source": [ + "print(\"Dette er mitt første Jupyter-program\") #endre denne linjen\n", + "print(\"Nå skal programmet stille et spørsmål\")\n", + "navn = input(\"Hva heter du? \")\n", + "print(\"Hei\", navn)\n", + "\n", + "alder = int(input(\"Hvor gammel er du? \")) # Her må du kun skrive et tall\n", + "print(\"Da er du\", alder + 5, \"år gammel om 5 år\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Variabler mellom kodeblokker" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Noe som er verdt å merke seg er at data kan eksistere mellom kodeblokkene i en Jupyter Notebook. La oss se på et eksempel. Trykk `ctrl + enter` i kodeblokken nedenfor slik at den kjører." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "message = \"Wow! Dette var kult!\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Kjør så kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(message)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser får vi printet ut verdien av `message` selv om `message` ikke er definert i den nederste kodeblokken. Dette kan være veldig praktisk, men kan noen ganger være forvirrende. Prøv å endre på verdien til `message` (\"Wow! Dette var kult!\") i den første kodeblokken, for så å trykke `ctrl + enter` i den andre blokken.\n", + "\n", + "Som du ser er ikke `message` blitt oppdatert. Dette er fordi **vi er nødt til å kjøre kodeblokken med `message =` for at `message` skal bli oppdatert**. \n", + "\n", + "Prøv nå å kjøre kodeblokken med `message =` igjen for så å kjøre blokken med `print` på nytt. Da burde riktig melding printes.\n", + "\n", + "**Oppgave c)** Endre message til `\"Wow, Jupyter er kult!\"`, og print det ut i blokken under.\n", + "\n", + "Dette gjelder ikke bare for *variabler*, men også for *funksjoner*, som dere skal lære å bruke etterhvert. Hvis du skriver en funksjon og ønsker å bruke den i en annen kodeblokk må du kjøre kodeblokken hver gang funksjonen endres akkurat som med variabler." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wow! Jupyter er kult!\n" + ] + } + ], + "source": [ + "message = \"Wow! Jupyter er kult!\"\n", + "\n", + "print(message)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Restarting dersom problemer skulle oppstå" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du ønsker å fjerne all output fra dokumentet og *starte på nytt* kan du trykke på `Kernel -> Restart and clear output` i menyen på toppen. Det vil komme opp en boks med en skummel rød knapp, men dette går helt fint. Å kunne restarte kan også være nyttig hvis dokumentet henger seg opp. Dette skal vi se et eksempel på nå.\n", + "\n", + "Kjør kodeblokken under to ganger uten å taste inn noe i inputfeltet som dukker opp (du må trykke på blokken igjen for å kjøre den andre gang)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "navn = input(\"Hva heter du?\")\n", + "print(\"Hei,\", navn)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dette var veldig uheldig. Nå skjer det ingenting og vi kan heller ikke kjøre andre kodeblokker i dokumentet :(\n", + "\n", + "Når en kodeblokk venter på input kan man ikke kjøre andre kodeblokker, så hvis man da prøver å kjøre andre kodeblokker vil disse bli satt på vent.\n", + "\n", + "Nå ser vi at det står `In [*]` ved flere av blokkene våre, dette betyr at de venter på andre blokker før de selv kjører, i vårt tilfelle kjørte vi input-blokken på nytt, uten å gi inn noe til forrige kjøring av blokken. Programmet venter fortsatt på input til forrige kjøring av blokken, selv om feltet er borte, som ikke er helt optimalt! Om du ikke forstår helt hva som skjer her er ikke det noe farlig. For å komme oss ut av dette kan vi restarte med `Kernel -> Restart and clear output` i toppmenyen. **Merk: Dette endrer ikke på koden du selv har skrevet.**\n", + "\n", + "**Oppgave d)** Restart notebooken med kommandoen beskrevet over." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Endring av tekst" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er også mulig å endre på teksten i et dokument ved å dobbelklikke på en tekstboks, men dette er noe du sjeldent trenger å gjøre. For å gjøre teksten «vanlig» igjen etter at du har endret trykker du her også på `ctrl + enter`.\n", + "\n", + "Jupyter bruker noe som heter markdown til formatering av tekst. Dette er ikke pensum, men hvis du ønsker å se litt på det finnes det en ganske fin oversikt (på engelsk) [her](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet?fbclid=IwAR2PRFaYr3YAPnKBzNRpgaumRufU4WHbT6Xd-0v9EsJwxtgqxOyzLluvPOA#tables). Det er også mulig å legge til LaTeX (et tekst-format til å lage fine matteuttrykk) i jupyter-tekstbokser. Dette er heller ikke pensum.\n", + "\n", + "Hvis vi skal be dere om et tekst-svar vil vi dere se noe sånt som under. Her kan dere selv fjerne det som står inne i krokodilletegnene.\n", + "\n", + "**Oppgave e)** Endre tekstboksen under til `Programmering er gøy`. *Merk: I en tekstboks trenger man ikke skrive python-kode*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Ditt svar:** <dobbelklikk her for å svare\\>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# En advarsel" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Jupyter er generelt ikke så glad i at du har samme dokument åpnet i flere faner. Hvis du har dette er det mulig at endringene du gjør i den ene fanen overskriver endringene du gjør i en annen fane, noe som kan være uheldig. Sørg derfor for at du aldri har mer enn en fane åpnet med det samme dokumentet." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Til slutt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange muligheter som ligger inne i jupyter, og vi skal ikke bruke alt i dette kurset. Det er ingenting som hindrer dere fra i å finne andre jupyter-notatbøker på nettet selv hvis dere ønsker mer utfordring eller å utforske hva som er mulig.\n", + "\n", + "**Lykke til videre med jupyter!**" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap1/lab/lf/lab-1.md b/lectures/chap1/lab/lf/lab-1.md new file mode 100644 index 0000000..548bb68 --- /dev/null +++ b/lectures/chap1/lab/lf/lab-1.md @@ -0,0 +1,14 @@ +# Lab-1 + +### Læringsutbytte + +* Komme i gang med jupyter (skjønne forskjellen mellom markdown, python, html) +* Kunne skrive enkel Python program som inneholder: kommentar, kode som skriver til skjerm og leser fra tastatur. +* Kunne definere variabler +* Kunne konvertere mellom enkle datatyper + +### Læringsaktiviteter + +* [Introduksjon til Jupyter](intro_til_jupyter.ipynb) +* [Tall- og Typekonvertering](tall_og_typekonvertering.ipynb) +* [Variabler](variabler.ipynb) diff --git a/lectures/chap1/lab/lf/tall_og_typekonvertering.ipynb b/lectures/chap1/lab/lf/tall_og_typekonvertering.ipynb new file mode 100644 index 0000000..bd0b738 --- /dev/null +++ b/lectures/chap1/lab/lf/tall_og_typekonvertering.ipynb @@ -0,0 +1,1047 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Tall- og Typekonvertering\n", + "\n", + "**Læringsmål:**\n", + "\n", + "* Datatyper\n", + "* Konvertering mellom datatyper\n", + "* Funksjoner\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## Tutorial: Datatyper" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "I Python, og andre programmeringsspråk, kan data ha forskjellige _typer_. Forskjellige datatyper egner seg for forskjellige bruksområder. For eksempel hvis vi skal lagre alderen til en person, vil det lønne seg å lagre dette i en `int`. Navnet til samme person, derimot, bør være en `string`. \n", + "\n", + "Det finnes mange forksjellige datatyper, men vi skal ikke gå igjennom alle her. Det kommer i en senere øving. De du skal lære her er:\n", + "\n", + "* **Integer** - et heltall. F.eks `10`. I Python brukes `int` for en integer\n", + "* **Float** - et flyttall (tall med desimal). F.eks `10.5`\n", + "* **String** - tekst. F.eks `\"ITGK\"`. I Python brukes `str` for en string\n", + "* **Boolean** - sannhetsverdi. Enten `True` eller `False`. I Python brukes `bool` for boolean\n", + "* **List** - en liste med verdier. En liste inneholder variabler/verdier av hvilken som helst datatype. F.eks `[1, 2, \"Er ITGK kult?\", True]`\n", + "* **ndarray**/**np.array** - et array. F.eks `np.array([1,2,3,4])`. \n", + "\n", + "Les mer om de forksjellige datatypene nedenfor:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Integer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Integers er enten et negativt heltall, 0 eller et positivt heltall. Som kjent fra matematikken er Integers tallene denotert som $\\mathbb{Z}$. (les mer om Integers i matematikken [her](https://en.wikipedia.org/wiki/Integer). La oss nå lage noen ints i Python, det er utrolig lett. Kjør kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = -10\n", + "b = 0\n", + "c = 10" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Integers følger et set med regler, akkurat som i matematikken. Vi kan for eksempel addere integers, hvor resultatet også vil være en integer. Det samme gjelder for multiplikasjon. Utfører vi _divisjon_ med to integers derimot, vil resultatet være en `float`. La oss gjøre litt aritmetiske operasjoner på ints. Prøv å kjøre kodeblokken under:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(a + b) # Samme som å si -10 + 0\n", + "print(b - c) # Samme som 0 - 10\n", + "print(a * c) # Samme som -10 * 10\n", + "print(b * c) # Samme som 0 * c\n", + "print(a / b) # Samme som -10 : 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Whoops, ser du koden over ga en feilmelding? Karer du å se hva feilen er? Hvis ikke er ikke det så farlig, vi forteller deg nå; på siste linje prøver vi å dele på `0`. Dette vet vi fra matematikken at er fyfy, og det samme gjelder i Python. Det som er fint med Python ovenfor matetmatikken er at Python sier ifra når du gjør noe som ikke er lov, slik som over. Det aller verste som kan skje er at programmet kræsjer, og vi må fikse opp i bugs. Se om du klarer å fikse opp i feilen over, slik at programmet kjører uten å kræsje." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Float" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Floats oppfører seg på nesten samme måte som Integers. De består av de rasjonale tallene $\\mathbb{Q}$. De skiller seg fra Integers ved at de kan ligge mellom heltall. La oss lage noen floats. Kjør kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "d = 1.2\n", + "e = -4.2\n", + "f = 0.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "På samme måte som med `int`s kan vi utføre aritmetiske operasjoner på floats. Kjør kodeblokken under og se at du forstår hva som skjer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(c + e) # Samme som 1.2 + (-4.2)\n", + "print(c - e) # Samme som 1.2 - (-4.2)\n", + "print(f * e) # Samme som 0.0 * (4.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### String" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "String er en datatype som inneholder tekst. For å lage en streng skriver vi tekst omringet av \"fnutter\". Vi kan bruke både enkeltfnutter `'Jeg er en streng'`, dobbeltfnutter `\"Jeg er en annen streng\"` eller trippelfnutter `\"\"\"Jeg er enda en streng\"\"\"`. Alle tre måtene å skrive strenger på er like riktig, men de har forskjellige bruksområder. Enkelt- og dobbeltfnutter er veldig like. En av forskjellene er at om du bruker enkeltfnutter, kan du ha dobbeltfnutter i teksten uten noe problem, og omvendt ved bruk av dobbeltfnutter. For eksempel `'Ordet \"stein\" kan være både et navn og et objekt man finner i naturen'` eller `\"Ordet 'stein' kan være både et navn og et objekt man finner i naturen\"`. Trippeltfnutter lager såkalte \"multiline\"-strenger. Altså kan vi få strenger på flere linjer. Kjør kodeblokken under og se om du forstår hva som skjer:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "s1 = 'Jeg er en streng med enkeltfnutter'\n", + "s2 = \"Jeg er en streng med dobbeltfnutter\"\n", + "s3 = \"\"\"Jeg er en\n", + "multiline streng\"\"\"\n", + "\n", + "print(s1)\n", + "print(s2)\n", + "print(s3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Vi kan ikke gjøre aritmetiske operasjoner på strenger, på samme måte som `int`s og `float`s. Det betyr derimot ikke at vi ikke kan bruke matematiske operatorer på strenger:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "s4 = '10' + '15' + '20'\n", + "print(s4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "`+` operatoren \"setter sammen\" strenger. Som i eksempelet over setter vi sammen, eller konkatinerer, tre strenger; `'10'`, `'15'` og `'20'`, til én stor streng `'101520'`. Du ser forhåpentligvis at tallene `10`, `15` og `20` _ikke_ blir addert til `45` slik de ville blitt om de var `int`s eller `float`s, men strengene blir konkatinert. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "s5 = '10' * 10\n", + "print(s5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "`*` operatoren ganger strengen antall ganger. I eksempelet over ganger vi strengen `'10'` med `10`, og får den resulterende strengen `'10101010101010101010'` ('10' 10 ganger), ikke `100` som om vi hadde ganget `int`en `10` med `int`en `10`. Operatorene `-` og `/` kan vi ikke bruke på strenger." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Innimellom er det fint å ha andre datatyper inne i strenger. Dette gjøres lett med **f-strings**:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "s6 = f'Jeg er en f-string, og jeg kan ha for eksempel ints i meg: {12345}, eller floats: {123.45}'\n", + "print(s6)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Det som er verdt å merke seg med **f-strings** er at så fort andre datatyper blir inkorporert inne i strengen, er de ikke lenger sin egen datatype. De er nå en del av den nye strengen. F-strings er helt vanlige strenger, men de er litt lettere å formatere de. Inne i krøllparentesene {} kan vi ha stort sett det vi vil, også variabler:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "tall = 12345\n", + "s7 = f'Her er et tall: {tall}'\n", + "print(s7)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Boolean" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "En `bool` er en sannhetsverdi, enten `True` eller `False`, og er en _veldig_ sentral datatype i programmering. Booleans kan brukes for eksempel til å sjekke om en alder er under eller over `18`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "gjort_oving = False\n", + "print(f'Jeg har gjort øvingen min: {gjort_oving}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Senere i emnet vil du lære om if-setninger. Da står booleans sentralt. En liten smakebit her:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### List" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Lister er en annen fundamental datatype i Python. Lister er er en samling av verdier, enten av andre datayper, eller av lister selv. For å lage en liste brukes klammeparantesene []. Inne i klammene legger vi verdiene våre, sparert med komma. Prøv å kjøre kodeblokken under, gjerne endre på verdiene også." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste_med_tall = [1, 2, 3, 4]\n", + "print(f'Her har du en liste med tall: {liste_med_tall}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Du vil lære mer om lister senere, som for eksempel hvordan du henter ut elementer. Det viktigste for nå er å vite hvordan du oppretter en :) Lister kan som sagt inneholde flere forskjellige datatyper:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste_med_forskjellige_verdier = [1.0, 4, True, 'hei på deg']\n", + "print(f'Her har du en liste med forskjellige verdier: {liste_med_forskjellige_verdier}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "På samme måte som strenger kan vi ikke gjøre vanlige matematiske operasjoner på lister. Vi kan derimort gange en liste med et tall, og plusse sammen lister. Oppførselen blir det samme som når vi ganger en streng med et tall, eller plusser sammen to strenger. _Elementente_ i listen blir ikke ganget med tallet, de vil bli replikert X ganger. _Elementene_ i listene vil heller ikke bli plusset sammen ved bruk av `+`, men den ene listen blir lagt til i den andre listen:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "liste_med_tall = [1,2,3,4]\n", + "liste_med_tall2 = [5,6,7,8]\n", + "\n", + "liste2 = liste_med_tall + liste_med_tall2\n", + "print(liste2)\n", + "\n", + "liste3 = liste_med_tall * 10\n", + "print(liste3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial: Konvertering mellom datatyper" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Vi kan ha ulike typer data, som tekststrenger (f.eks. `\"Python\"`), heltall (f.eks. `42`), flyttall (f.eks. `9.80`) og sannhetsverdier (`True`, `False`). Ofte kommer vi i situasjoner hvor vi har data av en viss type, men vi trenger samme data bare med en annen type. Da må vi konvertere dataene. Noen vanlige konverteringsfunksjoner:\n", + "\n", + "**`int()`** - konverterer til heltall.\n", + "- `int('423')` gir 423 (dvs. tekststrengen blir konvertert til et tall). Virker kun hvis tekststrengen faktisk inneholder et heltall.\n", + "- `int(5.69)` gir 5 (dvs. for flyttall blir desimaldelen fjernet)\n", + "\n", + "**`float()`** - konverterer til flyttall\n", + "- `float('5.69')` gir 5.69 (tekststreng konvertert til tall)\n", + "- `float('5')` gir 5.0, dvs. float() virker på tekststrenger enten de inneholder flyttall eller heltall (men ikke på strenger som er noe annet enn tall)\n", + "- `float(5)` gir 5.0\n", + "\n", + "**`str()`** - konverterer til tekststreng\n", + "- `str(42)` gir '42'\n", + "- `str(5.69)` gir '5.69'\n", + "Koden under feiler fordi vi har glemt å konvertere. Kjør den og se hva som skjer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "alder = '13'\n", + "alder_mor = '37'\n", + "sum_alder = alder + alder_mor\n", + "\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n", + "\n", + "sum_alder = int(alder) + int(alder_mor)\n", + "\n", + "print('Gratulerer, til sammen er dere ' + sum_alder + ' år!')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den første feilen viser seg i linjen \"Gratulerer...\" Summen skulle ha blitt 50 år. Men vi har de to alderne fortsatt bare lagret som tekststrenger. Da betyr `+` å hekte sammen strengene, ikke å gjøre noen addisjon. Altså får vi `'13' + '37'` som blir `'1337'` heller enn `13 + 37` som blir `50`. Her måtte vi ha konvertert fra tekst til tall før vi gjorde addisjonen.\n", + "\n", + "Den andre feilen oppstår i den siste print-setningen. Vi har på linjen over kalkulert rett alder, ved å konvertere `alder` og `alder_mor` til `int`. Problemet nå ligger i at vi prøver å legge sammen en `string` og en `int`. Som feilmeldingen sier; \"can only concatenate str (not \"int\") to str\". En mulig løsning er å konvertere `sum_alder` tilbake til `string` nå, slik av vi kan plusse sammen to strenger, eller bruke f-strings. Mulige løsninger vises under:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "alder = '13'\n", + "alder_mor = '37'\n", + "sum_alder = alder + alder_mor\n", + "\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n", + "\n", + "sum_alder = int(alder) + int(alder_mor)\n", + "\n", + "print('Gratulerer, til sammen er dere ' + str(sum_alder) + ' år!')\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Altså: bruker `int()` i linje 7, dette gjør at vi får heltall i variablene `alder` og `alder_mor` så vi blir i stand til å regne med dem. Bruker deretter `str()` i linje 9 så denne opplysningen kan settes sammen med annen tekst og brukes i `print()`. Dette eksemplet viser dermed både et tilfelle hvor vi har tekst men trenger tall, og ett hvor vi har et tall men trenger tekst. Hvis det er vi trenger et desimaltall på alder (f.eks. `13.5`) vil imidlertid koden over ikke funke. Da måtte vi ha brukt funksjonen `float()` der vi nå har brukt `int()`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I koden under er det noe feil. Finn feilene og rett opp i de" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Rett utskrift skal være:\n", + "\n", + "```python\n", + "25\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T11:24:13.550825Z", + "start_time": "2019-07-01T11:24:13.542723Z" + }, + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def legg_sammen_to_tall(a, b):\n", + " return a + b\n", + "\n", + "legg_sammen_to_tall(10, 15)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `legg_til_landskode(telefonnummer, landskode)` som tar inn `telefonnummer` (`int`) og `landskode` (`int`) som parametere og returnerer telefonnummetet prefixet med \"+\", landskode og et mellomrom.\n", + "\n", + "***Skriv koden din i kodeblokken udner***" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+47 12345678\n", + "+46 87654321\n" + ] + } + ], + "source": [ + "# Skriv koden din her\n", + "def legg_til_landskode(telefonnummer, landskode):\n", + " return \"+\" + str(landskode) + \" \" + str(telefonnummer)\n", + "\n", + "\n", + "print(legg_til_landskode(12345678, 47))\n", + "print(legg_til_landskode(87654321, 46))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis du har gjort alt rett, skal kodeblokken under gi ut:\n", + "\n", + "```python\n", + "+47 12345678\n", + "+46 87654321\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "telefonnummer1 = 12345678\n", + "landskode1 = 47\n", + "\n", + "telefonnummer2 = 87654321\n", + "landskode2 = 46\n", + "\n", + "print(legg_til_landskode(telefonnummer1, landskode1))\n", + "print(legg_til_landskode(telefonnummer2, landskode2))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kodeblokken nedenfor innheholder noen variabler. Konverter alle til `int`. **Merk**: Det lurer seg kanskje noen feil i koden!" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = '1'\n", + "b = True\n", + "c = False\n", + "d = '1.5'\n", + "e = '2.45'\n", + "\n", + "a = int(a)\n", + "b = int(b)\n", + "c = int(c)\n", + "d = int(float(d))\n", + "e = int(float(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis du har gjort alt rett, skal kodeblokken under skrive ut:\n", + "\n", + "```python\n", + "a er nå 1\n", + "b er nå 1\n", + "c er nå 0\n", + "d er nå 1\n", + "e er nå 2\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(f'a er nå {a}')\n", + "print(f'b er nå {b}')\n", + "print(f'c er nå {c}')\n", + "print(f'd er nå {d}')\n", + "print(f'e er nå {e}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Lag en funksjon `mult_list_with_x(l, x)` som tar inn en liste `l` og skalar `x` som parametere og returnerer en _liste_ hvor alle elementene er multiplisert med `x`.\n", + "\n", + "***Skriv koden din i kodeblokken nedenfor***" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def mult_list_with_x(l, x):\n", + " return list(np.array(l) * x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis funksjonen din er skrevet rett, skal kodeblokken nedenfor gi output:\n", + "\n", + "```python\n", + "[2.0, 3.0, 4.0, 5.0, 6.0]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[2.0, 3.0, 4.0, 5.0, 6.0]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "liste = [1, 1.5, 2, 2.5, 3]\n", + "skalar = 2\n", + "\n", + "mult_list_with_x(liste, skalar)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Her må du bruke **numpy** og `np.array()`. For å gjøre om fra et array til en liste kan du bruke `list()`. Husk også å importere **numpy** med `import numpy as np`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 2: avrunding av flyttall" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ofte har man flyttall, men trenger heltall, f.eks. hvis man skal bruke innebygde Python-funksjoner som krever heltall som argument, eller skal bruke tallet som indeks til en streng eller liste (som vi vil se senere i pensum). Flyttall kan konverteres til heltall med funksjoner som `int()` eller `round()`. Kodeblokka under viser litt forskjell på hvordan disse virker." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(\"int() bare kutter desimalene, uansett hvor stor eller liten desimaldelen er:\")\n", + "print(\"int(2.25) er\", int(2.25))\n", + "print(\"int(2.5) er\", int(2.5))\n", + "print(\"int(2.99) er\", int(2.99))\n", + "print(\"round() runder av til nærmeste heltall, f.eks.\")\n", + "print(\"round(2.25) er\", round(2.25))\n", + "print(\"round(2.51) er\", round(2.51))\n", + "print(\"Hva hvis tallet er midt mellom to heltall?\")\n", + "print(\"round(2.5) er\", round(2.5))\n", + "print(\"round(3.5) er\", round(3.5))\n", + "print(\"round() bruker en IEEE standard som velger partallet for midt-imellom-situasjoner.\")\n", + "print(\"Mens int() alltid gir heltall kan round() brukes for antall desimaler:\")\n", + "print(\"round(2.5488, 1) blir\", round(2.5488, 1))\n", + "print(\"round(2.5488, 3) blir\", round(2.5488, 3))\n", + "print(\"Med negativt antall desimaler kan vi få round() til å runde større enn heltall:\")\n", + "print(\"round(12345.67, -3) blir\", round(12345.67, -3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser i eksemplet, blir 2.5 rundet av til 2 mens 3.5 blir rundet til 4. Dette kan virke litt uvant, i dagliglivet er man mest kjent med såkalt \"kjøpmannsavrunding\", hvor det alltid rundes opp hvis man er midt mellom (dvs., 2.5 skulle i så fall ha blitt rundet til 3). Konsekvent runding oppover når man er midt mellom har imidlertid en uheldig side, nemlig at man pådrar seg en systematisk feil hvis man har mange data som avrundes. Tenk f.eks. temperaturmålinger for lange perioder, hvor man deretter skal regne ut et snitt for hele perioden. Hvis alle temperaturer som er midt når det gjelder siste brukte siffer, rundes opp, vil snittet for perioden alltid bli litt for høyt. Hvis man i stedet går i partallsretning i alle slike midt mellom situasjoner, vil man runde opp cirka halvparten av gangene og ned cirka halvparten av gangene og dermed unngå slike systematiske feil. Men for kjøpmannen er systematisk runding oppover selvsagt bedre med tanke på å få inn mest mulig penger." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "I tillegg til `int()` og `round()` kan f-strenger \"innebygd\" runde av flyttall:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(f'1.2345 avrundet til 2 desimaler er: {1.2345:.2f}')\n", + "print(f'5.4321 avrundet til 0 desimaler er: {5.4321:.0f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Det som skjer her inne i krøllparentesene her er; `1.2345` er tallet vi ønsker runde av, `:` sier \"rund av det som står til venstre til det som står til høyre\", `.2` sier \"gi meg 2 desimaler\" og `f` sier at typen skal være `float`. Det som er verdt å merke seg er at denne måten å runde av tall på gir deg ikke muligheten til å bruke tallet videre. Tallet er da inkorporert i strengen. Med `round()` og `int()` kan vi bruke det avrundede tallet videre." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `rund_av(tall, desimaler)` som tar inn et tall `tall` som skal avrundes og `desimaler` antall desimaler tallet skal avrundes til som parametere og returnerer det avrundede tallet.\n", + "\n", + "***Skriv koden din i kodeblokken under.***" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def rund_av(tall, desimaler):\n", + " return round(tall, desimaler)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis funksjonen din er skrevet rett, skal kodeblokken under gi følgende output:\n", + "\n", + "```python\n", + "1.23\n", + "1000.0\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.23\n", + "1000.0\n" + ] + } + ], + "source": [ + "print(rund_av(1.23456, 2))\n", + "print(rund_av(1234.5432, -3))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap1/lab/lf/variabler.ipynb b/lectures/chap1/lab/lf/variabler.ipynb new file mode 100644 index 0000000..de167fb --- /dev/null +++ b/lectures/chap1/lab/lf/variabler.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Variable\n", + "\n", + "**Læringsmål:**\n", + "\n", + "* Enkel bruk av variable\n", + "\n", + "* Korrekt navngivning av variable" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 1: variable - grunnleggende intro" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvorfor trenger vi variable? Poenget med variable er å **huske data underveis** i utførelsen av et program.\n", + "\n", + "Variable er derfor et sentralt konsept i programmering, ikke bare i Python men uansett hva slags språk man programmerer i.\n", + "\n", + "Uten variable støter vi fort på en rekke problemer fordi programmet vårt ikke kan huske noe, f.eks. at\n", + "\n", + "* vi må be brukeren gi inn opplysninger på nytt som brukeren har gitt tidligere\n", + "* vi må regne ut på nytt data vi allerede har regnet ut tidligere\n", + "\n", + "Dette sløser tid og strøm og vil i mange tilfeller gjøre programmet fullstendig ubrukelig.\n", + "\n", + "I det lille eksempelprogrammet under, klarer vi oss uten noen variabel, fordi navnet som skrives utkun blir benyttet én gang.\n", + "\n", + " \n", + "```python \n", + "print('Pi, med seks desimaler er 3.141592') \n", + "```\n", + "\n", + " \n", + "```\n", + "Pi, med seks desimaler er 3.141592\n", + ">>>>\n", + "```\n", + "\n", + "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.\n", + "\n", + " \n", + "```\n", + "Pi, med seks desimaler er 3.141592 \n", + "3.141592 er pi, avrundet til seks desimaler.\n", + ">>>>\n", + "```\n", + "\n", + "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:\n", + "\n", + " \n", + "```python\n", + "print('Pi, med seks desimaler er 3.141592')\n", + "print('3.141592 er pi, avrundet til seks desimaler.') \n", + "```\n", + "\n", + "\n", + "```\n", + "Pi, med seks desimaler er 3.141592\n", + "3.141592 er Pi, avrundet til seks desimaler.\n", + "```\n", + "\n", + "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.\n", + "\n", + "Kan vi løse det på en bedre måte? JA - med en variabel for å huske navnet. Koden blir da" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "pi = 3.141592\n", + "print(f'Pi, med seks desimaler er {pi}')\n", + "print(f'{pi} er pi, avrundet til seks desimaler')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dette programmet kan forklares som følger:\n", + "\n", + "* linje 1, til høyre for `=` : verdien vi ønsker å lagre (3.141592)\n", + "* linje 1, til venstre for `=`: oppretter en variabel som heter `pi`.\n", + "* linje 1, tegnet `=`. Dette er **tilordningsoperatoren**. Betyr at verdien av uttrykket på høyre side, verdien 3.141592, blir husket i variabelen kalt `pi`.\n", + "* linje 2, variabelen `pi` brukes sist i f-strengen i print-setningen. Merk at variabelnavnet **ikke** skal ha fnutter rundt seg. Med fnuttter ville ikke akkurat dette programmet kjørt. Ordet pi som står som det tredje ordet i setningen \"{pi} er pi, avrundet til seks desimaler\" er ikke variabelen, her er ordet navn bare del av en tekststreng.\n", + "* linje 3, variabelen `pi` brukes fremst i print-setningen. Igjen uten fnutter; det er ikke ordet pi vi ønsker å skrive, men den verdien som variabelen `pi` inneholder (f.eks. 3.141592)\n", + "\n", + "Ved hjelp av variabelen som her ble kalt pi, unngår vi å måtte skrive ut verdien to ganger. Vi skriver den bare én gang, i starten av programmet, og husker da opplysningen ved å putte den inn i en variabel.\n", + "\n", + "Videre i programmet kan vi benytte denne variabelen hver gang vi trenger verdien - enten det som her var bare to ganger, eller om det hadde vært flere.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Rask intro til f-strenger" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(f'1 + 1 = {1 + 1}')\n", + "print(f'2 * 2 = {2 * 5}') # Her er det noe feil. Kan du fikse opp?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a) Huske verdier i variable" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Kjør koden under for å se hvordan den virker. Som du vil se, skriver den ut \"Ada\" to ganger, og \"LBAS2002\" to ganger.\n", + "\n", + "Forbedre koden ved å introdusere en variabel for navn og en annen variabel for favorittfag, slik at vi slipper å skrive \"Ada\" og \"LBAS2002\" mer enn én gang.\n", + "\n", + "Hvis du er i tvil om hvordan du skal angripe problemet, se lignende eksempel i tutorial like over." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei, Ada\n", + "ITGK - interessant!\n", + "Ha en fin dag, Ada\n", + "- og lykke til med ITGK\n" + ] + } + ], + "source": [ + "navn = 'Ada'\n", + "favorittfag = 'ITGK'\n", + "\n", + "print(f'Hei, {navn}')\n", + "print(f'{favorittfag} - interessant!')\n", + "print(f'Ha en fin dag, {navn}')\n", + "print(f'- og lykke til med {favorittfag}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du får til å bruke de to variablene som tenkt, skal kjøringen av det forbedrede programmet se slik ut (men også funke om brukeren skriver inn noe annet enn Ada på spørsmålet Navn? og noe annet enn ITGK på Favorittfag?)\n", + "\n", + "```\n", + "Navn? Ada \n", + "Hei, Ada \n", + "Favorittfag? LBAS2002 \n", + "ITGK - interessant! \n", + "Ha en fin dag, Ada \n", + "- og lykke til med LBAS2002\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 2 - bruk av variable i beregninger" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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. \n", + "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.\n", + "\n", + "**Sirkel og sylinder**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import math\n", + " \n", + "# VERSJON 1, uten variable\n", + "print(\"Areal av sirkelen:\", math.pi * 5.4**2)\n", + "print(\"Volum av sylinderen:\", math.pi * 5.4**2 * 7.9)\n", + " \n", + "print()\n", + " \n", + "# VERSJON 2, med variable\n", + "r = 5.4 # radius for en sirkel\n", + "a_sirkel = math.pi * r**2\n", + "print(\"Areal av sirkelen:\", a_sirkel)\n", + "h = 7.9 # høyde sylinder hvor sirkelen er grunnflate\n", + "v_syl = a_sirkel * h\n", + "print(\"Volum av sylinderen:\", v_syl)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du kjører koden, vil du se at begge gir samme resultat. Hva er da forskjellen?\n", + "\n", + "* Versjon 2 er vesentlig lenger (6 kodelinjer, mot bare 2) fordi det brukes ekstra linjer på variable. Lenger kode er en mulig ulempe. MEN:\n", + "* Formlene i Versjon 2 er lettere å forstå fordi det er intuitive navn som `r`, `h`, `a_sirkel` heller enn bare tall direkte.\n", + "* 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.\n", + "* 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.\n", + "**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", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "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.\n", + "\n", + "***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", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:54:16.358742Z", + "start_time": "2019-07-01T10:54:16.351684Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n", + "Omkrets av sirkelen: 33.929200658769766\n", + "Areal av sirkelen: 91.60884177867838\n", + "Areal av sylinderen: 451.25836876163794\n" + ] + } + ], + "source": [ + "import math\n", + "import numpy as np\n", + " \n", + "r = 5.4\n", + "h = 7.9\n", + "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n", + "omkrets = math.tau * r\n", + "print(\"Omkrets av sirkelen:\", omkrets) #tau er det samme som 2 pi\n", + "areal_sirkel = np.pi * r**2\n", + "print(\"Areal av sirkelen:\", areal_sirkel)\n", + "areal_sylinder = omkrets * h + 2 * areal_sirkel\n", + "print(\"Areal av sylinderen:\", areal_sylinder)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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).\n", + "\n", + " \n", + "```\n", + "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n", + "Omkrets av sirkelen: 33.929200658769766\n", + "Areal av sirkelen: 91.60884177867838\n", + "Areal av sylinderen: 451.25836876163794\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 3: Navngiving av variable" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "`variable = expression`\n", + "\n", + "I dette tilfellet er variable navnet til variabelen, mens expression er verdien. Noen regler for slike tilordningssetninger:\n", + "\n", + "* variabelen som opprettes skal alltid stå på venstre side av uttrykket, og venstre side skal kun inneholde denne variabelen, ikke noe annet\n", + "* 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.\n", + "* variabelnavnet må tilfredsstille følgende regler:\n", + " * 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\n", + " * variabelnavn må begynne med en bokstav eller tegnet _ (understrek)\n", + " * kan ellers inneholde bokstaver, tall og understrek, dvs. kan f.eks. ikke inneholde blanke tegn.\n", + "* Python skiller mellom små og store bokstaver, så `Areal` og `areal` vil være to ulike variable.\n", + "\n", + "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.\n", + "\n", + "Kodeblokka under viser eksempler på variable som funker og ikke funker:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Eksempel på tilordningssetninger som funker\n", + "pokemon_name = \"Tyranitar\"\n", + "MaxCP = 3670\n", + "antall = 3\n", + "antall = antall + 1 # høyre side regnes ut som 3+1, så 4 blir ny verdi i variabelen antall\n", + "resists_fighting = False\n", + "level42 = \"to be done\" # tall er OK i variabelnavn unntatt helt fremst\n", + " \n", + "# Eksempel på tilordninger som IKKE funker\n", + "1 = antall # variabelen må stå på venstre side\n", + "antall + 1 = antall # og v.s. kan KUN inneholde et variabelnavn, ikke et større uttrykk\n", + "10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\n", + "antall = 3 # denne er OK, men se neste linje\n", + "antall = Antall + 1 # Python skiller mellom store og små bokstaver, Antall vil være en annen\n", + " # variabel og gir NameError her fordi den ikke er opprettet i en tidligere setning\n", + "happy hour = 20 # navn kan ikke inneholde mellomrom, burde vært happy_hour eller happyHour\n", + "alkohol% = 4.5 # % kan ikke brukes i variabelnavn (betyr modulo). Samme gjelder andre spesialtegn,\n", + " # hold deg til vanlige bokstaver og tall" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c) Variabelnavn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Prøv å kjør koden under. Som du vil se, funker den ikke pga. diverse feil med variabelnavn og tilordningssetninger. Fiks feilene så programmet kjører som det skal." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Per er 5 år unna idealalderen\n" + ] + } + ], + "source": [ + "fornavn = \"Per\"\n", + "ideal_alder = 42\n", + "kundensAlder = 37\n", + "differanse = ideal_alder - kundensAlder\n", + "print(fornavn, \"er\", differanse, \"år unna idealalderen\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap2/lab/lf/aarstider.ipynb b/lectures/chap2/lab/lf/aarstider.ipynb new file mode 100644 index 0000000..f64d46f --- /dev/null +++ b/lectures/chap2/lab/lf/aarstider.ipynb @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == 'juni':\n", + " if d<21:\n", + " return \"Vår\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m == 'september':\n", + " if d<22:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == 'desember':\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == 'april' or m == 'mai':\n", + " return \"Vår\"\n", + " elif m == 'juli' or m == 'august':\n", + " return \"Sommer\"\n", + " elif m == 'oktober' or m == 'november':\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap2/lab/lf/funksjoner_og_kalkulasjoner.ipynb b/lectures/chap2/lab/lf/funksjoner_og_kalkulasjoner.ipynb new file mode 100644 index 0000000..17a1ca6 --- /dev/null +++ b/lectures/chap2/lab/lf/funksjoner_og_kalkulasjoner.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3\n", + "c = 5*a + b\n", + "d = a * b + c\n", + "e = (-b + 4) / (a - 4)\n", + "f = 5 ** (a * b + 2)\n", + "g = (a + b) * c - d" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def f(x):\n", + " return 2 * x + 1\n", + "\n", + "def g(x):\n", + " return (-4 * x + 2) / (5 * x + 3)\n", + "\n", + "def h(x):\n", + " return x**2 + 2*x + 1\n", + "\n", + "def i(x):\n", + " return np.sqrt(x)\n", + "\n", + "def j(x):\n", + " return np.sin(x) + np.cos(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap2/lab/lf/lab-2.md b/lectures/chap2/lab/lf/lab-2.md new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ b/lectures/chap2/lab/lf/lab-2.md @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git a/lectures/chap2/lab/lf/logiske_operatorer_uttrykk.ipynb b/lectures/chap2/lab/lf/logiske_operatorer_uttrykk.ipynb new file mode 100644 index 0000000..d03752e --- /dev/null +++ b/lectures/chap2/lab/lf/logiske_operatorer_uttrykk.ipynb @@ -0,0 +1,462 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "True: 1, 3, 5\n", + "False: 2, 4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' \\neventuelt:\\nif ((a>70 and a<90) or (a>40 and not a>50)) and ((70<b and b<90) or (b>40 and b<50)):\\n ...\\n(Flere mulige løsninger, men minimal retting gir øverste)\\n'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def gyldige_tall(a, b): \n", + " if ((a>70 and a<90) or (a>40 and not a>50)) and (70<b<90 or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\"\"\" \n", + "eventuelt:\n", + "if ((a>70 and a<90) or (a>40 and not a>50)) and ((70<b and b<90) or (b>40 and b<50)):\n", + " ...\n", + "(Flere mulige løsninger, men minimal retting gir øverste)\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/lectures/chap2/lab/lf/ulike_typer_if_setninger.ipynb b/lectures/chap2/lab/lf/ulike_typer_if_setninger.ipynb new file mode 100644 index 0000000..14c64d5 --- /dev/null +++ b/lectures/chap2/lab/lf/ulike_typer_if_setninger.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vanilje.\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vanilje.\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vanilje.\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " \"\"\"Skriv koden her\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud1/.DS_Store" "b/\303\270vinger/\303\270ving_2/stud1/.DS_Store" new file mode 100644 index 0000000000000000000000000000000000000000..fee4843f77bb5c65d77cb4a0159837960705d9b5 GIT binary patch literal 6148 zcmZQzU|@7AO)+F(5MW?n;9!8z45|#6fRTZLft4YLA(0`8L6^ZOr8qe!DL+34B+S4B zRSx1Xg3Umchf0r9qaiRF0;3@?8UmvsFd71bC<H+DHmLsR9z<>$b;@W6jE2DA2mw&} zpaAMCFfcGUK<Neu4U%GDWPo%57#SE?U@nIA0~kPZAgv%8q!mPiv@$S)SYR_Cy$439 zRz`3)1f&ntB>~Z3?F@`yn?ZcAb_PbU%?u2T5bX?%P@5S+y%><W5bX?%5bX?%VB2A? z8>L4>U^E0^A;1h_2!QH;R|W>G{eOs(QF1f{Mnhn@h5#drOR$R*sPe?&Lr|TY0F?u= yK~*s$s7{9H0awMaMgS9JKv4p!98}$dt71k-8v?`!X&-F}zyfHL9u0v32mt`eR1(Gj literal 0 HcmV?d00001 diff --git "a/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb" new file mode 100644 index 0000000..0ae7319 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb" @@ -0,0 +1,159 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vår\n", + "vinter\n", + "høst\n" + ] + } + ], + "source": [ + "def arstid(maned, dag):\n", + "\n", + " if maned in ['januar', 'februar']:\n", + " return \"vinter\"\n", + " if maned in ['april', 'mai',]:\n", + " return \"vår\"\n", + " if maned in ['juni', 'juli', 'august']:\n", + " return \"sommer\"\n", + " if maned in [\"oktober\", 'november']:\n", + " return \"høst\"\n", + " \n", + " if maned == 'mars' and dag >= 20:\n", + " return \"vår\"\n", + " else: \n", + " return \"vinter\"\n", + " if maned == 'juni' and dag >= 20:\n", + " return \"sommer\"\n", + " else:\n", + " return \"vår\"\n", + " if maned == 'september' and dag >= 21:\n", + " return \"høst\"\n", + " else:\n", + " return \"sommer\"\n", + " if maned == 'desember' and dag >= 21:\n", + " return \"vinter\"\n", + " else:\n", + " return \"høst\"\n", + "\n", + "print(arstid('mars', 20))\n", + "print(arstid('januar', 2))\n", + "print(arstid('november', 17))\n", + " " + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud1/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud1/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..c3ece5e --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud1/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5 * a +b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "\n", + "def f(x):\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5 (v3.11.5:cce6ba91b3, Aug 24 2023, 10:50:31) [Clang 13.0.0 (clang-1300.0.29.30)]" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud1/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud1/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud1/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud1/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud1/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..6bd9fdc --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud1/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "\n", + "if -5 < z and 5 > z:\n", + " print ('True')\n", + "else:\n", + " print ('False')\n", + "\n", + "if not y == 8:\n", + " print ('True')\n", + "else:\n", + " print ('False')\n", + "\n", + "if x == 8 or y == 8:\n", + " print ('True')\n", + "else:\n", + " print ('False')\n", + "\n", + "if not (x <= 3 or y >= 9):\n", + " print ('True')\n", + "else:\n", + " print ('False')\n", + "\n", + "if not (x**2 != 8 and y-z == 5) or x+y == y-z:\n", + " print ('True')\n", + "else:\n", + " print ('False')\n", + "\n", + " " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: Uttrykk 1, 3, og 5 er sant når x = 3, y = 8, z = -3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minst ett av tallene er utenfor et gyldig intervall :(\n" + ] + } + ], + "source": [ + "def gyldige_tall(a, b):\n", + " if (a>70 and a<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)): \n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "a = int(input(\"Gi inn heltall i intervall <40, 50> eller <70,90>\"))\n", + "b = int(input(\"Gi inn heltall i interv all <40, 50> eller <70, 90>\"))\n", + "\n", + "resultat = gyldige_tall(a,b)\n", + "print(resultat)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud1/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud1/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..ff60430 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud1/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,407 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis!\n", + "-------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis!\n", + "-------------------------------\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis!\n", + "-------------------------------\n" + ] + } + ], + "source": [ + "#tid = input(\"Hvor lenge har kaken vært i ovnen?\")\n", + "\n", + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + "\n", + " print(\"Kaken kan tas ut av ovnen\")\n", + "\n", + " print(\"Tips til servering: vaniljeis!\")\n", + " print(\"-------------------------------\")\n", + "\n", + "\n", + "kake_ut_av_ovnen_losning(35)\n", + "\n", + "kake_ut_av_ovnen_losning(50)\n", + "\n", + "kake_ut_av_ovnen_losning(65)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5 (v3.11.5:cce6ba91b3, Aug 24 2023, 10:50:31) [Clang 13.0.0 (clang-1300.0.29.30)]" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud10/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud10/aarstider.ipynb" new file mode 100644 index 0000000..69a43c8 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud10/aarstider.ipynb" @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vår\n", + "Vinter\n", + "Sommer\n", + "Høst\n", + "Vår\n", + "Vinter\n", + "Sommer\n", + "Høst\n" + ] + } + ], + "source": [ + "def arstid(maned, dag):\n", + " if maned in [\"januar\", \"februar\", \"mars\"]:\n", + " return \"Vinter\"\n", + " if maned in [\"april\", \"mai\"]:\n", + " return \"Vår\"\n", + " if maned in [\"juli\", \"august\"]:\n", + " return \"Sommer\"\n", + " if maned in [\"oktober\", \"november\"]:\n", + " return \"Høst\"\n", + " if maned == \"mars\":\n", + " if dag >= 20:\n", + " return \"Vår\"\n", + " else: \n", + " return \"Vinter\"\n", + " if maned == \"juni\":\n", + " if dag >= 21:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Vår\"\n", + " if maned == \"september\":\n", + " if dag >= 22:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Sommer\"\n", + " if maned == \"desember\":\n", + " if dag >= 21:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Høst\"\n", + "\n", + "def arstid_2(maned, dag):\n", + " if (maned == \"desember\" and dag >= 21) or maned == \"januar\" or maned == \"februar\" or (maned == \"mars\" and dag < 20):\n", + " return \"Vinter\"\n", + " elif maned == \"mars\" or maned == \"april\" or maned == \"mai\" or (maned == \"juni\" and dag < 21):\n", + " return \"Vår\"\n", + " elif maned == \"juni\" or maned == \"juli\" or maned == \"august\" or (maned == \"september\" and dag <22):\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + "\n", + "print(arstid(\"april\", 11))\n", + "print(arstid(\"desember\", 24))\n", + "print(arstid(\"september\", 21))\n", + "print(arstid(\"september\", 22))\n", + "\n", + "print(arstid_2(\"april\", 11))\n", + "print(arstid_2(\"desember\", 24))\n", + "print(arstid_2(\"september\", 21))\n", + "print(arstid_2(\"september\", 22))" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud10/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud10/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..c8a0b06 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud10/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,652 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Matematiske utrykk i Python\n", + "* Funksjoner\n", + "\n", + "\n", + "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": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "La $e$ være $\\frac{-b + 4}{a - 4}$\n", + "\n", + "La $f$ være $5^{a * b + 2}$\n", + "\n", + "La $g$ være $[(a + b) * c - d]$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5*a+b\n", + "d = a*b+c\n", + "e = (-b+4)/(a-4)\n", + "f = 5**(a*b+2)\n", + "g = (a+b)*c-d" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "-0.5\n", + "390625\n", + "46\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n", + "-0.5\n", + "390625\n", + "46\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)\n", + "print(e)\n", + "print(f)\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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:\n", + "\n", + "```py\n", + "# Her kan man ikke bruke a eller min_funksjon\n", + "\n", + "a = 1.3 # Assosierer navnet a med et flyttallsobjekt i minnet\n", + "\n", + "# Her kan man bruke a, men ikke min_funksjon\n", + "\n", + "def min_funksjon(): # Assosierer navnet min_funksjon med et funksjonsobjekt i minnet\n", + "\n", + "# Her kan man bruke begge\n", + "```\n", + "\n", + "\n", + "Prøv å kjøre kodeblokken over og se at du ikke får noe output.\n", + "\n", + "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", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "$g(x) = \\frac{-4x + 2}{5x + 3}$\n", + "\n", + "$h(x) = x^2 + 2x + 1$\n", + "\n", + "$i(x) = \\sqrt(x)$\n", + "\n", + "$j(x) = \\sin{x} + \\cos{x}$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Skriv koden din her\n", + "def f(x):\n", + " return 2*x+1\n", + "def g(x):\n", + " return (-4*x+2)/(5*x+3)\n", + "def h(x):\n", + " return x**2+2*x+1\n", + "def i(x):\n", + " return np.sqrt(x)\n", + "def j(x):\n", + " return np.sin(x)+np.cos(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "-0.6428571428571429\n", + "16\n", + "2.0\n", + "-0.6752620891999122\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "-0.6428571428571429\n", + "16\n", + "2.0\n", + "-0.6752620891999122\n" + ] + } + ], + "source": [ + "print(f(10))\n", + "print(g(5))\n", + "print(h(3))\n", + "print(i(4))\n", + "print(j(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 2: Heltallsdivisjon og Modulo:\n", + "\n", + "Les gjerne denne før du begynner på neste oppgave" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I tillegg til vanlig divisjon / har Python også heltallsdivisjon som skrives // og modulo som skrives med operatoren %.\n", + "\n", + "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.\n", + "\n", + "Tabellen under illustrerer hvordan disse operatorene virker:\n", + "\n", + "**Utrykk i Python**|**Resultat**|**Forklaring**\n", + "---|---|---\n", + "17 / 5\t|3.4\t|Vanlig divisjon\n", + "17 // 5|\t3\t|Heltallsdivisjon, gir hvor mange hele ganger nevneren 5 går opp i telleren 17\n", + "17 % 5\t|2|\tModulo, gir resten av 17 // 5, dvs. de 2 som blir til over\n", + "7.75 / 2.5\t|3.1|\tVanlig divisjon\n", + "7.75 // 2.5\t|3.0|\tHeltallsdivisjon, 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.\n", + "7.75 % 2.5\t|0.25|\tModulo, Resten av 7.75//2.5 er 0.25 fordi 2.5 * 3.0 er 7.5\n", + "\n", + "Heltallsdivisjon og modulo har en rekke nyttige bruksområder i programmering.\n", + "\n", + "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.\n", + "\n", + "Koden under viser hvordan // og % kan brukes til slike beregninger. Prøv å kjør den." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "(2, 1)\n" + ] + } + ], + "source": [ + "def antall_hele_uker(dager):\n", + " return dager // 7\n", + "\n", + "def antall_uker_dager(dager):\n", + " uker = dager // 7\n", + " dager = dager % 7\n", + " return uker, dager\n", + "\n", + "print(antall_hele_uker(10))\n", + "print(antall_uker_dager(15))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T09:01:23.971652Z", + "start_time": "2019-07-01T09:01:23.962336Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### c) Bruk av heltallsdivisjon og modulo" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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.\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "def antall_minutt_sekund(sek):\n", + " return sek // 60\n", + "def antall_dogn_timer(timer):\n", + " return timer // 24\n", + "def antall_timer_minutt_sekund(sek):\n", + " timer = sek // (60*60)\n", + " minutt = (sek // 60) % 60\n", + " return timer, minutt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "hidden": true, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "(5, 30)\n" + ] + } + ], + "source": [ + "print(antall_minutt_sekund(120))\n", + "print(antall_dogn_timer(75))\n", + "print(antall_timer_minutt_sekund(19832))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Riktig utskrift hvis du har fått det til, skal bli**\n", + "```\n", + "2\n", + "3\n", + "(5, 30) #siden 19832 sekunder tilsvarer 5 timer, 30 min, 32 sek.\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### d) Konvertering av minutter\n", + "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", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# Skriv koden din her\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud10/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud10/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud10/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud10/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud10/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..6046d20 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud10/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,601 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: 1, 3, 5\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "x=3\n", + "y=8\n", + "z=-3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Tallene er begge i gyldige intervall!\n", + "Minst ett av tallene er utenfor et gyldig intervall :(\n", + "Minst ett av tallene er utenfor et gyldig intervall :(\n", + "Minst ett av tallene er utenfor et gyldig intervall :(\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if ((a>70 and a<90) or (a>40 and not a>=50)) and (70<b<90 or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\n", + "\n", + "print(gyldige_tall(41,49))\n", + "print(gyldige_tall(45,51))\n", + "print(gyldige_tall(69,91))\n", + "print(gyldige_tall(60,89))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\")\n", + " \n", + "def antall_pannekaker(p):\n", + " if p > 10 or p < 0: #Kode mangler her\n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " else:\n", + " r = 10-(p)\n", + " return f\"Da blir det {p} på deg og {r} på meg :D\" \n", + "antall_pannekaker(-100)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Eksempel på kjøring**\n", + "\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\n", + "antall_pannekaker(4)\n", + "Da blir det 4 på deg og 6 på meg :D\n", + "```\n", + " \n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n", + "antall_pannekaker(100)\n", + "Beklager, men det er nok ikke mulig\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "```python\n", + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\")\n", + "\n", + "def antall_pannekaker(n, liker):\n", + " if liker == 'J':\n", + " liker_pannekaker = True\n", + " else:\n", + " liker_pannekaker = False\n", + " ...\n", + "```\n", + "\n", + "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>.\n", + "\n", + "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", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n" + ] + }, + { + "data": { + "text/plain": [ + "'Beklager, men det er nok ikke mulig'" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\")\n", + "def antall_pannekaker(p, liker):\n", + " if liker == 'J':\n", + " liker_pannekaker = True\n", + " else:\n", + " liker_pannekaker = False\n", + " \n", + " if liker_pannekaker==False or p>10 or p<0: #Kode mangler her\n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " else:\n", + " r = 10-p\n", + " return f\"Da blir det {p} på deg og {r} på meg :D\"\n", + "\n", + "antall_pannekaker (-4, 'N') " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Eksempel på kjøring**\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\n", + "antall_pannekaker(5, 'J')\n", + "Da blir det 5 på deg og 5 på meg :D\n", + "```\n", + "\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n", + "antall_pannekaker(7, 'N')\n", + "Beklager, men det er nok ikke mulig\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud10/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud10/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..6843a2c --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud10/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,1476 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + "\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print('Kaken kan tas ut av ovnen.')\n", + " print('Tips til servering: vaniljeis.')\n", + "kake_ut_av_ovnen_losning(60)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:03:17.573938Z", + "start_time": "2019-07-01T10:03:17.564290Z" + }, + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ta utgangspunkt i følgende funksjon, som tar inn antall epler og antall barn som argumenter, og deretter regner ut hvor mange epler det blir på hvert barn." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:06:41.706832Z", + "start_time": "2019-07-01T10:06:37.363889Z" + } + }, + "outputs": [], + "source": [ + "def antall_epler_per_barn(epler, barn):\n", + " # Antall epler til hvert barn\n", + " antall_per = epler // barn\n", + " # Antall epler det er igjen etter at barna har fått sine epler\n", + " antall_rest = epler % barn\n", + " \n", + " return antall_per, antall_rest\n", + "\n", + "antall_per, antall_rest = antall_epler_per_barn(14,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Når en funksjon i Python returnerer mer enn én ting, kan det enten returneres som en liste ved å plassere \"square brackets\" rundt og skille elementene ved komma, eller som en tuppel ved å skille elementene ved komma. Dersom du ønsker å hente ut spesifikke deler av den returnerte dataen, må du enten hente den ut ved å indeksere outputen, eller ved å deklarere variablene på tilsvarende måte som verdiene ble returnert. Vedlagt kode viser de to måtene." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Da blir det 2 epler til hvert barn\n", + "og 2 epler til overs til deg selv.\n", + "Takk for i dag!\n" + ] + } + ], + "source": [ + "tuppel = antall_epler_per_barn(12,5)\n", + "antall_per = tuppel[0]\n", + "antall_rest = tuppel[1]\n", + "\n", + "print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + "print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + "print(\"Takk for i dag!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan hente ut de returnerte variablene direkte ved å gjøre som i eksempelet nedenfor." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Da blir det 2 epler til hvert barn\n", + "og 2 epler til overs til deg selv.\n", + "Takk for i dag!\n" + ] + } + ], + "source": [ + "antall_per, antall_rest = antall_epler_per_barn(12,5)\n", + "\n", + "print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + "print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + "print(\"Takk for i dag!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Under vises to kjøreeksempler med tilsvarende scripts som i de to cellene ovenfor:\n", + "\n", + "**Kjøring 1:**\n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(14, 3)\n", + "\n", + "Da blir det 4 epler til hvert barn \n", + "og 2 epler til overs til deg selv. \n", + "Takk for i dag!\n", + "```\n", + "\n", + "**Kjøring 2:**\n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(3, 0)\n", + "Traceback (most recent call last): \n", + " ... \n", + "ZeroDivisionError: integer division or modulo by zero \n", + "```\n", + "\n", + "\n", + "Det første, hvor brukeren gir tallene 14 og 3 som argumenter, funker fint. Hvis brukeren derimot svarer 0 barn, vil funksjonen gi feilmelding (`ZeroDivisionError`) fordi det er umulig å dele på null. Negativt antall barn vil \"funke\", men ikke gi mening.\n", + "\n", + "___Endre koden slik at de to print-setningene som forteller hvor mange epler det blir til barna og deg selv KUN utføres hvis barn > 0. \"Takk for i dag!\" skal derimot printes uansett.___\n", + "\n", + " Kjøring med barn > 0 skal gi samme resultat som eksemplet øverst. Eksemplet under viser kjøring hvis det skrives 0 for barn:\n", + " \n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(3, 0) \n", + "Takk for i dag!\n", + "```\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Da blir det 4 epler til hvert barn\n", + "og 2 epler til overs til deg selv.\n", + "Takk for i dag!\n", + "Takk for i dag!\n" + ] + } + ], + "source": [ + "def antall_epler_per_barn(epler, barn):\n", + " if barn > 0:\n", + " antall_per = epler // barn \n", + " antall_rest = epler % barn\n", + " print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + " print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + " print(\"Takk for i dag!\")\n", + "\n", + "antall_epler_per_barn(14,3)\n", + "antall_epler_per_barn(12,0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-else-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I eksemplene knyttet til (a) og (b) skulle vi gjøre noe ekstra hvis en betingelse var sann, ellers la være. I andre tilfeller kan vi ønske å gjøre en handling hvis betingelsen er sann, og en alternativ handling hvis den er usann.\n", + "\n", + "Det kan vi oppnå med en **if-else**-setning. Eksemplet nedenfor bygger videre på tilsvarende eksempel for if-setninger." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "start_time": "2019-07-01T10:30:04.105Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.0\n", + "Jeg burde bruke paraply i dag: Nei\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if_else(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " anbefaling = \"Ja\"\n", + " else:\n", + " anbefaling = \"Nei\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_if_else(0.0)\n", + "\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")\n", + "print(hilsen)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I dette eksemplet vil følgende skje hvis vi svarer mer enn 0.2 mm nedbør slik at betingelsen blir sann:\n", + "\n", + "**Eksempel på kjøring med over 0.3 mm nedbør:**\n", + "```\n", + "paraply_if_else(0.3)\n", + "\n", + "Output:\n", + "Jeg burde bruke paraply i dag: Ja\n", + "Ha en fin tur til universitetet!\n", + "```\n", + "\n", + "Svares det derimot et lavere tall, slik at betingelsen blir usann, skjer følgende:\n", + "\n", + "**Eksempel på kjøring med under 0.0 mm nedbør:** \n", + "```\n", + "paraply_if_else(0.0)\n", + "\n", + "Output:\n", + "Jeg burde bruke paraply i dag: Nei\n", + "Ha en fin tur til universitetet!\n", + "```\n", + "\n", + "Altså:\n", + "- Anbefalingen settes til \"Ja\" under `if`-uttrykket bare hvis betingelsen er sann.\n", + "- Setningen som står på innrykk under `else` blir utført bare hvis betingelsen er usann (kunne også hatt flere setninger på innrykk etter `else`).\n", + "- Den siste hilsenen, som ikke har innrykk (Ha en fin tur...), blir returnert uansett." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "I denne deloppgaven skal det lages et program som sjekker om en person kan stemme, altså om personen er 18 år eller eldre. Man må da spørre brukeren om alder og lagre svaret i en variabel, for deretter å sjekke om brukerens alder er 18 eller mer.\n", + "\n", + "**Eksempel på kjøring**\n", + "\n", + "```\n", + "kan_stemme(19)\n", + "\n", + "Output:\n", + "Du kan stemme:)\n", + "```\n", + " \n", + "```\n", + "kan_stemme(18)\n", + "\n", + "Output:\n", + "Du kan stemme:)\n", + "```\n", + " \n", + "```\n", + "kan_stemme(2)\n", + "\n", + "Output:\n", + "Du kan ikke stemme ennå\n", + "```\n", + "\n", + "***Skriv din kode her:***" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du kan stemme :)\n" + ] + } + ], + "source": [ + "def kan_stemme(alder):\n", + " if (alder>= 18):\n", + " print ('Du kan stemme :)')\n", + " else:\n", + " print ('Du kan ikke stemme ennå')\n", + " \n", + "kan_stemme (18)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Fremgangsmåte\n", + "Trykk på pilen til venstre for å lese" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "1. Lag en funksjon som heter `kan_stemme` som tar inn en alder (tall) som argument\n", + "2. Sjekk, vha. if, om personens alder er større eller lik 18 (`alder >= 18`). Om dette er tilfelle skal strengen `\"Du kan stemme:)\"` returneres fra funksjonen\n", + "3. Lag en `else`-blokk som returnerer strenger `\"Du kan ikke stemme ennå\"`\n", + "\n", + "(Det er flere mulige løsninger på denne oppgaven.)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-elif-else-setninger\n", + "Les gjerne denne før du går videre. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I eksemplene vi har sett hittil, har det vært kun to mulige utfall på betingelsene - kaken har stått >= 50 minutt, eller ikke; antall barn er > 0, eller ikke; alder er over 18, eller ikke. I mange praktiske situasjoner kan det være tre eller flere mulige utfall.\n", + "\n", + "F.eks. hvis det var meldt mer enn 3 mm nedbør er kanskje ikke paraply tilstrekkelig, vi ville heller anbefale støvler og regntøy. Vårt tidligere eksempel kunne da utvides som følger:" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 4\n", + "Dagens anbefaling: Støvler og regntøy\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "# EKSEMPEL 1\n", + "\n", + "def paraply_if_elif_else(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 3.0:\n", + " anbefaling = \"Støvler og regntøy\"\n", + " elif regn > 0.2:\n", + " anbefaling = \"Paraply\"\n", + " else:\n", + " anbefaling = \"T-skjorte med NTNU-logo\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " \n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_if_elif_else(4)\n", + "print(f\"Dagens anbefaling: {anbefaling}\")\n", + "print(hilsen)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Under vises tre kjøringer av denne koden:\n", + "\n", + "```\n", + "paraply_if_elif_else(4.2)\n", + "\n", + "Output:\n", + "Regn i mm: 4.2\n", + "Dagens anbefaling: Støvler og regntøy\n", + "Ha en fin tur til universitetet!\n", + ">>>\n", + "```\n", + "\n", + "```\n", + "paraply_if_elif_else(0.3)\n", + "\n", + "Output:\n", + "Regn i mm: 0.3\n", + "Dagens anbefaling: Paraply\n", + "Ha en fin tur til universitetet!\n", + ">>>\n", + "```\n", + "\n", + "```\n", + "paraply_if_elif_else(0.0)\n", + "\n", + "Output:\n", + "Regn i mm: 0.0\n", + "Dagens anbefaling: T-skjorte med NTNU-logo\n", + "Ha en fin tur til universitetet!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis betingelsen `regn > 3.0` er sann, settes anbefalingen til støvler og regntøy, deretter går programmet til første kodelinje etter hele if-elif-else-setningen, og setter hilsenen til (\"Ha en fin tur...\")\n", + "\n", + "Hvis betingelsen `regn > 3.0` er usann, settes **ikke** anbefalingen til støvler, programmet sjekker i stedet betingelsen på `elif`. Hvis denne er sann, settes anbefalingen til paraply, og dersom `elif`-påstanden også er usann, settes anbefalingen til T-skjorte med NTNU-logo som tidligere.\n", + "\n", + "Det er mulig å klare seg uten if-elif-else-setninger og i stedet bare putte if-else-setninger inni hverandre for å oppnå det samme. Eksemplet ovenfor kunne alternativt skrives:" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 2\n", + "def paraply_nested_if(regn):\n", + " if regn > 3.0:\n", + " anbefaling = \"Støvler og regntøy\"\n", + " else:\n", + " if regn > 0.2:\n", + " anbefaling = \"Paraply\"\n", + " else:\n", + " anbefaling = \"T-skjorte med NTNU-logo\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_nested_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Særlig i tilfeller hvor det dreier seg om tre eller flere alternative utfall basert på verdien av den **samme variabelen** (f.eks. `regn` her) vil de fleste oppfatte **if-elif-else**-setninger som både lettere å skrive og lettere å forstå, enn flere nøstede if-else-setninger.\n", + "\n", + "Ett typisk eksempel er antall oppnådde poeng på en eksamen, som kan transformeres til en bokstavkarakter A-F etter gitte grenser. Det er da 6 mulige utfall, dette gir mye innrykk og blir vanskelig å lese med nøstede if-setninger:" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du fikk C\n" + ] + } + ], + "source": [ + "# EKSEMPEL 3\n", + "def hvilken_karakter(score): \n", + " if score >= 89:\n", + " return \"A\"\n", + " else:\n", + " if score >= 77:\n", + " return \"B\"\n", + " else:\n", + " if score >= 65:\n", + " return \"C\"\n", + " else:\n", + " if score >= 53:\n", + " return \"D\"\n", + " else:\n", + " if score >= 41:\n", + " return \"E\"\n", + " else:\n", + " return \"F\"\n", + "\n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "if-elif-else-setning vil være klart å foretrekke i en slik situasjon; det er mye lettere å se at koden her tar en beslutning med 6 alternativer basert på verdien av en enkelt variabel:" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du fikk C\n" + ] + } + ], + "source": [ + "# EKSEMPEL 4\n", + "def hvilken_karakter(score): \n", + " if score >= 89:\n", + " return \"A\"\n", + " elif score >= 77:\n", + " return \"B\"\n", + " elif score >= 65:\n", + " return \"C\"\n", + " elif score >= 53:\n", + " return \"D\"\n", + " elif score >= 41:\n", + " return \"E\"\n", + " else:\n", + " return \"F\"\n", + "\n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ved bruk av if-elif-else er det avgjørende at betingelsene kommer i riktig rekkefølge. Anta at vi hadde gjort karaktereksemplet motsatt:" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du fikk F\n" + ] + } + ], + "source": [ + "# EKSEMPEL 5\n", + "# HER HAR VI MED VILJE HAR GJORT FEIL\n", + "def hvilken_karakter(score): \n", + " if score >= 0:\n", + " return \"F\"\n", + " elif score >= 41:\n", + " return \"E\"\n", + " elif score >= 53:\n", + " return \"D\"\n", + " elif score >= 65:\n", + " return \"C\"\n", + " elif score >= 77:\n", + " return \"B\"\n", + " elif score >= 89:\n", + " return \"A\"\n", + " \n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil øverste betingelse vil være sann for alle eksamensbesvarelser - og alle ender opp med karakteren F.\n", + "\n", + "Det er også viktig når det er snakk om alternativt ekskluderende utfall av samme beslutning at vi bruker **if-elif-else**-setning; **IKKE en serie med frittstående if-setninger**.\n", + "\n", + "Eksempel 6 under ser nesten ut som Eksempel 4, bare at vi kun skriver `if` der vi før skrev `elif`. Merk også at funksjonen her bruker en variabel `karakter` for å holde på karakteren, heller enn å returnere den - dette er gjort for å fremheve feilen som oppstår." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Karakter etter første if: A\n", + "Karakter etter andre if: B\n", + "Karakter etter tredje if: C\n", + "Karakter etter fjerde if: D\n", + "Karakter etter femte if: E\n", + "Du fikk F\n" + ] + } + ], + "source": [ + "# EKSEMPEL 6\n", + "# HER HAR VI MED VILJE HAR GJORT FEIL\n", + "def hvilken_karakter(score):\n", + " karakter = \"\"\n", + " if score >= 89:\n", + " karakter = \"A\"\n", + " print(f\"Karakter etter første if: {karakter}\")\n", + " if score >= 77:\n", + " karakter = \"B\"\n", + " print(f\"Karakter etter andre if: {karakter}\")\n", + " if score >= 65:\n", + " karakter = \"C\"\n", + " print(f\"Karakter etter tredje if: {karakter}\")\n", + " if score >= 53:\n", + " karakter = \"D\"\n", + " print(f\"Karakter etter fjerde if: {karakter}\")\n", + " if score >= 41:\n", + " karakter = \"E\"\n", + " print(f\"Karakter etter femte if: {karakter}\")\n", + " else:\n", + " karakter = \"F\"\n", + " return karakter\n", + "\n", + "hvilken_karakter(92)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "En student som har fått 92 poeng vil her komme riktig ut av den første if-setningen, og karakter settes til A. Men 92 > 77 er også sant, så karakter omgjøres deretter til B. Så til C, så til D, så til E.\n", + "\n", + "De eneste tilfellene som dette programmet vil takle korrekt blir dermed studenter som skal ha E eller F.\n", + "\n", + "Feilen her er at vi bruker nye frittstående if-setninger (dvs. som ikke er relatert til hverandre), mens vi egentlig har å gjøre med gjensidig ekskluderende alternativer som skulle vært løst med if-elif-else.\n", + "\n", + "Hvor er det eventuelt riktig å bruke frittstående if-setninger? Jo, hvis det er snakk om flere uavhengige beslutninger. I eksempel 7 under er det to uavhengige beslutninger, den ene om man skal ta paraply eller ikke, den andre om brodder eller ikke. Hver beslutning tas uavhengig av den andre, da blir det riktig med to frittstående if-setninger.\n", + "\n", + "Hadde vi i stedet brukt if-elif her, ville programmet ikke ha virket som det skulle, da det kun ville ha vært i stand til å anbefale brodder i oppholdsvær (mens det jo kan være minst like glatt om det regner)." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "ExecuteTime": { + "start_time": "2019-07-01T11:00:12.045Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Hvor glatt er det på en skala fra 1 til 10: 9\n", + "Da anbefaler jeg paraply. \n", + "Da anbefaler jeg sko med brodder eller pigger.\n" + ] + } + ], + "source": [ + "# EKSEMPEL 7\n", + "def paraply_og_brodder(regn, glatt):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Hvor glatt er det på en skala fra 1 til 10: {glatt}\")\n", + " anbefaling = \"\"\n", + " if regn > 0.2:\n", + " anbefaling += \"Da anbefaler jeg paraply. \\n\"\n", + " if glatt > 8:\n", + " anbefaling += \"Da anbefaler jeg sko med brodder eller pigger.\"\n", + " return anbefaling\n", + "\n", + "anbefaling = paraply_og_brodder(0.3, 9)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I andre tilfeller kan en beslutning være avhengig av en annen, f.eks. kun være aktuell ved et visst utfall av en foregående if-setning. Som i eksempel 8 under:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 9\n", + "Anbefaler regntøy, for mye vind for paraply.\n" + ] + } + ], + "source": [ + "# EKSEMPEL 8\n", + "def paraply_i_vind(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Da anbefaler jeg paraply.\"\n", + " else:\n", + " return \"Anbefaler regntøy, for mye vind for paraply.\"\n", + "\n", + "anbefaling = paraply_i_vind(0.3, 9)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her ville if `regn > 0.2:` .....`elif vind < 7.0` ha blitt feil.\n", + "\n", + "Programmet ville da ha gjort vurderinger av vinden kun hvis det ikke regnet, og dermed ha vært ute av stand til å fraråde paraply hvis det regner og samtidig blåser kraftig.\n", + "\n", + "**Oppsummert:**\n", + "\n", + "- flere helt uavhengige beslutninger: bruk frittstående if-setninger\n", + "- beslutning med gjensidig utelukkende handlingsalternativer: bruk if-else (2 alternativer) eller if-elif-else (3 eller flere alternativer)\n", + "- beslutninger relatert på annen måte, f.eks. at en betingelse (som `vind < 7.0` ovenfor) kun er aktuell gitt et visst utfall av en annen betingelse: kan løses ved å nøste flere if-setninger inni hverandre\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en utvidet versjon av programmet fra (c) som sier om personen kan stemme eller ikke, med følgende regler:\n", + "\n", + "- `alder >= 18`: Kan stemme både ved lokalvalg og Stortingsvalg\n", + "- `alder >= 16`: Kan stemme ved lokalvalg, men ikke ved Stortingsvalg\n", + "- ellers (`alder < 16`): Kan ikke stemme.\n", + "\n", + "Eksempel på kjøring:\n", + "\n", + "```\n", + "kan_stemme(19)\n", + "\n", + "Output:\n", + "Du kan stemme både ved lokalvalg og Stortingsvalg\n", + ">>>>\n", + "```\n", + "\n", + "```\n", + "kan_stemme(17)\n", + "\n", + "Output:\n", + "Du kan stemme ved lokalvalg, men ikke ved Stortingsvalg\n", + ">>>>\n", + "```\n", + "\n", + "```\n", + "kan_stemme(12)\n", + "\n", + "Output:\n", + "Du kan ikke stemme ennå\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du kan stemme både ved lokalvalg og Stortingsvalg\n" + ] + } + ], + "source": [ + "def kan_stemme(alder):\n", + " if (alder) >=18:\n", + " print('Du kan stemme både ved lokalvalg og Stortingsvalg')\n", + " elif (alder >=16):\n", + " print('Du kan stemme ved lokalvalg, men ikke ved Stortingsvalg')\n", + " else: print('Du kan ikke stemme ennå')\n", + "\n", + "kan_stemme(22)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du skal lage en funskjon som sjekker hvilken billettpris en person skal betale ut ifra alderen til personen og returnerer prisen som et tall.\n", + "\n", + "Oversikt over alder og tilhørende billettpriser:\n", + "\n", + "Aldersgruppe | Billettpris\n", + "--- | ---\n", + "Under 3 år | Gratis\n", + "3-11 år | 30 kr\n", + "12-25 år | 50 kr\n", + "26-66 år | 80 kr\n", + "67 år og over | 40 kr" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80 kr\n" + ] + } + ], + "source": [ + "def bruker_alder(alder):\n", + " if (alder)<3:\n", + " print('Gratis')\n", + " elif (alder)<=11:\n", + " print('30 kr')\n", + " elif (alder)<=25:\n", + " print('50 kr')\n", + " elif (alder)<=66:\n", + " print('80 kr')\n", + " else: print ('40 kr')\n", + "\n", + "bruker_alder(66)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Fremgangsmåte\n", + "Trykk på pilen til venstre" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "1. Først må det lages en funksjon som tar inn alderen til brukeren som argument.\n", + "2. Videre skal man sjekke hvilken billett personen skal ha, og dette gjøres med en if-elif-else-setning:\n", + "\n", + "```\n", + "if alder < 3:\n", + " ...\n", + "elif alder < 12:\n", + " ...\n", + "elif ...:\n", + " ...\n", + "elif ...:\n", + " ...\n", + "else:\n", + " ...\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud11/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud11/aarstider.ipynb" new file mode 100644 index 0000000..e5a78df --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud11/aarstider.ipynb" @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (1883520187.py, line 23)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Cell \u001b[1;32mIn[3], line 23\u001b[1;36m\u001b[0m\n\u001b[1;33m retrun \"Vår\"\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "def arstid(m, d):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return \"Vinter\" \n", + " else:\n", + " return \"Vår\" \n", + " elif m == 'juni':\n", + " if d<21:\n", + " return \"Vår\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m =='september':\n", + " if d<22:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\" \n", + " elif m == 'desember':\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\" \n", + " elif m == 'april' or m == 'mai':\n", + " retrun \"Vår\" \n", + " elif m == 'juli' or m == 'august':\n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud11/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud11/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..3f87180 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud11/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = a * b + c " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "def f(x): \n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud11/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud11/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud11/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud11/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud11/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..53020f8 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud11/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,484 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "x, y, z = 3, 8, -3\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "x, y, z = 3, 8, -3\n", + "\n", + "#uttrykk1 \n", + "print (-5 < z and 5 > z)\n", + "\n", + "#uttrykk2\n", + "print (not y == 8)\n", + "\n", + "#Uttrykk3\n", + "print (x == 8 or y == 8)\n", + "\n", + "#uttrykk4\n", + "print (not (x <= 3 or y >= 9))\n", + "\n", + "#uttrykk5\n", + "print (not (x**2 != 8 and y-z == 5) or x+y == y-z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minst ett av tallene er utenfor et gyldig intervall:(\n" + ] + } + ], + "source": [ + "\n", + "def gyldige_tall(a, b):\n", + " if ((a>70 and a<90) or (a>40 and not a>=50) and (70<b<90) or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall:(\"\n", + "print(gyldige_tall(40,50) or (70,90))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud11/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud11/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..f80ec31 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud11/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 49 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid > 49:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(49)\n", + "kake_ut_av_ovnen(50)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen(tid)\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud12/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_2/stud12/intro_til_jupyter.ipynb" new file mode 100644 index 0000000..59a22e8 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud12/intro_til_jupyter.ipynb" @@ -0,0 +1,370 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Introduksjon til Jupyter\n", + "\n", + "Hei, og velkommen til Jupyter, en annen måte å skrive kode på! Jupyter er et system som lar deg lage dokumenter som inneholder både tekst og kode på en gang. Det fine her er at du kan kjøre koden i dokumentet og se resultatet umiddelbart. Dette kan du prøve ut nå. \n", + "\n", + "**oppgave a)** Klikk på kodeblokken under og trykk `ctrl + enter` på tastaturet for å kjøre koden. (Det er også mulig å klikke på kodeblokken for så å klikke `run` i menyen på toppen)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velkommen til Jupyter\n" + ] + } + ], + "source": [ + "print(\"Velkommen til Jupyter\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser kommer resultatet av koden ut rett nedenfor kodeblokken. Dette er veldig praktisk og du kan kjøre koden så mange ganger du vil! Hvis du trykker på `ctrl + enter` i kodeblokken over en gang til vil du se at tallet til venstre for kodeblokken øker. Dette tallet brukes bare som referanse og er ikke noe du trenger å tenke på til vanlig.\n", + "\n", + "Alle kodeblokker i et dokument kan endres på, og dette oppfordres på det sterkeste! Det er mye god læring i å endre kode, tenke seg til hva som skal skje og sjekke om dette faktisk skjer. Du kan for eksempel prøve å kjøre programmet under med `ctrl + enter`, gjøre et par endringer og sjekke om den nye versjonen din gjør det du hadde tenkt." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave b)** Endre første linje i koden under til `print(\"Dette er mitt første Jupyter-program\")`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dette er mitt første jupyter-program\n", + "Nå skal programmet stille et spørsmål\n", + "Hei Julie\n", + "Da er du 42 år gammel om 5 år\n" + ] + } + ], + "source": [ + "print(\"Dette er mitt første jupyter-program\") #endre denne linjen\n", + "print(\"Nå skal programmet stille et spørsmål\")\n", + "navn = input(\"Hva heter du? \")\n", + "print(\"Hei\", navn)\n", + "\n", + "alder = int(input(\"Hvor gammel er du? \")) # Her må du kun skrive et tall\n", + "print(\"Da er du\", alder + 5, \"år gammel om 5 år\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Variabler mellom kodeblokker" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Noe som er verdt å merke seg er at data kan eksistere mellom kodeblokkene i en Jupyter Notebook. La oss se på et eksempel. Trykk `ctrl + enter` i kodeblokken nedenfor slik at den kjører." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "message = \"Wow! Jupyter er kult!\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Kjør så kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wow! Jupyter er kult!\n" + ] + } + ], + "source": [ + "print(message)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser får vi printet ut verdien av `message` selv om `message` ikke er definert i den nederste kodeblokken. Dette kan være veldig praktisk, men kan noen ganger være forvirrende. Prøv å endre på verdien til `message` (\"Wow! Dette var kult!\") i den første kodeblokken, for så å trykke `ctrl + enter` i den andre blokken.\n", + "\n", + "Som du ser er ikke `message` blitt oppdatert. Dette er fordi **vi er nødt til å kjøre kodeblokken med `message =` for at `message` skal bli oppdatert**. \n", + "\n", + "Prøv nå å kjøre kodeblokken med `message =` igjen for så å kjøre blokken med `print` på nytt. Da burde riktig melding printes.\n", + "\n", + "**Oppgave c)** Endre message til `\"Wow, Jupyter er kult!\"`, og print det ut i blokken under.\n", + "\n", + "Dette gjelder ikke bare for *variabler*, men også for *funksjoner*, som dere skal lære å bruke etterhvert. Hvis du skriver en funksjon og ønsker å bruke den i en annen kodeblokk må du kjøre kodeblokken hver gang funksjonen endres akkurat som med variabler." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Restarting dersom problemer skulle oppstå" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du ønsker å fjerne all output fra dokumentet og *starte på nytt* kan du trykke på `Kernel -> Restart and clear output` i menyen på toppen. Det vil komme opp en boks med en skummel rød knapp, men dette går helt fint. Å kunne restarte kan også være nyttig hvis dokumentet henger seg opp. Dette skal vi se et eksempel på nå.\n", + "\n", + "Kjør kodeblokken under to ganger uten å taste inn noe i inputfeltet som dukker opp (du må trykke på blokken igjen for å kjøre den andre gang)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei, Julie\n" + ] + } + ], + "source": [ + "navn = input(\"Hva heter du?\")\n", + "print(\"Hei,\", navn)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dette var veldig uheldig. Nå skjer det ingenting og vi kan heller ikke kjøre andre kodeblokker i dokumentet :(\n", + "\n", + "Når en kodeblokk venter på input kan man ikke kjøre andre kodeblokker, så hvis man da prøver å kjøre andre kodeblokker vil disse bli satt på vent.\n", + "\n", + "Nå ser vi at det står `In [*]` ved flere av blokkene våre, dette betyr at de venter på andre blokker før de selv kjører, i vårt tilfelle kjørte vi input-blokken på nytt, uten å gi inn noe til forrige kjøring av blokken. Programmet venter fortsatt på input til forrige kjøring av blokken, selv om feltet er borte, som ikke er helt optimalt! Om du ikke forstår helt hva som skjer her er ikke det noe farlig. For å komme oss ut av dette kan vi restarte med `Kernel -> Restart and clear output` i toppmenyen. **Merk: Dette endrer ikke på koden du selv har skrevet.**\n", + "\n", + "**Oppgave d)** Restart notebooken med kommandoen beskrevet over." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Endring av tekst" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er også mulig å endre på teksten i et dokument ved å dobbelklikke på en tekstboks, men dette er noe du sjeldent trenger å gjøre. For å gjøre teksten «vanlig» igjen etter at du har endret trykker du her også på `ctrl + enter`.\n", + "\n", + "Jupyter bruker noe som heter markdown til formatering av tekst. Dette er ikke pensum, men hvis du ønsker å se litt på det finnes det en ganske fin oversikt (på engelsk) [her](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet?fbclid=IwAR2PRFaYr3YAPnKBzNRpgaumRufU4WHbT6Xd-0v9EsJwxtgqxOyzLluvPOA#tables). Det er også mulig å legge til LaTeX (et tekst-format til å lage fine matteuttrykk) i jupyter-tekstbokser. Dette er heller ikke pensum.\n", + "\n", + "Hvis vi skal be dere om et tekst-svar vil vi dere se noe sånt som under. Her kan dere selv fjerne det som står inne i krokodilletegnene.\n", + "\n", + "**Oppgave e)** Endre tekstboksen under til `Programmering er gøy`. *Merk: I en tekstboks trenger man ikke skrive python-kode*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Programmering er gøy" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# En advarsel" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Jupyter er generelt ikke så glad i at du har samme dokument åpnet i flere faner. Hvis du har dette er det mulig at endringene du gjør i den ene fanen overskriver endringene du gjør i en annen fane, noe som kan være uheldig. Sørg derfor for at du aldri har mer enn en fane åpnet med det samme dokumentet." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Til slutt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange muligheter som ligger inne i jupyter, og vi skal ikke bruke alt i dette kurset. Det er ingenting som hindrer dere fra i å finne andre jupyter-notatbøker på nettet selv hvis dere ønsker mer utfordring eller å utforske hva som er mulig.\n", + "\n", + "**Lykke til videre med jupyter!**" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud12/lab-1.md" "b/\303\270vinger/\303\270ving_2/stud12/lab-1.md" new file mode 100644 index 0000000..548bb68 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud12/lab-1.md" @@ -0,0 +1,14 @@ +# Lab-1 + +### Læringsutbytte + +* Komme i gang med jupyter (skjønne forskjellen mellom markdown, python, html) +* Kunne skrive enkel Python program som inneholder: kommentar, kode som skriver til skjerm og leser fra tastatur. +* Kunne definere variabler +* Kunne konvertere mellom enkle datatyper + +### Læringsaktiviteter + +* [Introduksjon til Jupyter](intro_til_jupyter.ipynb) +* [Tall- og Typekonvertering](tall_og_typekonvertering.ipynb) +* [Variabler](variabler.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud12/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_2/stud12/tall_og_typekonvertering.ipynb" new file mode 100644 index 0000000..c5c1d8a --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud12/tall_og_typekonvertering.ipynb" @@ -0,0 +1,1212 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Tall- og Typekonvertering\n", + "\n", + "**Læringsmål:**\n", + "\n", + "* Datatyper\n", + "* Konvertering mellom datatyper\n", + "* Funksjoner\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## Tutorial: Datatyper" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "I Python, og andre programmeringsspråk, kan data ha forskjellige _typer_. Forskjellige datatyper egner seg for forskjellige bruksområder. For eksempel hvis vi skal lagre alderen til en person, vil det lønne seg å lagre dette i en `int`. Navnet til samme person, derimot, bør være en `string`. \n", + "\n", + "Det finnes mange forksjellige datatyper, men vi skal ikke gå igjennom alle her. Det kommer i en senere øving. De du skal lære her er:\n", + "\n", + "* **Integer** - et heltall. F.eks `10`. I Python brukes `int` for en integer\n", + "* **Float** - et flyttall (tall med desimal). F.eks `10.5`\n", + "* **String** - tekst. F.eks `\"ITGK\"`. I Python brukes `str` for en string\n", + "* **Boolean** - sannhetsverdi. Enten `True` eller `False`. I Python brukes `bool` for boolean\n", + "* **List** - en liste med verdier. En liste inneholder variabler/verdier av hvilken som helst datatype. F.eks `[1, 2, \"Er ITGK kult?\", True]`\n", + "* **ndarray**/**np.array** - et array. F.eks `np.array([1,2,3,4])`. \n", + "\n", + "Les mer om de forksjellige datatypene nedenfor:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Integer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Integers er enten et negativt heltall, 0 eller et positivt heltall. Som kjent fra matematikken er Integers tallene denotert som $\\mathbb{Z}$. (les mer om Integers i matematikken [her](https://en.wikipedia.org/wiki/Integer). La oss nå lage noen ints i Python, det er utrolig lett. Kjør kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = -10\n", + "b = 0\n", + "c = 10" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Integers følger et set med regler, akkurat som i matematikken. Vi kan for eksempel addere integers, hvor resultatet også vil være en integer. Det samme gjelder for multiplikasjon. Utfører vi _divisjon_ med to integers derimot, vil resultatet være en `float`. La oss gjøre litt aritmetiske operasjoner på ints. Prøv å kjøre kodeblokken under:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-10\n", + "-10\n", + "-100\n", + "0\n", + "-1.0\n" + ] + } + ], + "source": [ + "print(a + b) # Samme som å si -10 + 0\n", + "print(b - c) # Samme som 0 - 10\n", + "print(a * c) # Samme som -10 * 10\n", + "print(b * c) # Samme som 0 * c\n", + "print(a / c) # Samme som -10 : 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Whoops, ser du koden over ga en feilmelding? Karer du å se hva feilen er? Hvis ikke er ikke det så farlig, vi forteller deg nå; på siste linje prøver vi å dele på `0`. Dette vet vi fra matematikken at er fyfy, og det samme gjelder i Python. Det som er fint med Python ovenfor matetmatikken er at Python sier ifra når du gjør noe som ikke er lov, slik som over. Det aller verste som kan skje er at programmet kræsjer, og vi må fikse opp i bugs. Se om du klarer å fikse opp i feilen over, slik at programmet kjører uten å kræsje." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Float" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Floats oppfører seg på nesten samme måte som Integers. De består av de rasjonale tallene $\\mathbb{Q}$. De skiller seg fra Integers ved at de kan ligge mellom heltall. La oss lage noen floats. Kjør kodeblokken nedenfor:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "d = 1.2\n", + "e = -4.2\n", + "f = 0.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "På samme måte som med `int`s kan vi utføre aritmetiske operasjoner på floats. Kjør kodeblokken under og se at du forstår hva som skjer:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-3.0\n", + "5.4\n", + "-0.0\n" + ] + } + ], + "source": [ + "print(d + e) # Samme som 1.2 + (-4.2)\n", + "print(d - e) # Samme som 1.2 - (-4.2)\n", + "print(f * e) # Samme som 0.0 * (4.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### String" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "String er en datatype som inneholder tekst. For å lage en streng skriver vi tekst omringet av \"fnutter\". Vi kan bruke både enkeltfnutter `'Jeg er en streng'`, dobbeltfnutter `\"Jeg er en annen streng\"` eller trippelfnutter `\"\"\"Jeg er enda en streng\"\"\"`. Alle tre måtene å skrive strenger på er like riktig, men de har forskjellige bruksområder. Enkelt- og dobbeltfnutter er veldig like. En av forskjellene er at om du bruker enkeltfnutter, kan du ha dobbeltfnutter i teksten uten noe problem, og omvendt ved bruk av dobbeltfnutter. For eksempel `'Ordet \"stein\" kan være både et navn og et objekt man finner i naturen'` eller `\"Ordet 'stein' kan være både et navn og et objekt man finner i naturen\"`. Trippeltfnutter lager såkalte \"multiline\"-strenger. Altså kan vi få strenger på flere linjer. Kjør kodeblokken under og se om du forstår hva som skjer:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jeg er en streng med enkeltfnutter\n", + "Jeg er en streng med dobbeltfnutter\n", + "Jeg er en\n", + "multiline streng\n" + ] + } + ], + "source": [ + "s1 = 'Jeg er en streng med enkeltfnutter'\n", + "s2 = \"Jeg er en streng med dobbeltfnutter\"\n", + "s3 = \"\"\"Jeg er en\n", + "multiline streng\"\"\"\n", + "\n", + "print(s1)\n", + "print(s2)\n", + "print(s3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Vi kan ikke gjøre aritmetiske operasjoner på strenger, på samme måte som `int`s og `float`s. Det betyr derimot ikke at vi ikke kan bruke matematiske operatorer på strenger:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "101520\n" + ] + } + ], + "source": [ + "s4 = '10' + '15' + '20'\n", + "print(s4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "`+` operatoren \"setter sammen\" strenger. Som i eksempelet over setter vi sammen, eller konkatinerer, tre strenger; `'10'`, `'15'` og `'20'`, til én stor streng `'101520'`. Du ser forhåpentligvis at tallene `10`, `15` og `20` _ikke_ blir addert til `45` slik de ville blitt om de var `int`s eller `float`s, men strengene blir konkatinert. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10101010101010101010\n" + ] + } + ], + "source": [ + "s5 = '10' * 10\n", + "print(s5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "`*` operatoren ganger strengen antall ganger. I eksempelet over ganger vi strengen `'10'` med `10`, og får den resulterende strengen `'10101010101010101010'` ('10' 10 ganger), ikke `100` som om vi hadde ganget `int`en `10` med `int`en `10`. Operatorene `-` og `/` kan vi ikke bruke på strenger." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Innimellom er det fint å ha andre datatyper inne i strenger. Dette gjøres lett med **f-strings**:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jeg er en f-string, og jeg kan ha for eksempel ints i meg: 12345, eller floats: 123.45\n" + ] + } + ], + "source": [ + "s6 = f'Jeg er en f-string, og jeg kan ha for eksempel ints i meg: {12345}, eller floats: {123.45}'\n", + "print(s6)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Det som er verdt å merke seg med **f-strings** er at så fort andre datatyper blir inkorporert inne i strengen, er de ikke lenger sin egen datatype. De er nå en del av den nye strengen. F-strings er helt vanlige strenger, men de er litt lettere å formatere de. Inne i krøllparentesene {} kan vi ha stort sett det vi vil, også variabler:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Her er et tall: 12345\n" + ] + } + ], + "source": [ + "tall = 12345\n", + "s7 = f'Her er et tall: {tall}'\n", + "print(s7)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Boolean" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "En `bool` er en sannhetsverdi, enten `True` eller `False`, og er en _veldig_ sentral datatype i programmering. Booleans kan brukes for eksempel til å sjekke om en alder er under eller over `18`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jeg har gjort øvingen min: True\n" + ] + } + ], + "source": [ + "gjort_oving = True\n", + "print(f'Jeg har gjort øvingen min: {gjort_oving}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Senere i emnet vil du lære om if-setninger. Da står booleans sentralt. En liten smakebit her:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### List" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Lister er en annen fundamental datatype i Python. Lister er er en samling av verdier, enten av andre datayper, eller av lister selv. For å lage en liste brukes klammeparantesene []. Inne i klammene legger vi verdiene våre, sparert med komma. Prøv å kjøre kodeblokken under, gjerne endre på verdiene også." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Her har du en liste med tall: [1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "liste_med_tall = [1, 2, 3, 4]\n", + "print(f'Her har du en liste med tall: {liste_med_tall}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Du vil lære mer om lister senere, som for eksempel hvordan du henter ut elementer. Det viktigste for nå er å vite hvordan du oppretter en :) Lister kan som sagt inneholde flere forskjellige datatyper:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Her har du en liste med forskjellige verdier: [1.0, 4, True, 'hei på deg']\n" + ] + } + ], + "source": [ + "liste_med_forskjellige_verdier = [1.0, 4, True, 'hei på deg']\n", + "print(f'Her har du en liste med forskjellige verdier: {liste_med_forskjellige_verdier}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "På samme måte som strenger kan vi ikke gjøre vanlige matematiske operasjoner på lister. Vi kan derimort gange en liste med et tall, og plusse sammen lister. Oppførselen blir det samme som når vi ganger en streng med et tall, eller plusser sammen to strenger. _Elementente_ i listen blir ikke ganget med tallet, de vil bli replikert X ganger. _Elementene_ i listene vil heller ikke bli plusset sammen ved bruk av `+`, men den ene listen blir lagt til i den andre listen:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8]\n", + "[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "liste_med_tall = [1,2,3,4]\n", + "liste_med_tall2 = [5,6,7,8]\n", + "\n", + "liste2 = liste_med_tall + liste_med_tall2\n", + "print(liste2)\n", + "\n", + "liste3 = liste_med_tall * 10\n", + "print(liste3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial: Konvertering mellom datatyper" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Vi kan ha ulike typer data, som tekststrenger (f.eks. `\"Python\"`), heltall (f.eks. `42`), flyttall (f.eks. `9.80`) og sannhetsverdier (`True`, `False`). Ofte kommer vi i situasjoner hvor vi har data av en viss type, men vi trenger samme data bare med en annen type. Da må vi konvertere dataene. Noen vanlige konverteringsfunksjoner:\n", + "\n", + "**`int()`** - konverterer til heltall.\n", + "- `int('423')` gir 423 (dvs. tekststrengen blir konvertert til et tall). Virker kun hvis tekststrengen faktisk inneholder et heltall.\n", + "- `int(5.69)` gir 5 (dvs. for flyttall blir desimaldelen fjernet)\n", + "\n", + "**`float()`** - konverterer til flyttall\n", + "- `float('5.69')` gir 5.69 (tekststreng konvertert til tall)\n", + "- `float('5')` gir 5.0, dvs. float() virker på tekststrenger enten de inneholder flyttall eller heltall (men ikke på strenger som er noe annet enn tall)\n", + "- `float(5)` gir 5.0\n", + "\n", + "**`str()`** - konverterer til tekststreng\n", + "- `str(42)` gir '42'\n", + "- `str(5.69)` gir '5.69'\n", + "Koden under feiler fordi vi har glemt å konvertere. Kjør den og se hva som skjer." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gratulerer, til sammen er dere 50 år!\n", + "Gratulerer, til sammen er dere 50 år!\n" + ] + } + ], + "source": [ + "alder = int(13)\n", + "alder_mor = int(37)\n", + "sum_alder = alder + alder_mor\n", + "\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n", + "\n", + "sum_alder = int(alder) + int(alder_mor)\n", + "\n", + "print(f'Gratulerer, til sammen er dere ' + str(sum_alder) + ' år!')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den første feilen viser seg i linjen \"Gratulerer...\" Summen skulle ha blitt 50 år. Men vi har de to alderne fortsatt bare lagret som tekststrenger. Da betyr `+` å hekte sammen strengene, ikke å gjøre noen addisjon. Altså får vi `'13' + '37'` som blir `'1337'` heller enn `13 + 37` som blir `50`. Her måtte vi ha konvertert fra tekst til tall før vi gjorde addisjonen.\n", + "\n", + "Den andre feilen oppstår i den siste print-setningen. Vi har på linjen over kalkulert rett alder, ved å konvertere `alder` og `alder_mor` til `int`. Problemet nå ligger i at vi prøver å legge sammen en `string` og en `int`. Som feilmeldingen sier; \"can only concatenate str (not \"int\") to str\". En mulig løsning er å konvertere `sum_alder` tilbake til `string` nå, slik av vi kan plusse sammen to strenger, eller bruke f-strings. Mulige løsninger vises under:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gratulerer, til sammen er dere 50 år!\n", + "Gratulerer, til sammen er dere 50 år!\n", + "Gratulerer, til sammen er dere 50 år!\n" + ] + } + ], + "source": [ + "alder = int(13)\n", + "alder_mor = int(37)\n", + "sum_alder = alder + alder_mor\n", + "\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')\n", + "\n", + "sum_alder = int(alder) + int(alder_mor)\n", + "\n", + "print('Gratulerer, til sammen er dere ' + str(sum_alder) + ' år!')\n", + "print(f'Gratulerer, til sammen er dere {sum_alder} år!')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Altså: bruker `int()` i linje 7, dette gjør at vi får heltall i variablene `alder` og `alder_mor` så vi blir i stand til å regne med dem. Bruker deretter `str()` i linje 9 så denne opplysningen kan settes sammen med annen tekst og brukes i `print()`. Dette eksemplet viser dermed både et tilfelle hvor vi har tekst men trenger tall, og ett hvor vi har et tall men trenger tekst. Hvis det er vi trenger et desimaltall på alder (f.eks. `13.5`) vil imidlertid koden over ikke funke. Da måtte vi ha brukt funksjonen `float()` der vi nå har brukt `int()`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I koden under er det noe feil. Finn feilene og rett opp i de" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Rett utskrift skal være:\n", + "\n", + "```python\n", + "25\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T11:24:13.550825Z", + "start_time": "2019-07-01T11:24:13.542723Z" + }, + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def legg_sammen_to_tall(a, b):\n", + " return int(a) + int(b)\n", + "\n", + "legg_sammen_to_tall(10, 15)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `legg_til_landskode(telefonnummer, landskode)` som tar inn `telefonnummer` (`int`) og `landskode` (`int`) som parametere og returnerer telefonnummetet prefixet med \"+\", landskode og et mellomrom.\n", + "\n", + "***Skriv koden din i kodeblokken udner***" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def legg_til_landskode(telefonnummer, landskode):\n", + " return str(f'+') + str(landskode) + (' ') + str(telefonnummer)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis du har gjort alt rett, skal kodeblokken under gi ut:\n", + "\n", + "```python\n", + "+47 12345678\n", + "+46 87654321\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+47 12345678\n", + "+46 87654321\n" + ] + } + ], + "source": [ + "telefonnummer1 = 12345678\n", + "landskode1 = 47\n", + "\n", + "telefonnummer2 = 87654321\n", + "landskode2 = 46\n", + "\n", + "print(legg_til_landskode(telefonnummer1, landskode1))\n", + "print(legg_til_landskode(telefonnummer2, landskode2))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kodeblokken nedenfor innheholder noen variabler. Konverter alle til `int`. **Merk**: Det lurer seg kanskje noen feil i koden!" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = int(1)\n", + "b = int(True)\n", + "c = int(False)\n", + "d = int(1.5)\n", + "e = int(2.45)\n", + "\n", + "# Skriv koden din her" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis du har gjort alt rett, skal kodeblokken under skrive ut:\n", + "\n", + "```python\n", + "a er nå 1\n", + "b er nå 1\n", + "c er nå 0\n", + "d er nå 1\n", + "e er nå 2\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a er nå 1\n", + "b er nå 1\n", + "c er nå 0\n", + "d er nå 1\n", + "e er nå 2\n" + ] + } + ], + "source": [ + "print(f'a er nå {a}')\n", + "print(f'b er nå {b}')\n", + "print(f'c er nå {c}')\n", + "print(f'd er nå {d}')\n", + "print(f'e er nå {e}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Lag en funksjon `mult_list_with_x(l, x)` som tar inn en liste `l` og skalar `x` som parametere og returnerer en _liste_ hvor alle elementene er multiplisert med `x`.\n", + "\n", + "***Skriv koden din i kodeblokken nedenfor***" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2. 3. 4. 5. 6.]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def mult_list_with_x(l, x):\n", + " resultat = l*x\n", + " return resultat\n", + "\n", + "l = np.array([1, 1.5, 2, 2.5, 3])\n", + "print(mult_list_with_x(l,2))\n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis funksjonen din er skrevet rett, skal kodeblokken nedenfor gi output:\n", + "\n", + "```python\n", + "[2.0, 3.0, 4.0, 5.0, 6.0]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 1.5, 2, 2.5, 3, 1, 1.5, 2, 2.5, 3]" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "liste = [1, 1.5, 2, 2.5, 3]\n", + "skalar = 2\n", + "\n", + "mult_list_with_x(liste, skalar)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Her må du bruke **numpy** og `np.array()`. For å gjøre om fra et array til en liste kan du bruke `list()`. Husk også å importere **numpy** med `import numpy as np`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 2: avrunding av flyttall" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ofte har man flyttall, men trenger heltall, f.eks. hvis man skal bruke innebygde Python-funksjoner som krever heltall som argument, eller skal bruke tallet som indeks til en streng eller liste (som vi vil se senere i pensum). Flyttall kan konverteres til heltall med funksjoner som `int()` eller `round()`. Kodeblokka under viser litt forskjell på hvordan disse virker." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "int() bare kutter desimalene, uansett hvor stor eller liten desimaldelen er:\n", + "int(2.25) er 2\n", + "int(2.5) er 2\n", + "int(2.99) er 2\n", + "round() runder av til nærmeste heltall, f.eks.\n", + "round(2.25) er 2\n", + "round(2.51) er 3\n", + "Hva hvis tallet er midt mellom to heltall?\n", + "round(2.5) er 2\n", + "round(3.5) er 4\n", + "round() bruker en IEEE standard som velger partallet for midt-imellom-situasjoner.\n", + "Mens int() alltid gir heltall kan round() brukes for antall desimaler:\n", + "round(2.5488, 1) blir 2.5\n", + "round(2.5488, 3) blir 2.549\n", + "Med negativt antall desimaler kan vi få round() til å runde større enn heltall:\n", + "round(12345.67, -3) blir 12000.0\n" + ] + } + ], + "source": [ + "print(\"int() bare kutter desimalene, uansett hvor stor eller liten desimaldelen er:\")\n", + "print(\"int(2.25) er\", int(2.25))\n", + "print(\"int(2.5) er\", int(2.5))\n", + "print(\"int(2.99) er\", int(2.99))\n", + "print(\"round() runder av til nærmeste heltall, f.eks.\")\n", + "print(\"round(2.25) er\", round(2.25))\n", + "print(\"round(2.51) er\", round(2.51))\n", + "print(\"Hva hvis tallet er midt mellom to heltall?\")\n", + "print(\"round(2.5) er\", round(2.5))\n", + "print(\"round(3.5) er\", round(3.5))\n", + "print(\"round() bruker en IEEE standard som velger partallet for midt-imellom-situasjoner.\")\n", + "print(\"Mens int() alltid gir heltall kan round() brukes for antall desimaler:\")\n", + "print(\"round(2.5488, 1) blir\", round(2.5488, 1))\n", + "print(\"round(2.5488, 3) blir\", round(2.5488, 3))\n", + "print(\"Med negativt antall desimaler kan vi få round() til å runde større enn heltall:\")\n", + "print(\"round(12345.67, -3) blir\", round(12345.67, -3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Som du ser i eksemplet, blir 2.5 rundet av til 2 mens 3.5 blir rundet til 4. Dette kan virke litt uvant, i dagliglivet er man mest kjent med såkalt \"kjøpmannsavrunding\", hvor det alltid rundes opp hvis man er midt mellom (dvs., 2.5 skulle i så fall ha blitt rundet til 3). Konsekvent runding oppover når man er midt mellom har imidlertid en uheldig side, nemlig at man pådrar seg en systematisk feil hvis man har mange data som avrundes. Tenk f.eks. temperaturmålinger for lange perioder, hvor man deretter skal regne ut et snitt for hele perioden. Hvis alle temperaturer som er midt når det gjelder siste brukte siffer, rundes opp, vil snittet for perioden alltid bli litt for høyt. Hvis man i stedet går i partallsretning i alle slike midt mellom situasjoner, vil man runde opp cirka halvparten av gangene og ned cirka halvparten av gangene og dermed unngå slike systematiske feil. Men for kjøpmannen er systematisk runding oppover selvsagt bedre med tanke på å få inn mest mulig penger." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "I tillegg til `int()` og `round()` kan f-strenger \"innebygd\" runde av flyttall:" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2345 avrundet til 2 desimaler er: 1.23\n", + "5.4321 avrundet til 0 desimaler er: 5\n" + ] + } + ], + "source": [ + "print(f'1.2345 avrundet til 2 desimaler er: {1.2345:.2f}')\n", + "print(f'5.4321 avrundet til 0 desimaler er: {5.4321:.0f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Det som skjer her inne i krøllparentesene her er; `1.2345` er tallet vi ønsker runde av, `:` sier \"rund av det som står til venstre til det som står til høyre\", `.2` sier \"gi meg 2 desimaler\" og `f` sier at typen skal være `float`. Det som er verdt å merke seg er at denne måten å runde av tall på gir deg ikke muligheten til å bruke tallet videre. Tallet er da inkorporert i strengen. Med `round()` og `int()` kan vi bruke det avrundede tallet videre." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en funksjon `rund_av(tall, desimaler)` som tar inn et tall `tall` som skal avrundes og `desimaler` antall desimaler tallet skal avrundes til som parametere og returnerer det avrundede tallet.\n", + "\n", + "***Skriv koden din i kodeblokken under.***" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def rund_av(tall, desimaler):\n", + " return round(tall, desimaler)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Hvis funksjonen din er skrevet rett, skal kodeblokken under gi følgende output:\n", + "\n", + "```python\n", + "1.23\n", + "1000.0\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.23\n", + "1000.0\n" + ] + } + ], + "source": [ + "print(rund_av(1.23456, 2))\n", + "print(rund_av(1234.5432, -3))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud12/variabler.ipynb" "b/\303\270vinger/\303\270ving_2/stud12/variabler.ipynb" new file mode 100644 index 0000000..ea3d6a9 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud12/variabler.ipynb" @@ -0,0 +1,589 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Variable\n", + "\n", + "**Læringsmål:**\n", + "\n", + "* Enkel bruk av variable\n", + "\n", + "* Korrekt navngivning av variable" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 1: variable - grunnleggende intro" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvorfor trenger vi variable? Poenget med variable er å **huske data underveis** i utførelsen av et program.\n", + "\n", + "Variable er derfor et sentralt konsept i programmering, ikke bare i Python men uansett hva slags språk man programmerer i.\n", + "\n", + "Uten variable støter vi fort på en rekke problemer fordi programmet vårt ikke kan huske noe, f.eks. at\n", + "\n", + "* vi må be brukeren gi inn opplysninger på nytt som brukeren har gitt tidligere\n", + "* vi må regne ut på nytt data vi allerede har regnet ut tidligere\n", + "\n", + "Dette sløser tid og strøm og vil i mange tilfeller gjøre programmet fullstendig ubrukelig.\n", + "\n", + "I det lille eksempelprogrammet under, klarer vi oss uten noen variabel, fordi navnet som skrives utkun blir benyttet én gang.\n", + "\n", + " \n", + "```python \n", + "print('Pi, med seks desimaler er 3.141592') \n", + "```\n", + "\n", + " \n", + "```\n", + "Pi, med seks desimaler er 3.141592\n", + ">>>>\n", + "```\n", + "\n", + "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.\n", + "\n", + " \n", + "```\n", + "Pi, med seks desimaler er 3.141592 \n", + "3.141592 er pi, avrundet til seks desimaler.\n", + ">>>>\n", + "```\n", + "\n", + "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:\n", + "\n", + " \n", + "```python\n", + "print('Pi, med seks desimaler er 3.141592')\n", + "print('3.141592 er pi, avrundet til seks desimaler.') \n", + "```\n", + "\n", + "\n", + "```\n", + "Pi, med seks desimaler er 3.141592\n", + "3.141592 er Pi, avrundet til seks desimaler.\n", + "```\n", + "\n", + "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.\n", + "\n", + "Kan vi løse det på en bedre måte? JA - med en variabel for å huske navnet. Koden blir da" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pi, med seks desimaler er 3.141592\n", + "3.141592 er pi, avrundet til seks desimaler\n" + ] + } + ], + "source": [ + "pi = 3.141592\n", + "print(f'Pi, med seks desimaler er {pi}')\n", + "print(f'{pi} er pi, avrundet til seks desimaler')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Dette programmet kan forklares som følger:\n", + "\n", + "* linje 1, til høyre for `=` : verdien vi ønsker å lagre (3.141592)\n", + "* linje 1, til venstre for `=`: oppretter en variabel som heter `pi`.\n", + "* linje 1, tegnet `=`. Dette er **tilordningsoperatoren**. Betyr at verdien av uttrykket på høyre side, verdien 3.141592, blir husket i variabelen kalt `pi`.\n", + "* linje 2, variabelen `pi` brukes sist i f-strengen i print-setningen. Merk at variabelnavnet **ikke** skal ha fnutter rundt seg. Med fnuttter ville ikke akkurat dette programmet kjørt. Ordet pi som står som det tredje ordet i setningen \"{pi} er pi, avrundet til seks desimaler\" er ikke variabelen, her er ordet navn bare del av en tekststreng.\n", + "* linje 3, variabelen `pi` brukes fremst i print-setningen. Igjen uten fnutter; det er ikke ordet pi vi ønsker å skrive, men den verdien som variabelen `pi` inneholder (f.eks. 3.141592)\n", + "\n", + "Ved hjelp av variabelen som her ble kalt pi, unngår vi å måtte skrive ut verdien to ganger. Vi skriver den bare én gang, i starten av programmet, og husker da opplysningen ved å putte den inn i en variabel.\n", + "\n", + "Videre i programmet kan vi benytte denne variabelen hver gang vi trenger verdien - enten det som her var bare to ganger, eller om det hadde vært flere.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "hidden": true + }, + "source": [ + "### Rask intro til f-strenger" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 + 1 = 2\n", + "2 * 2 = 4\n" + ] + } + ], + "source": [ + "print(f'1 + 1 = {1 + 1}')\n", + "print(f'2 * 2 = {2 * 2}') # Her er det noe feil. Kan du fikse opp?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a) Huske verdier i variable" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Kjør koden under for å se hvordan den virker. Som du vil se, skriver den ut \"Ada\" to ganger, og \"LBAS2002\" to ganger.\n", + "\n", + "Forbedre koden ved å introdusere en variabel for navn og en annen variabel for favorittfag, slik at vi slipper å skrive \"Ada\" og \"LBAS2002\" mer enn én gang.\n", + "\n", + "Hvis du er i tvil om hvordan du skal angripe problemet, se lignende eksempel i tutorial like over." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei, Julie\n", + "LBAS2002 - interessant!\n", + "Ha en fin dag, Julie\n", + "- og lykke til med LBAS2002\n" + ] + } + ], + "source": [ + "navn = input('Hva heter du?')\n", + "fag = input('Hva er ditt favorittfag?')\n", + "\n", + "print(f'Hei, {navn}')\n", + "print(f'{fag} - interessant!')\n", + "print(f'Ha en fin dag, {navn}')\n", + "print(f'- og lykke til med {fag}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du får til å bruke de to variablene som tenkt, skal kjøringen av det forbedrede programmet se slik ut (men også funke om brukeren skriver inn noe annet enn Ada på spørsmålet Navn? og noe annet enn ITGK på Favorittfag?)\n", + "\n", + "```\n", + "Navn? Ada \n", + "Hei, Ada \n", + "Favorittfag? LBAS2002 \n", + "ITGK - interessant! \n", + "Ha en fin dag, Ada \n", + "- og lykke til med LBAS2002\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 2 - bruk av variable i beregninger" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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. \n", + "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.\n", + "\n", + "**Sirkel og sylinder**" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Areal av sirkelen: 91.60884177867838\n", + "Volum av sylinderen: 723.7098500515592\n", + "\n", + "Areal av sirkelen: 91.60884177867838\n", + "Volum av sylinderen: 723.7098500515592\n" + ] + } + ], + "source": [ + "import math\n", + " \n", + "# VERSJON 1, uten variable\n", + "print(\"Areal av sirkelen:\", math.pi * 5.4**2)\n", + "print(\"Volum av sylinderen:\", math.pi * 5.4**2 * 7.9)\n", + " \n", + "print()\n", + " \n", + "# VERSJON 2, med variable\n", + "r = 5.4 # radius for en sirkel\n", + "a_sirkel = math.pi * r**2\n", + "print(\"Areal av sirkelen:\", a_sirkel)\n", + "h = 7.9 # høyde sylinder hvor sirkelen er grunnflate\n", + "v_syl = a_sirkel * h\n", + "print(\"Volum av sylinderen:\", v_syl)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis du kjører koden, vil du se at begge gir samme resultat. Hva er da forskjellen?\n", + "\n", + "* Versjon 2 er vesentlig lenger (6 kodelinjer, mot bare 2) fordi det brukes ekstra linjer på variable. Lenger kode er en mulig ulempe. MEN:\n", + "* Formlene i Versjon 2 er lettere å forstå fordi det er intuitive navn som `r`, `h`, `a_sirkel` heller enn bare tall direkte.\n", + "* 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.\n", + "* 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.\n", + "**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", + "metadata": { + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "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.\n", + "\n", + "***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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:54:16.358742Z", + "start_time": "2019-07-01T10:54:16.351684Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n", + "Omkrets av sirkelen: 16.964600329384883\n", + "Areal av sirkelen: 91.60884177867838\n", + "Areal av sylinderen: 317.23802615949734\n" + ] + } + ], + "source": [ + "import math\n", + "\n", + "radius = 5.4\n", + "hoyde = 7.9\n", + "o_sirkel = math.pi * radius\n", + "a_sirkel = math.pi * radius**2\n", + "a_sylinder = math.pi * radius * hoyde + 2 * math.pi * radius ** 2\n", + " \n", + "print(\"Har en sirkel med radius\", radius, \"som er grunnflate i en sylinder med høyde\", hoyde)\n", + "print(\"Omkrets av sirkelen:\", o_sirkel) \n", + "print(\"Areal av sirkelen:\", a_sirkel)\n", + "print(\"Areal av sylinderen:\", a_sylinder)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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).\n", + "\n", + " \n", + "```\n", + "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n", + "Omkrets av sirkelen: 33.929200658769766\n", + "Areal av sirkelen: 91.60884177867838\n", + "Areal av sylinderen: 451.25836876163794\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Tutorial del 3: Navngiving av variable" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "`variable = expression`\n", + "\n", + "I dette tilfellet er variable navnet til variabelen, mens expression er verdien. Noen regler for slike tilordningssetninger:\n", + "\n", + "* variabelen som opprettes skal alltid stå på venstre side av uttrykket, og venstre side skal kun inneholde denne variabelen, ikke noe annet\n", + "* 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.\n", + "* variabelnavnet må tilfredsstille følgende regler:\n", + " * 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\n", + " * variabelnavn må begynne med en bokstav eller tegnet _ (understrek)\n", + " * kan ellers inneholde bokstaver, tall og understrek, dvs. kan f.eks. ikke inneholde blanke tegn.\n", + "* Python skiller mellom små og store bokstaver, så `Areal` og `areal` vil være to ulike variable.\n", + "\n", + "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.\n", + "\n", + "Kodeblokka under viser eksempler på variable som funker og ikke funker:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Eksempel på tilordningssetninger som funker\n", + "pokemon_name = \"Tyranitar\"\n", + "MaxCP = 3670\n", + "antall = 3\n", + "antall = antall + 1 # høyre side regnes ut som 3+1, så 4 blir ny verdi i variabelen antall\n", + "resists_fighting = False\n", + "level42 = \"to be done\" # tall er OK i variabelnavn unntatt helt fremst\n", + " \n", + "# Eksempel på tilordninger som IKKE funker\n", + "1 = antall # variabelen må stå på venstre side\n", + "antall + 1 = antall # og v.s. kan KUN inneholde et variabelnavn, ikke et større uttrykk\n", + "10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\n", + "antall = 3 # denne er OK, men se neste linje\n", + "antall = Antall + 1 # Python skiller mellom store og små bokstaver, Antall vil være en annen\n", + " # variabel og gir NameError her fordi den ikke er opprettet i en tidligere setning\n", + "happy hour = 20 # navn kan ikke inneholde mellomrom, burde vært happy_hour eller happyHour\n", + "alkohol% = 4.5 # % kan ikke brukes i variabelnavn (betyr modulo). Samme gjelder andre spesialtegn,\n", + " # hold deg til vanlige bokstaver og tall" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c) Variabelnavn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Prøv å kjør koden under. Som du vil se, funker den ikke pga. diverse feil med variabelnavn og tilordningssetninger. Fiks feilene så programmet kjører som det skal." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Per er 5 år unna idealalderen\n" + ] + } + ], + "source": [ + "navn = \"Per\"\n", + "ideal_alder = 42\n", + "kundens_alder = 37\n", + "differanse = ideal_alder - kundens_alder\n", + "print(f'{navn} er {differanse} år unna idealalderen')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud13/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud13/aarstider.ipynb" new file mode 100644 index 0000000..a797c74 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud13/aarstider.ipynb" @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'vår'" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def arstid (m, d):\n", + " if m == \"mars\":\n", + " if d < 20:\n", + " return \"vinter\"\n", + " else:\n", + " return \"vår\"\n", + " elif m == \"april\" or m ==\"mai\":\n", + " return \"vår\"\n", + " elif m == \"juni\":\n", + " if d < 21:\n", + " return \"vår\"\n", + " else: \n", + " return \"sommer\"\n", + " elif m == \"juli\" or m == \"august\":\n", + " return \"sommer\"\n", + " elif m == \"september\":\n", + " if d < 22:\n", + " return \"sommer\"\n", + " else:\n", + " return \"høst\"\n", + " elif m == \"okotber\" or m == \"november\":\n", + " return \"høst\"\n", + " elif m == \"desember\":\n", + " if d < 21:\n", + " return \"vinter\"\n", + " else:\n", + " return \"høst\"\n", + " elif m == \"januar\" or m == \"feburar\":\n", + " return \"vinter\"\n", + " \n", + "\n", + "arstid (\"mars\", 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'vår'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arstid (\"desember\", 17)" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud13/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud13/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..4600b0e --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud13/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2 \n", + "b = 3 \n", + "c = 5*a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "def f(x):\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud13/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud13/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud13/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud13/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud13/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..14b51a5 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud13/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,488 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: uttrykk 1, 3 og 5" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "x = 3 \n", + "y = 8 \n", + "z = -3\n", + "\n", + "print (-5 < z and 5 > z)\n", + "print (not y == 8)\n", + "print (x == 8 or y == 8)\n", + "print (not (x <= 3 or y >= 9))\n", + "print (not (x**2 != 8 and y-z == 5) or x+y == y-z)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + }, + { + "data": { + "text/plain": [ + "'Minst ett av tallene er utenfor et gyldig intervall :('" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "def gyldige_tall(a, b):\n", + " if (a >= 70 and a <= 90) or (a >= 40 and a <= 50) and (70 <= b and b <= 90) or (b >= 40 and b <= 50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "gyldige_tall(54, 56)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud13/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud13/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..7a0975e --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud13/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,398 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kaken har vært i ovnen i 50 minutter\n", + "kaken kan tas ut av ovnen\n", + "tips til servering: vanlijeis\n", + ">>>>>>>>>\n", + "kaken har vært i ovnen i 10 minutter\n", + "kaken kan ikke tas ut av ovnen\n", + "tips til servering: vanlijeis\n", + ">>>>>>>>>\n" + ] + } + ], + "source": [ + "\n", + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"kaken har vært i ovnen i {tid} minutter\")\n", + "\n", + " if tid >= 50:\n", + " print (\"kaken kan tas ut av ovnen\")\n", + "\n", + " elif tid < 50:\n", + " print (\"kaken kan ikke tas ut av ovnen\")\n", + "\n", + " print(\"tips til servering: vanlijeis\")\n", + " print(\">>>>>>>>>\") \n", + "\n", + "kake_ut_av_ovnen_losning (50)\n", + "\n", + "kake_ut_av_ovnen_losning (10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud14/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud14/aarstider.ipynb" new file mode 100644 index 0000000..4b0906e --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud14/aarstider.ipynb" @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Høst, (`september, 5)\n" + ] + } + ], + "source": [ + "def aarstid(mnd, dag):\n", + " vaar = ['mars', 'april', 'mai']\n", + " sommer = ['juni', 'juli', 'august']\n", + " host = ['september', 'oktober', 'novemver']\n", + " vinter = ['desember', 'januar', 'februar']\n", + "\n", + " if mnd in vaar:\n", + " aarstid = \"Vår\"\n", + " elif mnd in sommer:\n", + " aarstid = \"Sommer\"\n", + " elif mnd in host:\n", + " aarstid = \"Høst\"\n", + " elif mnd in vinter:\n", + " aarstid = \"Vinter\"\n", + " else:\n", + " aarstid = \"Ukjent\"\n", + " \n", + " return aarstid\n", + "\n", + "mnd = (input(\"skriv inn måned: \"))\n", + "dag = int(input(\"skriv inn dato: \"))\n", + "\n", + "svar = aarstid(mnd, dag)\n", + "\n", + "print(f\"{svar}, (`{mnd}, {dag})\")\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud14/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud14/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..17b310d --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud14/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 3 13 19\n" + ] + } + ], + "source": [ + "# Skriv koden din her\n", + "\n", + "a = 2\n", + "b = 3\n", + "c = (a*5) + b\n", + "d= a * b + c\n", + "\n", + "print(a , b , c , d )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "\n", + "def f(x):\n", + " return 2 * x + 1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud14/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud14/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud14/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud14/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud14/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..a58cb3e --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud14/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: < Utrykk 1, 3, 4 og 5 gir True>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "\n", + " x = 3\n", + " y = 8\n", + " z = -3\n", + "\n", + " sant = not (x**2 != 8 and y-z == 5) or x+y == y-z\n", + "\n", + " print(sant)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Tallene er begge i gyldige intervall!\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if ((70 <= a <= 90 or 40 <= a <= 50) and (70 <= b <= 90 or 40 <= b <= 50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "a = int(input(\"Tall a: \"))\n", + "b = int(input(\"Tall b: \"))\n", + "\n", + "if (70 <= a <= 90 or 40 <= a <= 50) and (70 <= b <= 90 or 40 <= b <= 50):\n", + " print(\"Tallene er begge i gyldige intervall!\")\n", + "else: \n", + " print(\"Minst ett av tallene er utenfor en gyldig intervall\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud14/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud14/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..832f26f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud14/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,399 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + "\n", + "\n", + " if tid >= 50:\n", + " \n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + " else:\n", + "\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + " \n", + "\n", + "kake_ut_av_ovnen(60)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud15/Funksjoner og Kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud15/Funksjoner og Kalkulasjoner.ipynb" new file mode 100644 index 0000000..c8402a7 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud15/Funksjoner og Kalkulasjoner.ipynb" @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2 \n", + "b = 3 \n", + "c = (5*a) + b \n", + "d = a * b + c " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "\n", + "import math\n", + "import numpy as np\n", + "\n", + "def f(x):\n", + " return 2*x + 1 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud15/Logiske Operatorer Uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud15/Logiske Operatorer Uttrykk.ipynb" new file mode 100644 index 0000000..d1678d4 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud15/Logiske Operatorer Uttrykk.ipynb" @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 34, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: \n", + "\n", + "Uttrykk 1: True \n", + "Uttrykk 2: False \n", + "Uttrykk 3: True \n", + "Uttrykk 4: False \n", + "Uttrykk 5: True " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "uttrykk_1 = -5 < z and 5 > z\n", + "\n", + "uttrykk_2 = not y == 8\n", + "\n", + "uttrykk_3 = x == 8 or y == 8\n", + "\n", + "uttrykk_4 = not (x <= 3 or y >= 9)\n", + "\n", + "uttrykk_5 = not (x**2 != 8 and y-z == 5) or x+y == y-z" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uttrykk 1: True\n", + "Uttrykk 2: False\n", + "Uttrykk 3: True\n", + "Uttrykk 4: False\n", + "Uttrykk 5: True\n" + ] + } + ], + "source": [ + "print(f'Uttrykk 1: {uttrykk_1}')\n", + "print(f'Uttrykk 2: {uttrykk_2}')\n", + "print(f'Uttrykk 3: {uttrykk_3}')\n", + "print(f'Uttrykk 4: {uttrykk_4}')\n", + "print(f'Uttrykk 5: {uttrykk_5}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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 har lovlig verdi, skal koden i lese-blokken returneres.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Tallene er begge i gyldige intervall!\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (70 < a < 90 or 40 <= a < 50) and (70 < b < 90 or 40 <= b < 50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\n", + "# Eksempel på bruk\n", + "resultat = gyldige_tall(45, 80)\n", + "print(resultat)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud15/Ulike Typer if-setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud15/Ulike Typer if-setninger.ipynb" new file mode 100644 index 0000000..16b5a0a --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud15/Ulike Typer if-setninger.ipynb" @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " \n", + " if tid > 50:\n", + " print(\"Kaken kan tas ut av ovnen.\") \n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud15/\303\205rstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud15/\303\205rstider.ipynb" new file mode 100644 index 0000000..f7442cc --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud15/\303\205rstider.ipynb" @@ -0,0 +1,163 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(maned, dag):\n", + "\n", + " if maned in ['januar', 'februar']:\n", + " return \"vinter\"\n", + " if maned in ['april', 'mai',]:\n", + " return \"vår\"\n", + " if maned in ['juli', 'august']:\n", + " return \"sommer\"\n", + " if maned in [\"oktober\", 'november']:\n", + " return \"høst\"\n", + " \n", + " if maned == 'mars' and dag >= 20:\n", + " return \"vår\"\n", + " else: \n", + " return \"vinter\"\n", + " if maned == 'juni' and dag >= 20:\n", + " return \"sommer\"\n", + " else:\n", + " return \"vår\"\n", + " if maned == 'september' and dag >= 21:\n", + " return \"høst\"\n", + " else:\n", + " return \"sommer\"\n", + " if maned == 'desember' and dag >= 21:\n", + " return \"vinter\"\n", + " else:\n", + " return \"høst\"\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vår\n", + "vinter\n", + "høst\n", + "sommer\n" + ] + } + ], + "source": [ + "print(arstid('mars', 20)) # Output: Vår\n", + "print(arstid('januar', 2)) # Output: Vinter\n", + "print(arstid('november', 17)) # Output: Høst\n", + "print(arstid('juli', 17)) # Output: Sommer" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud16/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud16/aarstider.ipynb" new file mode 100644 index 0000000..89fa9c9 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud16/aarstider.ipynb" @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == 'Mars':\n", + " if d <20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == 'Juni':\n", + " if d<21:\n", + " return \"Vår\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m == 'September':\n", + " if d<22:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == 'Desember':\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == 'april' or m == 'mai':\n", + " return \"Vår\"\n", + " elif m == 'juli' or m == 'august':\n", + " return \"Sommer\"\n", + " elif m == 'Oktober' or m == 'November':\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud16/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud16/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..d34ce18 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud16/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,360 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud16/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud16/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud16/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud16/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud16/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..6eea19a --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud16/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,479 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: True, False, True, False, True Uttrykk 1, 3 og 5" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8 \n", + "z = - 3 \n", + "\n", + "print(-5 < z and 5 > z)\n", + "print(not y == 8) \n", + "print(x == 8 or y == 8) \n", + "print(not (x <= 3 or y >= 9)) \n", + "print(not (x**2 != 8 and y-z == 5) or x+y == y-z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Tallene er begge i gyldige intervaller!'" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def gyldige_tall(a, b):\n", + " if ((a>70 and a<90) or (a>40 and not a>=50) and (b>70 and b<90) or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervaller!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig interall :(\"\n", + "\n", + "gyldige_tall(86,86) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud16/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud16/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..4c22685 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud16/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply nå!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n", + "Takk!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply nå!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + " print (\"Takk!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {50} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(50)\n", + "\n", + "kake_ut_av_ovnen(50)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "kaken har vært i ovnen i 35 minutter.\n", + "kaken har vært i ovnen i 22 minutter.\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print (f\"kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid > 49:\n", + " print(\"Kaken kan tas ut av ovnen\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(50)\n", + "kake_ut_av_ovnen(35)\n", + "kake_ut_av_ovnen (22)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud17/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud17/aarstider.ipynb" new file mode 100644 index 0000000..ee9ba52 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud17/aarstider.ipynb" @@ -0,0 +1,162 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return \"vinter\" \n", + " else:\n", + " return \"vår\"\n", + " elif m == 'juni':\n", + " if d<21:\n", + " return \"vår\"\n", + " else: \n", + " return \"sommer\"\n", + " elif m == 'september':\n", + " if d<22:\n", + " return \"sommer\"\n", + " else: \n", + " return \"høst\"\n", + " elif m == 'desember':\n", + " if d<21:\n", + " return \"høst\"\n", + " else:\n", + " return \"vinter\"\n", + " elif m == 'april' or m== 'mai':\n", + " return \"vår\" \n", + " elif m == 'juli' or m == 'august':\n", + " return \"sommer\"\n", + " elif m == 'oktober' or m == 'november':\n", + " return \"høst\"\n", + " else:\n", + " return \"vinter\"\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'vinter'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arstid('mars', 10)" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud17/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud17/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..9b0f7cd --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud17/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "a = 2\n", + "\n", + "b = 3\n", + "\n", + "c = 5*a+b\n", + "\n", + "d = a*b+c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'tuple' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(b)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(c)\n", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object is not callable" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): [2*(x+3)]\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "\n", + "def f(x): [2*(x+1)]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud17/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud17/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud17/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud17/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud17/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..f43d095 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud17/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "raw", + "metadata": { + "hide_input": false + }, + "source": [ + "Uttrykk 1:true\n", + "uttrykk 2:false\n", + "uttrykk 3:true\n", + "uttrykk 4:false\n", + "uttrykk 5:true" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "true\n", + "false\n", + "true\n", + "false\n", + "true\n" + ] + } + ], + "source": [ + "x=3\n", + "y=8\n", + "z=-3\n", + "\n", + "if -5<z and 5>z:\n", + " print('true')\n", + "else:\n", + " print('false')\n", + "\n", + "if not y == 8:\n", + " print('true')\n", + "else:\n", + " print('false')\n", + " \n", + "if x==8 or y==8:\n", + " print('true')\n", + "else:\n", + " print('false')\n", + " \n", + "if not(x<=3 or y >= 9):\n", + " print('true')\n", + "else:\n", + " print('false')\n", + " \n", + "if not(x**2 != 8 and y-z == 5) or x+y==y-z:\n", + " print('true')\n", + "else:\n", + " print('false')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)): \n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud17/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud17/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..d6188af --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud17/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,377 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"la kaken avkjøles i {tid} minutter før den serveres\")\n", + " \n", + " if tid>50:\n", + " print(\"påtide å pynte og servere kaken.\")\n", + " \n", + " \n", + " if tid<50:\n", + " print(\"la kaken stå litt til og ingen prøvesmaking.\")\n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud18/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud18/aarstider.ipynb" new file mode 100644 index 0000000..ec35a82 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud18/aarstider.ipynb" @@ -0,0 +1,150 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___ \n", + "\n", + "Dette var det jeg prøvde å få til å funke hjemme, det er på kanten til å funke, men jeg skjønner ikke helt hvorfor jeg får de svarene jeg får. Så det svaret du hadde i timen; skrev det ikke ned her selv, men skjønte svaret." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Årstiden er vår\n" + ] + } + ], + "source": [ + "\n", + "\n", + "def Årstid(x, y):\n", + " if (x == str('Mars') and y >= 20) or (x == str('April') or str('Mai')):\n", + " return print('Årstiden er vår')\n", + " elif (x == str('Juni') and y >= 21) or (x == str('Juli') or str('August')):\n", + " return print('Årstiden er sommer')\n", + " elif (x == str('September') and y >= 22) or (x == str('Oktober') or str('November')):\n", + " return print('Årstiden er høst')\n", + " elif (x == str('Desember') and y >= 21) or (x == str('Januar') or str('Februar')):\n", + " return print('Årstiden er vinter')\n", + " \n", + " if x == str('Mars') and y <= 19:\n", + " return print('Årstiden er vinter')\n", + " \n", + " if x == str('Juni') and y <= 20:\n", + " return print('Årstiden er vår')\n", + " \n", + " if x == str('September') and y <= 21:\n", + " return print('Årstiden er sommer')\n", + " \n", + " if x == str('Desember') and y <= 20:\n", + " return print('Årstiden er høst')\n", + " \n", + "\n", + "\n", + "\n", + "Årstid('September', 20)\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud18/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud18/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..6213fb2 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud18/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,360 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3\n", + "c = 5*a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2 * x + 1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud18/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud18/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud18/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud18/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud18/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..39bf1ce --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud18/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,470 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: 1: True \n", + " 2: False\n", + " 3: True\n", + " 4: True\n", + " 5: False" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + }, + { + "data": { + "text/plain": [ + "'Minst ett av tallene er utenfor et gyldig intervall :('" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if ((a > 70 and a <= 90) or (a>40 and a <= 50)) and (b > 40 and b <= 50 ):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "gyldige_tall(90, 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud18/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud18/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..c3b81d8 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud18/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Jeg burde bruke paraply i dag: Ja\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.3)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.2\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + "\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(50)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 52 minutter\n", + " Kaken er ferdig og kan tas ut!\n", + " Vel bekomme!\n", + "Tips til servering: vaniljeis\n", + "---------------------------------------\n", + "Kaken har vært i ovnen i 49 minutter\n", + "Kaken er ikke ferdig styr unna!\n", + "Tips til servering: vaniljeis\n", + "---------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f'Kaken har vært i ovnen i {tid} minutter')\n", + "\n", + " if tid >= 50:\n", + " print(' Kaken er ferdig og kan tas ut!')\n", + " print(' Vel bekomme!')\n", + " elif tid < 50:\n", + " print('Kaken er ikke ferdig styr unna!')\n", + " print('Tips til servering: vaniljeis')\n", + " print('---------------------------------------')\n", + "\n", + "kake_ut_av_ovnen_losning(52)\n", + "kake_ut_av_ovnen_losning(49)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud19/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud19/aarstider.ipynb" new file mode 100644 index 0000000..283652f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud19/aarstider.ipynb" @@ -0,0 +1,111 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud19/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud19/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..f2958d9 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud19/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud19/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud19/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud19/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud19/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud19/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..ec15eff --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud19/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,454 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: < dobbeltklikk her>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud19/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud19/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..e595a3a --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud19/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " \"\"\"Skriv koden her\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud2/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud2/aarstider.ipynb" new file mode 100644 index 0000000..6c37f60 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud2/aarstider.ipynb" @@ -0,0 +1,165 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == \"mars\":\n", + " if d<20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == \"juni\":\n", + " if d<21:\n", + " return \"sommer\"\n", + " elif m == \"september\":\n", + " if d<22:\n", + " return\"sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == \"desember\":\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == \"april\" or m == \"mai\":\n", + " return \"Vår\"\n", + " elif m == \"juli\" or m == \"august\":\n", + " return \"sommer\"\n", + " elif m == \"oktober\" or m == \"november\":\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud2/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud2/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..6d69342 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud2/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,357 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3 \n", + "c = 5*a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2 * x + 1\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud2/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud2/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..24cc7c5 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud2/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: \n", + "uttrykk 1\n", + "uttrykk 3\n", + "uttrykk 5 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "print(-5 < z and 5 > z)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "a=40\n", + "b=70\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (70 < a < 90 or 40 <= a < 50) and (70 < b < 90 or 40 <= b < 50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " resultat = gyldig_tall(a, b)\n", + " print(resultat)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud2/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud2/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..eabc9a6 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud2/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid): \n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " \n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid): \n", + "\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "kake_ut_av_ovnen_losning(60)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud20/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud20/aarstider.ipynb" new file mode 100644 index 0000000..8aa21b8 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud20/aarstider.ipynb" @@ -0,0 +1,139 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid (d, m):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return 'vinter'\n", + " else:\n", + " return 'vår'\n", + " elif m== 'juni':\n", + " if d<21:\n", + " return 'sommer'\n", + " else: 'vår'\n", + " elif m == 'september':\n", + " if d<22: \n", + " return 'sommer'\n", + " else: 'høst' \n", + " elif m == 'desember':\n", + " if d<21:\n", + " return'høst'\n", + " else:'høst'\n", + " elif m == 'april' or m == 'mai':\n", + " return 'vår'\n", + " \n", + " \n", + "arstid('mars', 27) \n", + "arstid('mars', 20)\n", + "arstid('juni', 21)\n", + "arstid('september', 22)\n", + "arstid('desember', 21)" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud20/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud20/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..f409aaf --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud20/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 3 13 19\n" + ] + } + ], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = a * b + c \n", + "\n", + "print (a, b, c, d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "def f(x):\n", + " return 2 * x + 1 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud20/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud20/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..96fc672 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud20/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,456 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: \n", + "Uttrykk 3\n", + "Uttrykk 5 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\")\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90) or (b>40 and b<50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud20/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud20/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..8d08755 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud20/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + "\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(50)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken er ferdig etter 50 i ovnen\n", + "Kaken er ferdig\n", + "Kos deg med kake\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken er ferdig etter {tid} i ovnen\")\n", + "\n", + " if tid >= 50:\n", + " print(\"Kaken er ferdig\")\n", + " print(\"Kos deg med kake\")\n", + "\n", + "kake_ut_av_ovnen_losning(50)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud3/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud3/aarstider.ipynb" new file mode 100644 index 0000000..6c37f60 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud3/aarstider.ipynb" @@ -0,0 +1,165 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def arstid(m, d):\n", + " if m == \"mars\":\n", + " if d<20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == \"juni\":\n", + " if d<21:\n", + " return \"sommer\"\n", + " elif m == \"september\":\n", + " if d<22:\n", + " return\"sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == \"desember\":\n", + " if d<21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == \"april\" or m == \"mai\":\n", + " return \"Vår\"\n", + " elif m == \"juli\" or m == \"august\":\n", + " return \"sommer\"\n", + " elif m == \"oktober\" or m == \"november\":\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud3/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud3/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..6d69342 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud3/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,357 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3 \n", + "c = 5*a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2 * x + 1\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud3/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud3/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..24cc7c5 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud3/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: \n", + "uttrykk 1\n", + "uttrykk 3\n", + "uttrykk 5 " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "print(-5 < z and 5 > z)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "a=40\n", + "b=70\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (70 < a < 90 or 40 <= a < 50) and (70 < b < 90 or 40 <= b < 50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " resultat = gyldig_tall(a, b)\n", + " print(resultat)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud3/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud3/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..eabc9a6 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud3/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid): \n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " \n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid): \n", + "\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "kake_ut_av_ovnen_losning(60)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud4/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud4/aarstider.ipynb" new file mode 100644 index 0000000..90e73c4 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud4/aarstider.ipynb" @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vinter\n", + "Vinter\n", + "Høst\n" + ] + } + ], + "source": [ + "def arstid(måned, dag):\n", + " vår_start = 20 \n", + " sommer_start = 21 \n", + " høst_start = 23 \n", + " vinter_start = 21 \n", + " \n", + " if måned == 'januar' or måned == 'februar' or måned == 'mars' and dag < vår_start or måned == 'desember' and dag >= vinter_start or måned == 'mars' and dag == vår_start:\n", + " return 'Vinter'\n", + " elif måned == 'april' or måned == 'mai' or måned == 'juni' and dag < sommer_start or måned == 'mars' and dag >= vår_start or måned == 'juni' and dag == sommer_start:\n", + " return 'Vår'\n", + " elif måned == 'juli' or måned == 'august' or måned == 'september' and dag < høst_start or måned == 'juni' and dag >= sommer_start or måned == 'september' and dag == høst_start:\n", + " return 'Sommer'\n", + " elif måned == 'oktober' or måned == 'november' or måned == 'desember' and dag < vinter_start or måned == 'september' and dag >= høst_start or måned == 'desember' and dag == vinter_start:\n", + " return 'Høst'\n", + " \n", + "\n", + "print(arstid('januar', 2)) \n", + "print(arstid('mars', 20)) \n", + "print(arstid('november', 17)) \n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud4/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud4/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..9a144de --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud4/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,351 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5*a + b\n", + "d = a * b + c\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2*x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud4/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud4/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..55f2597 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud4/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,487 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Utrykk 1, utrykk 3 og utrykk 5 er de logiske uttrykkene som gir oss True" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "x=3\n", + "y=8\n", + "z=-3\n", + "\n", + "Uttrykk_1 = -5 < z and 5 > z \n", + "\n", + "Uttrykk_2 = not y == 8\n", + "\n", + "Uttrykk_3 = x == 8 or y == 8\n", + "\n", + "Uttrykk_4 = not (x <= 3 or y >= 9) \n", + "\n", + "Uttrykk_5 = not (x**2 != 8 and y-z == 5) or x+y == y-z \n", + "\n", + "print(Uttrykk_3)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Minst ett av tallene er utenfor et gyldig intervall :(\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "a=40\n", + "b=70\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (70 < a < 90 or 40 <= a < 50) and (70 < b < 90 or 40 <= b < 50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "resultat = gyldige_tall(a, b)\n", + "print(resultat)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud4/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud4/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..51219f9 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud4/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,404 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Tips til servering: vaniljeis.\n", + "Kaken kan tas ut av ovnen.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------------------\n", + "kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------------------\n", + "kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen\")\n", + "\n", + "\n", + "\n", + "kake_ut_av_ovnen_losning(35)\n", + "print(\"Tips til servering: vaniljeis.\")\n", + "\n", + "print(\"----------------------------------------------------\")\n", + "kake_ut_av_ovnen_losning(50)\n", + "print(\"Tips til servering: vaniljeis.\")\n", + "\n", + "print(\"----------------------------------------------------\")\n", + "kake_ut_av_ovnen_losning(65)\n", + "print(\"Tips til servering: vaniljeis.\")\n", + "\n", + "print(\"----------------------------------------------------\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud5/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud5/aarstider.ipynb" new file mode 100644 index 0000000..b8b3c04 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud5/aarstider.ipynb" @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "datoen er: ('mars', 20)\n", + "da er det vår\n", + "datoen er: ('januar', 2)\n", + "da er det vinter\n", + "datoen er: ('november', 17)\n", + "da er det høst\n" + ] + } + ], + "source": [ + "def tid_paa_aaret(maned, dag):\n", + " print(f\"datoen er: {maned, dag}\")\n", + "\n", + "\n", + " if (maned == 'april' or maned == 'mai') or (dag <= 20 and maned == 'juni') or (dag >=20 and maned == 'mars'):\n", + " return (f\"da er det vår\")\n", + " \n", + " elif (maned == 'juli' or maned == 'august') or (dag <= 21 and maned == 'september') or (dag >= 21 and maned == 'juni'):\n", + " return (f\"da er det sommer\")\n", + " \n", + " elif (maned == 'oktober' or maned == 'november') or (dag <= 20 and maned == 'desember') or (dag >= 22 and maned == 'septemper'):\n", + " return (f\"da er det høst\")\n", + " \n", + " elif (maned == 'januar' or maned == 'februar') or (dag <= 19 and maned == 'mars') or (dag >= 21 and maned == 'desember'):\n", + " return (f\"da er det vinter\")\n", + "\n", + "\n", + "arstidd = tid_paa_aaret('mars', 20)\n", + "print (arstidd)\n", + "\n", + "arstidd = tid_paa_aaret('januar', 2)\n", + "print (arstidd)\n", + "\n", + "arstidd = tid_paa_aaret('november', 17)\n", + "print (arstidd)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud5/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud5/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..73645bc --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud5/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,361 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5 * (a) + (b)\n", + "d = (a) * (b) + (c)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x):\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud5/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud5/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud5/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud5/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud5/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..2c89086 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud5/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: < 1, 3, 5>" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "#Uttrykk 1: `-5 < z and 5 > z` - True\n", + "#Uttrykk 2: `not y == 8` - False\n", + "#Uttrykk 3: `x == 8 or y == 8` - True\n", + "#Uttrykk 4: `not (x <= 3 or y >= 9)` - False\n", + "#Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` - True\n", + "\n", + "logisk_uttrykk = -5 < z and 5 > z\n", + "\n", + "print (logisk_uttrykk)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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 har lovlig verdi, skal koden i else-blokken returneres.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Tallene er begge i gyldige intervall!\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>40 and a<50) and (b>70 and b<90) or (70<b<90) and (a>40 and not a>=50):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "riktige_tall = gyldige_tall(45, 77)\n", + "print(riktige_tall)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud5/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud5/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..278f4ff --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud5/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,401 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)\n", + "\n", + "#løsningen står skrevet under, jeg tolket det slik at det var i boksen under løsningen skulle føres :) " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " \n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " \n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen_losning(35)\n", + "\n", + "kake_ut_av_ovnen_losning(50)\n", + "\n", + "kake_ut_av_ovnen_losning(65)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud6/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud6/aarstider.ipynb" new file mode 100644 index 0000000..835896b --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud6/aarstider.ipynb" @@ -0,0 +1,137 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Vinter'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "januar, februar, mars, april, mai, juni = 1, 2, 3, 4, 5, 6\n", + "juli, august, september, oktober, november, desember = 7, 8, 9, 10, 11, 12\n", + "\n", + "def aarstid(mnd, dag):\n", + " if (mnd, dag) <= (3, 19) or (mnd, dag) >= (12, 21):\n", + " return \"Vinter\"\n", + " elif (mnd, dag) <= (6, 20) and (mnd, dag) >= (3, 20):\n", + " return \"Vår\"\n", + " elif (mnd, dag) <= (9, 21) and (mnd, dag) >= (6, 21):\n", + " return \"Sommer\"\n", + " elif (mnd, dag) <= (12, 20) and (mnd, dag) >= (9, 22):\n", + " return \"Høst\"\n", + "\n", + "aarstid(januar, 22) # Funksjonen tar ikke inn en måned som en streng, men dette var det nærmeste jeg kom en løsning" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud6/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud6/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..b4bfbec --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud6/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Matematiske utrykk i Python\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "La $e$ være $\\frac{-b + 4}{a - 4}$\n", + "\n", + "La $f$ være $5^{a * b + 2}$\n", + "\n", + "La $g$ være $[(a + b) * c - d]$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = (a * b) + c\n", + "e = (-b + 4) / (a - 4)\n", + "f = 5**((a*b)+2)\n", + "g = (a + b) * c - d" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "-0.5\n", + "390625\n", + "46\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n", + "-0.5\n", + "390625\n", + "46\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)\n", + "print(e)\n", + "print(f)\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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:\n", + "\n", + "```py\n", + "# Her kan man ikke bruke a eller min_funksjon\n", + "\n", + "a = 1.3 # Assosierer navnet a med et flyttallsobjekt i minnet\n", + "\n", + "# Her kan man bruke a, men ikke min_funksjon\n", + "\n", + "def min_funksjon(): # Assosierer navnet min_funksjon med et funksjonsobjekt i minnet\n", + "\n", + "# Her kan man bruke begge\n", + "```\n", + "\n", + "\n", + "Prøv å kjøre kodeblokken over og se at du ikke får noe output.\n", + "\n", + "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", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "$g(x) = \\frac{-4x + 2}{5x + 3}$\n", + "\n", + "$h(x) = x^2 + 2x + 1$\n", + "\n", + "$i(x) = \\sqrt(x)$\n", + "\n", + "$j(x) = \\sin{x} + \\cos{x}$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "def f(x):\n", + " return 2 * x + 1\n", + "\n", + "def g(x):\n", + " return (-4 * x + 2) / (5 * x + 3)\n", + "\n", + "def h(x):\n", + " return x**2 + 2 * x + 1\n", + "\n", + "def i(x):\n", + " return np.sqrt(x)\n", + "\n", + "def j(x):\n", + " return np.sin(x) + np.cos(x)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "-0.6428571428571429\n", + "16\n", + "2.0\n", + "-0.6752620891999122\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "-0.6428571428571429\n", + "16\n", + "2.0\n", + "-0.6752620891999122\n" + ] + } + ], + "source": [ + "print(f(10))\n", + "print(g(5))\n", + "print(h(3))\n", + "print(i(4))\n", + "print(j(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 2: Heltallsdivisjon og Modulo:\n", + "\n", + "Les gjerne denne før du begynner på neste oppgave" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I tillegg til vanlig divisjon / har Python også heltallsdivisjon som skrives // og modulo som skrives med operatoren %.\n", + "\n", + "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.\n", + "\n", + "Tabellen under illustrerer hvordan disse operatorene virker:\n", + "\n", + "**Utrykk i Python**|**Resultat**|**Forklaring**\n", + "---|---|---\n", + "17 / 5\t|3.4\t|Vanlig divisjon\n", + "17 // 5|\t3\t|Heltallsdivisjon, gir hvor mange hele ganger nevneren 5 går opp i telleren 17\n", + "17 % 5\t|2|\tModulo, gir resten av 17 // 5, dvs. de 2 som blir til over\n", + "7.75 / 2.5\t|3.1|\tVanlig divisjon\n", + "7.75 // 2.5\t|3.0|\tHeltallsdivisjon, 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.\n", + "7.75 % 2.5\t|0.25|\tModulo, Resten av 7.75//2.5 er 0.25 fordi 2.5 * 3.0 er 7.5\n", + "\n", + "Heltallsdivisjon og modulo har en rekke nyttige bruksområder i programmering.\n", + "\n", + "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.\n", + "\n", + "Koden under viser hvordan // og % kan brukes til slike beregninger. Prøv å kjør den." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def antall_hele_uker(dager):\n", + " return dager // 7\n", + "\n", + "def antall_uker_dager(dager):\n", + " uker = dager // 7\n", + " dager = dager % 7\n", + " return uker, dager\n", + "\n", + "print(antall_hele_uker(10))\n", + "print(antall_uker_dager(15))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T09:01:23.971652Z", + "start_time": "2019-07-01T09:01:23.962336Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### c) Bruk av heltallsdivisjon og modulo" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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.\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def antall_minutt_sekund(sek):\n", + " min = sek // 60\n", + " return min\n", + "\n", + "def antall_dogn_timer(timer):\n", + " dogn = timer // 24\n", + " return dogn\n", + "\n", + "def antall_timer_minutt_sekund(sek):\n", + " min = sek // 60\n", + " time = min // 60\n", + " rest = min % 60\n", + " return time, rest" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "(5, 30)\n" + ] + } + ], + "source": [ + "print(antall_minutt_sekund(120))\n", + "print(antall_dogn_timer(75))\n", + "print(antall_timer_minutt_sekund(19832))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Riktig utskrift hvis du har fått det til, skal bli**\n", + "```\n", + "2\n", + "3\n", + "(5, 30) #siden 19832 sekunder tilsvarer 5 timer, 30 min, 32 sek.\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### d) Konvertering av minutter\n", + "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", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(28, 869, 20871, 1252300)\n" + ] + } + ], + "source": [ + "def funksjon(min):\n", + " time = min // 60\n", + " dager = time // 24\n", + " maaned = dager // 30\n", + " return maaned, dager, time, min\n", + " \n", + "print(funksjon(1252300))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud6/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud6/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..066555f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud6/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,652 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "1. True\n", + "2. False\n", + "3. True\n", + "4. False\n", + "5. True" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z = -3\n", + "\n", + "print(not(x**2 != 8 and y-z == 5) or x+y == y-z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + }, + { + "data": { + "text/plain": [ + "'Tallene er begge i gyldige intervall!'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>=70 and a<=90) or (a>=40 and not(a>50)) and ((70<=b<=90) or (b>=40 and b<=50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\n", + "gyldige_tall(80, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\n" + ] + }, + { + "data": { + "text/plain": [ + "'Da blir det 4 på deg og 6 på meg :D'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\")\n", + " \n", + "def antall_pannekaker(n):\n", + " if n > 10 or n <= 0: \n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " else:\n", + " r = 10-n\n", + " return f\"Da blir det {n} på deg og {r} på meg :D\"\n", + "\n", + "antall_pannekaker(4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Eksempel på kjøring**\n", + "\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\n", + "antall_pannekaker(4)\n", + "Da blir det 4 på deg og 6 på meg :D\n", + "```\n", + " \n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n", + "antall_pannekaker(100)\n", + "Beklager, men det er nok ikke mulig\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "```python\n", + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\")\n", + "\n", + "def antall_pannekaker(n, liker):\n", + " if liker == 'J':\n", + " liker_pannekaker = True\n", + " else:\n", + " liker_pannekaker = False\n", + " ...\n", + "```\n", + "\n", + "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>.\n", + "\n", + "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", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\")\n", + "def antall_pannekaker(n, liker):\n", + " if liker == 'J':\n", + " liker_pannekaker = True\n", + " else:\n", + " liker_pannekaker = False\n", + " \n", + " if ...: #Kode mangler her\n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " else:\n", + " r = 10-p\n", + " return f\"Da blir det {p} på deg og {r} på meg :D\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Eksempel på kjøring**\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg\n", + "antall_pannekaker(5, 'J')\n", + "Da blir det 5 på deg og 5 på meg :D\n", + "```\n", + "\n", + "```\n", + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n", + "antall_pannekaker(7, 'N')\n", + "Beklager, men det er nok ikke mulig\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\n" + ] + }, + { + "data": { + "text/plain": [ + "'Beklager, men det er nok ikke mulig'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Hei! Jeg har 10 pannekaker jeg ønsker å dele med deg ^u^\")\n", + "def antall_pannekaker(n, liker):\n", + " if n > 10 or n <= 0: \n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " \n", + " if liker == 'J':\n", + " liker_pannekaker = True\n", + " else:\n", + " liker_pannekaker = False\n", + " \n", + " if liker_pannekaker == False: #Kode mangler her\n", + " return \"Beklager, men det er nok ikke mulig\"\n", + " else:\n", + " r = 10-n\n", + " return f\"Da blir det {n} på deg og {r} på meg :D\"\n", + "\n", + "antall_pannekaker(4, 'N')" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud6/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud6/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..adc700d --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud6/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,1416 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 70 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " \n", + " if tid >= 50:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen_losning(10)\n", + "\n", + "kake_ut_av_ovnen_losning(60)\n", + "\n", + "kake_ut_av_ovnen_losning(70)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:03:17.573938Z", + "start_time": "2019-07-01T10:03:17.564290Z" + }, + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ta utgangspunkt i følgende funksjon, som tar inn antall epler og antall barn som argumenter, og deretter regner ut hvor mange epler det blir på hvert barn." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T10:06:41.706832Z", + "start_time": "2019-07-01T10:06:37.363889Z" + } + }, + "outputs": [], + "source": [ + "def antall_epler_per_barn(epler, barn):\n", + " # Antall epler til hvert barn\n", + " antall_per = epler // barn\n", + " # Antall epler det er igjen etter at barna har fått sine epler\n", + " antall_rest = epler % barn\n", + " \n", + " return antall_per, antall_rest\n", + "\n", + "antall_per, antall_rest = antall_epler_per_barn(14,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Når en funksjon i Python returnerer mer enn én ting, kan det enten returneres som en liste ved å plassere \"square brackets\" rundt og skille elementene ved komma, eller som en tuppel ved å skille elementene ved komma. Dersom du ønsker å hente ut spesifikke deler av den returnerte dataen, må du enten hente den ut ved å indeksere outputen, eller ved å deklarere variablene på tilsvarende måte som verdiene ble returnert. Vedlagt kode viser de to måtene." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tuppel = antall_epler_per_barn(12,5)\n", + "antall_per = tuppel[0]\n", + "antall_rest = tuppel[1]\n", + "\n", + "print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + "print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + "print(\"Takk for i dag!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vi kan hente ut de returnerte variablene direkte ved å gjøre som i eksempelet nedenfor." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "antall_per, antall_rest = antall_epler_per_barn(12,5)\n", + "\n", + "print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + "print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + "print(\"Takk for i dag!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Under vises to kjøreeksempler med tilsvarende scripts som i de to cellene ovenfor:\n", + "\n", + "**Kjøring 1:**\n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(14, 3)\n", + "\n", + "Da blir det 4 epler til hvert barn \n", + "og 2 epler til overs til deg selv. \n", + "Takk for i dag!\n", + "```\n", + "\n", + "**Kjøring 2:**\n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(3, 0)\n", + "Traceback (most recent call last): \n", + " ... \n", + "ZeroDivisionError: integer division or modulo by zero \n", + "```\n", + "\n", + "\n", + "Det første, hvor brukeren gir tallene 14 og 3 som argumenter, funker fint. Hvis brukeren derimot svarer 0 barn, vil funksjonen gi feilmelding (`ZeroDivisionError`) fordi det er umulig å dele på null. Negativt antall barn vil \"funke\", men ikke gi mening.\n", + "\n", + "___Endre koden slik at de to print-setningene som forteller hvor mange epler det blir til barna og deg selv KUN utføres hvis barn > 0. \"Takk for i dag!\" skal derimot printes uansett.___\n", + "\n", + " Kjøring med barn > 0 skal gi samme resultat som eksemplet øverst. Eksemplet under viser kjøring hvis det skrives 0 for barn:\n", + " \n", + "```\n", + "antall_per, antall_rest = antall_epler_per_barn(3, 0) \n", + "Takk for i dag!\n", + "```\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Da blir det 4 epler til hvert barn\n", + "og 0 epler til overs til deg selv.\n", + "Takk for i dag!\n" + ] + } + ], + "source": [ + "def antall_epler_per_barn(epler, barn):\n", + " # Antall epler til hvert barn\n", + " if barn > 0:\n", + " antall_per = epler // barn\n", + " antall_rest = epler % barn\n", + " print(\"Da blir det\", antall_per, \"epler til hvert barn\")\n", + " print(\"og\", antall_rest, \"epler til overs til deg selv.\")\n", + " print(\"Takk for i dag!\")\n", + " else:\n", + " print(\"Takk for i dag!\")\n", + "\n", + " return antall_per, antall_rest\n", + "\n", + "tuppel = antall_epler_per_barn(12,3)\n", + "antall_per = tuppel[0]\n", + "antall_rest = tuppel[1]\n", + "\n", + "# Får \"UnboundLocalError: cannot access local variable 'antall_per' where it is not associated with a value\" med tuppel = antall_epler_per_barn(12,0) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-else-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du går videre. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I eksemplene knyttet til (a) og (b) skulle vi gjøre noe ekstra hvis en betingelse var sann, ellers la være. I andre tilfeller kan vi ønske å gjøre en handling hvis betingelsen er sann, og en alternativ handling hvis den er usann.\n", + "\n", + "Det kan vi oppnå med en **if-else**-setning. Eksemplet nedenfor bygger videre på tilsvarende eksempel for if-setninger." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "start_time": "2019-07-01T10:30:04.105Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.0\n", + "Jeg burde bruke paraply i dag: Nei\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if_else(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " anbefaling = \"Ja\"\n", + " else:\n", + " anbefaling = \"Nei\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_if_else(0.0)\n", + "\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")\n", + "print(hilsen)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I dette eksemplet vil følgende skje hvis vi svarer mer enn 0.2 mm nedbør slik at betingelsen blir sann:\n", + "\n", + "**Eksempel på kjøring med over 0.3 mm nedbør:**\n", + "```\n", + "paraply_if_else(0.3)\n", + "\n", + "Output:\n", + "Jeg burde bruke paraply i dag: Ja\n", + "Ha en fin tur til universitetet!\n", + "```\n", + "\n", + "Svares det derimot et lavere tall, slik at betingelsen blir usann, skjer følgende:\n", + "\n", + "**Eksempel på kjøring med under 0.0 mm nedbør:** \n", + "```\n", + "paraply_if_else(0.0)\n", + "\n", + "Output:\n", + "Jeg burde bruke paraply i dag: Nei\n", + "Ha en fin tur til universitetet!\n", + "```\n", + "\n", + "Altså:\n", + "- Anbefalingen settes til \"Ja\" under `if`-uttrykket bare hvis betingelsen er sann.\n", + "- Setningen som står på innrykk under `else` blir utført bare hvis betingelsen er usann (kunne også hatt flere setninger på innrykk etter `else`).\n", + "- Den siste hilsenen, som ikke har innrykk (Ha en fin tur...), blir returnert uansett." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## c)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "I denne deloppgaven skal det lages et program som sjekker om en person kan stemme, altså om personen er 18 år eller eldre. Man må da spørre brukeren om alder og lagre svaret i en variabel, for deretter å sjekke om brukerens alder er 18 eller mer.\n", + "\n", + "**Eksempel på kjøring**\n", + "\n", + "```\n", + "kan_stemme(19)\n", + "\n", + "Output:\n", + "Du kan stemme:)\n", + "```\n", + " \n", + "```\n", + "kan_stemme(18)\n", + "\n", + "Output:\n", + "Du kan stemme:)\n", + "```\n", + " \n", + "```\n", + "kan_stemme(2)\n", + "\n", + "Output:\n", + "Du kan ikke stemme ennå\n", + "```\n", + "\n", + "***Skriv din kode her:***" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hvor gammel er du?\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + " 19\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du kan stemme\n" + ] + } + ], + "source": [ + "print(\"Hvor gammel er du?\")\n", + "\n", + "def kan_stemme(alder):\n", + " alder = int(input())\n", + " if alder >=18:\n", + " print(\"Du kan stemme\")\n", + " else:\n", + " print(\"Du kan ikke stemme ennå\")\n", + "\n", + "kan_stemme(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Fremgangsmåte\n", + "Trykk på pilen til venstre for å lese" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "1. Lag en funksjon som heter `kan_stemme` som tar inn en alder (tall) som argument\n", + "2. Sjekk, vha. if, om personens alder er større eller lik 18 (`alder >= 18`). Om dette er tilfelle skal strengen `\"Du kan stemme:)\"` returneres fra funksjonen\n", + "3. Lag en `else`-blokk som returnerer strenger `\"Du kan ikke stemme ennå\"`\n", + "\n", + "(Det er flere mulige løsninger på denne oppgaven.)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-elif-else-setninger\n", + "Les gjerne denne før du går videre. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I eksemplene vi har sett hittil, har det vært kun to mulige utfall på betingelsene - kaken har stått >= 50 minutt, eller ikke; antall barn er > 0, eller ikke; alder er over 18, eller ikke. I mange praktiske situasjoner kan det være tre eller flere mulige utfall.\n", + "\n", + "F.eks. hvis det var meldt mer enn 3 mm nedbør er kanskje ikke paraply tilstrekkelig, vi ville heller anbefale støvler og regntøy. Vårt tidligere eksempel kunne da utvides som følger:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 1\n", + "\n", + "def paraply_if_elif_else(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 3.0:\n", + " anbefaling = \"Støvler og regntøy\"\n", + " elif regn > 0.2:\n", + " anbefaling = \"Paraply\"\n", + " else:\n", + " anbefaling = \"T-skjorte med NTNU-logo\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " \n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_if_elif_else(4)\n", + "print(f\"Dagens anbefaling: {anbefaling}\")\n", + "print(hilsen)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Under vises tre kjøringer av denne koden:\n", + "\n", + "```\n", + "paraply_if_elif_else(4.2)\n", + "\n", + "Output:\n", + "Regn i mm: 4.2\n", + "Dagens anbefaling: Støvler og regntøy\n", + "Ha en fin tur til universitetet!\n", + ">>>\n", + "```\n", + "\n", + "```\n", + "paraply_if_elif_else(0.3)\n", + "\n", + "Output:\n", + "Regn i mm: 0.3\n", + "Dagens anbefaling: Paraply\n", + "Ha en fin tur til universitetet!\n", + ">>>\n", + "```\n", + "\n", + "```\n", + "paraply_if_elif_else(0.0)\n", + "\n", + "Output:\n", + "Regn i mm: 0.0\n", + "Dagens anbefaling: T-skjorte med NTNU-logo\n", + "Ha en fin tur til universitetet!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvis betingelsen `regn > 3.0` er sann, settes anbefalingen til støvler og regntøy, deretter går programmet til første kodelinje etter hele if-elif-else-setningen, og setter hilsenen til (\"Ha en fin tur...\")\n", + "\n", + "Hvis betingelsen `regn > 3.0` er usann, settes **ikke** anbefalingen til støvler, programmet sjekker i stedet betingelsen på `elif`. Hvis denne er sann, settes anbefalingen til paraply, og dersom `elif`-påstanden også er usann, settes anbefalingen til T-skjorte med NTNU-logo som tidligere.\n", + "\n", + "Det er mulig å klare seg uten if-elif-else-setninger og i stedet bare putte if-else-setninger inni hverandre for å oppnå det samme. Eksemplet ovenfor kunne alternativt skrives:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 2\n", + "def paraply_nested_if(regn):\n", + " if regn > 3.0:\n", + " anbefaling = \"Støvler og regntøy\"\n", + " else:\n", + " if regn > 0.2:\n", + " anbefaling = \"Paraply\"\n", + " else:\n", + " anbefaling = \"T-skjorte med NTNU-logo\"\n", + " hilsen = \"Ha en fin tur til universitetet!\"\n", + " return anbefaling, hilsen\n", + "\n", + "anbefaling, hilsen = paraply_nested_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Særlig i tilfeller hvor det dreier seg om tre eller flere alternative utfall basert på verdien av den **samme variabelen** (f.eks. `regn` her) vil de fleste oppfatte **if-elif-else**-setninger som både lettere å skrive og lettere å forstå, enn flere nøstede if-else-setninger.\n", + "\n", + "Ett typisk eksempel er antall oppnådde poeng på en eksamen, som kan transformeres til en bokstavkarakter A-F etter gitte grenser. Det er da 6 mulige utfall, dette gir mye innrykk og blir vanskelig å lese med nøstede if-setninger:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 3\n", + "def hvilken_karakter(score): \n", + " if score >= 89:\n", + " return \"A\"\n", + " else:\n", + " if score >= 77:\n", + " return \"B\"\n", + " else:\n", + " if score >= 65:\n", + " return \"C\"\n", + " else:\n", + " if score >= 53:\n", + " return \"D\"\n", + " else:\n", + " if score >= 41:\n", + " return \"E\"\n", + " else:\n", + " return \"F\"\n", + "\n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "if-elif-else-setning vil være klart å foretrekke i en slik situasjon; det er mye lettere å se at koden her tar en beslutning med 6 alternativer basert på verdien av en enkelt variabel:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 4\n", + "def hvilken_karakter(score): \n", + " if score >= 89:\n", + " return \"A\"\n", + " elif score >= 77:\n", + " return \"B\"\n", + " elif score >= 65:\n", + " return \"C\"\n", + " elif score >= 53:\n", + " return \"D\"\n", + " elif score >= 41:\n", + " return \"E\"\n", + " else:\n", + " return \"F\"\n", + "\n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Ved bruk av if-elif-else er det avgjørende at betingelsene kommer i riktig rekkefølge. Anta at vi hadde gjort karaktereksemplet motsatt:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 5\n", + "# HER HAR VI MED VILJE HAR GJORT FEIL\n", + "def hvilken_karakter(score): \n", + " if score >= 0:\n", + " return \"F\"\n", + " elif score >= 41:\n", + " return \"E\"\n", + " elif score >= 53:\n", + " return \"D\"\n", + " elif score >= 65:\n", + " return \"C\"\n", + " elif score >= 77:\n", + " return \"B\"\n", + " elif score >= 89:\n", + " return \"A\"\n", + " \n", + "karakter = hvilken_karakter(75)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil øverste betingelse vil være sann for alle eksamensbesvarelser - og alle ender opp med karakteren F.\n", + "\n", + "Det er også viktig når det er snakk om alternativt ekskluderende utfall av samme beslutning at vi bruker **if-elif-else**-setning; **IKKE en serie med frittstående if-setninger**.\n", + "\n", + "Eksempel 6 under ser nesten ut som Eksempel 4, bare at vi kun skriver `if` der vi før skrev `elif`. Merk også at funksjonen her bruker en variabel `karakter` for å holde på karakteren, heller enn å returnere den - dette er gjort for å fremheve feilen som oppstår." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 6\n", + "# HER HAR VI MED VILJE HAR GJORT FEIL\n", + "def hvilken_karakter(score):\n", + " karakter = \"\"\n", + " if score >= 89:\n", + " karakter = \"A\"\n", + " print(f\"Karakter etter første if: {karakter}\")\n", + " if score >= 77:\n", + " karakter = \"B\"\n", + " print(f\"Karakter etter andre if: {karakter}\")\n", + " if score >= 65:\n", + " karakter = \"C\"\n", + " print(f\"Karakter etter tredje if: {karakter}\")\n", + " if score >= 53:\n", + " karakter = \"D\"\n", + " print(f\"Karakter etter fjerde if: {karakter}\")\n", + " if score >= 41:\n", + " karakter = \"E\"\n", + " print(f\"Karakter etter femte if: {karakter}\")\n", + " else:\n", + " karakter = \"F\"\n", + " return karakter\n", + "\n", + "hvilken_karakter(92)\n", + "print(f\"Du fikk {karakter}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "En student som har fått 92 poeng vil her komme riktig ut av den første if-setningen, og karakter settes til A. Men 92 > 77 er også sant, så karakter omgjøres deretter til B. Så til C, så til D, så til E.\n", + "\n", + "De eneste tilfellene som dette programmet vil takle korrekt blir dermed studenter som skal ha E eller F.\n", + "\n", + "Feilen her er at vi bruker nye frittstående if-setninger (dvs. som ikke er relatert til hverandre), mens vi egentlig har å gjøre med gjensidig ekskluderende alternativer som skulle vært løst med if-elif-else.\n", + "\n", + "Hvor er det eventuelt riktig å bruke frittstående if-setninger? Jo, hvis det er snakk om flere uavhengige beslutninger. I eksempel 7 under er det to uavhengige beslutninger, den ene om man skal ta paraply eller ikke, den andre om brodder eller ikke. Hver beslutning tas uavhengig av den andre, da blir det riktig med to frittstående if-setninger.\n", + "\n", + "Hadde vi i stedet brukt if-elif her, ville programmet ikke ha virket som det skulle, da det kun ville ha vært i stand til å anbefale brodder i oppholdsvær (mens det jo kan være minst like glatt om det regner)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "start_time": "2019-07-01T11:00:12.045Z" + }, + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 7\n", + "def paraply_og_brodder(regn, glatt):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Hvor glatt er det på en skala fra 1 til 10: {glatt}\")\n", + " anbefaling = \"\"\n", + " if regn > 0.2:\n", + " anbefaling += \"Da anbefaler jeg paraply. \\n\"\n", + " if glatt > 8:\n", + " anbefaling += \"Da anbefaler jeg sko med brodder eller pigger.\"\n", + " return anbefaling\n", + "\n", + "anbefaling = paraply_og_brodder(0.3, 9)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I andre tilfeller kan en beslutning være avhengig av en annen, f.eks. kun være aktuell ved et visst utfall av en foregående if-setning. Som i eksempel 8 under:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# EKSEMPEL 8\n", + "def paraply_i_vind(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Da anbefaler jeg paraply.\"\n", + " else:\n", + " return \"Anbefaler regntøy, for mye vind for paraply.\"\n", + "\n", + "anbefaling = paraply_i_vind(0.3, 9)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her ville if `regn > 0.2:` .....`elif vind < 7.0` ha blitt feil.\n", + "\n", + "Programmet ville da ha gjort vurderinger av vinden kun hvis det ikke regnet, og dermed ha vært ute av stand til å fraråde paraply hvis det regner og samtidig blåser kraftig.\n", + "\n", + "**Oppsummert:**\n", + "\n", + "- flere helt uavhengige beslutninger: bruk frittstående if-setninger\n", + "- beslutning med gjensidig utelukkende handlingsalternativer: bruk if-else (2 alternativer) eller if-elif-else (3 eller flere alternativer)\n", + "- beslutninger relatert på annen måte, f.eks. at en betingelse (som `vind < 7.0` ovenfor) kun er aktuell gitt et visst utfall av en annen betingelse: kan løses ved å nøste flere if-setninger inni hverandre\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Lag en utvidet versjon av programmet fra (c) som sier om personen kan stemme eller ikke, med følgende regler:\n", + "\n", + "- `alder >= 18`: Kan stemme både ved lokalvalg og Stortingsvalg\n", + "- `alder >= 16`: Kan stemme ved lokalvalg, men ikke ved Stortingsvalg\n", + "- ellers (`alder < 16`): Kan ikke stemme.\n", + "\n", + "Eksempel på kjøring:\n", + "\n", + "```\n", + "kan_stemme(19)\n", + "\n", + "Output:\n", + "Du kan stemme både ved lokalvalg og Stortingsvalg\n", + ">>>>\n", + "```\n", + "\n", + "```\n", + "kan_stemme(17)\n", + "\n", + "Output:\n", + "Du kan stemme ved lokalvalg, men ikke ved Stortingsvalg\n", + ">>>>\n", + "```\n", + "\n", + "```\n", + "kan_stemme(12)\n", + "\n", + "Output:\n", + "Du kan ikke stemme ennå\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hvor gammel er du?\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + " 16\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du kan stemme ved lokalvalg, men ikke ved Stortingsvalg\n" + ] + } + ], + "source": [ + "print(\"Hvor gammel er du?\")\n", + "\n", + "def kan_stemme(alder):\n", + " alder = int(input())\n", + " if alder >=18:\n", + " print(\"Du kan stemme både ved lokalvalg og Stortingsvalg\")\n", + " elif alder >=16:\n", + " print(\"Du kan stemme ved lokalvalg, men ikke ved Stortingsvalg\")\n", + " elif alder <16:\n", + " print(\"Du kan ikke stemme ennå\")\n", + "\n", + "kan_stemme(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du skal lage en funskjon som sjekker hvilken billettpris en person skal betale ut ifra alderen til personen og returnerer prisen som et tall.\n", + "\n", + "Oversikt over alder og tilhørende billettpriser:\n", + "\n", + "Aldersgruppe | Billettpris\n", + "--- | ---\n", + "Under 3 år | Gratis\n", + "3-11 år | 30 kr\n", + "12-25 år | 50 kr\n", + "26-66 år | 80 kr\n", + "67 år og over | 40 kr" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hvor gammel er du?\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + " 66\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Du må betale 80 kr\n" + ] + } + ], + "source": [ + "print(\"Hvor gammel er du?\")\n", + "\n", + "def billettpris(alder):\n", + " alder = int(input())\n", + " if alder < 3:\n", + " print(\"Du kommer inn Gratis!\")\n", + " elif alder >= 3 and alder <= 11:\n", + " print(\"Du må betale 30 kr\")\n", + " elif alder >= 12 and alder <= 25:\n", + " print(\"Du må betale 50 kr\")\n", + " elif alder >= 26 and alder <= 66:\n", + " print(\"Du må betale 80 kr\")\n", + " else:\n", + " print(\"Du må betale 40 kr\")\n", + " \n", + "billettpris(1)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Fremgangsmåte\n", + "Trykk på pilen til venstre" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "1. Først må det lages en funksjon som tar inn alderen til brukeren som argument.\n", + "2. Videre skal man sjekke hvilken billett personen skal ha, og dette gjøres med en if-elif-else-setning:\n", + "\n", + "```\n", + "if alder < 3:\n", + " ...\n", + "elif alder < 12:\n", + " ...\n", + "elif ...:\n", + " ...\n", + "elif ...:\n", + " ...\n", + "else:\n", + " ...\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/\303\270vinger/\303\270ving_2/stud7/.vscode/settings.json" "b/\303\270vinger/\303\270ving_2/stud7/.vscode/settings.json" new file mode 100644 index 0000000..457f44d --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/.vscode/settings.json" @@ -0,0 +1,3 @@ +{ + "python.analysis.typeCheckingMode": "basic" +} \ No newline at end of file diff --git "a/\303\270vinger/\303\270ving_2/stud7/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud7/aarstider.ipynb" new file mode 100644 index 0000000..ae5c103 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/aarstider.ipynb" @@ -0,0 +1,155 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funksjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vinter\n", + "Høst\n" + ] + } + ], + "source": [ + "# definerer en funksjon som tar inn parameterne måned (mnd) og dag. \n", + "def aarstid(mnd, dag):\n", + " # hvis måneden er mars og datoen er lik eller høyere enn den 20' vil den returnere Vår som årstid. \n", + " if mnd == 'mars' and dag >= 20:\n", + " return 'Vår'\n", + " # kunne kanskje kortet ned ved å bruke or mellom månedene der datoen ikke er avgjørende.\n", + " if mnd == 'april':\n", + " return 'Vår'\n", + " if mnd == 'mai':\n", + " return 'Vår'\n", + " if mnd == 'juni' and dag < 21:\n", + " return 'Vår'\n", + " if mnd == 'juni' and dag >= 21:\n", + " return 'Sommer'\n", + " if mnd == 'juli':\n", + " return 'Sommer'\n", + " if mnd == 'august':\n", + " return 'Sommer'\n", + " if mnd == 'september' and dag < 22:\n", + " return 'Sommer'\n", + " if mnd == 'september' and dag >= 22:\n", + " return 'Høst'\n", + " if mnd == 'oktober':\n", + " return 'Høst'\n", + " if mnd == 'november':\n", + " return 'Høst'\n", + " if mnd == 'desember' and dag < 21:\n", + " return 'Høst'\n", + " if mnd == 'desember' and dag >= 21:\n", + " return 'Vinter'\n", + " \n", + "print(aarstid('desember', 29))\n", + "\n", + "print(aarstid('desember', 0))" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud7/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud7/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..7463896 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Brukte ikke parenteser da gangingen måtte bli gjort først.\n", + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = a * b + c" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "Etter definisjonen av funksjonen kommer funksjonskroppen. Her skiller funksjonene i Python seg mest ut fra matematiske funksjoner. Matematiske funksjoner gir 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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# definerer funksjonen.\n", + "def f(x):\n", + " # returnerer parameteren x ganget med 2 og plusset med 1\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud7/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud7/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git a/lectures/chap2/lab/lab-2.zip "b/\303\270vinger/\303\270ving_2/stud7/lab-2.zip" similarity index 100% rename from lectures/chap2/lab/lab-2.zip rename to "\303\270vinger/\303\270ving_2/stud7/lab-2.zip" diff --git "a/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..531619a --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif hvilket er forkortelse av \"else if\". \n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: \n", + "Uttrykk 1 = True (-5 er mindre enn -3 og 5 er større enn -3 og begge er sanne.)\n", + "Uttrykk 2 = False (y er det samme som 8, mens uttrykket kun er sant om y er ulik 8.)\n", + "Uttrykk 3 = True (y er lik 8 selv om x ikke er lik 8 og så lenge enn av de er sanne blir uttrykket True, siden or brukes.)\n", + "Uttrykk 4 = True (siden y = 8 og derfor verken større eller lik 9, og kun en av uttrykkene trenger å være sanne.)\n", + "Uttrykk 5 = True (delen til høyre for or på hver side av == blir begge 11, derfor blir uttrykket sant/True. Delen til venstre stemmer ikke da x opphøyet i 2 ikke er like 8, siden dette uttrykket også kunne vært skrevet x**2 == 8, men svaret blir x = 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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 har lovlig verdi, skal koden i else-blokken returneres.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n", + "Tallene er begge i gyldige intervall!\n" + ] + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " # parantes rundt hele uttrykket for a og hele uttrykket for b slik at alt inni begge de største paranteses må være sanne for at\n", + " # de skal regnes som gyldige tall. Og la til = og byttet om plass på tall og b, slik at alle er >= eller <= siden vi har fra og med,\n", + " # og til og med 40, 50, 70 og 90.\n", + " if ((a>=70 and a<=90) or (a>=40 and a<=50)) and ((b>=70 and b<=90) or (b>=40 and b<=50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "print(gyldige_tall(40, 70))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud7/oving2.py" "b/\303\270vinger/\303\270ving_2/stud7/oving2.py" new file mode 100644 index 0000000..1f118e5 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/oving2.py" @@ -0,0 +1,92 @@ +import math +import numpy + + + +#def nokkel_svar(nokkel): +# print(f"Du har nøkkelen: {nokkel}") +# +# if nokkel == True: +# return "Ja." +# return "Nei." +# +#svar = nokkel_svar(False) +#print(f"Kommer vi inn: {svar}") + + + + +# fikk hjelp av Jonny med å få denne til å kjøre da den ikke kjørte så lenge koden over var aktiv. Usikker på hvorfor feilen oppsto. +svarjallernei = input("Svar meg ja eller nei: Har du nøkkelen?") + +def svar_nokkel(jaellernei): + + if jaellernei == "ja": + print("Da kommer vi inn!") + print("Jeg hadde med min egen nøkkel sånn i tilfelle du skulle glemme det.") + +svar_nokkel(svarjallernei) + +print("------------") + +# definerer funksjonen +def f(x): + # returnerer parameteren x først ganget med 2 og så plusset med 4. + return 4 + x * 2 + +print(f(8)) + +# definerer funksjonen +def m(x): + # returnerer parameteren x først plusset med 4 og så ganget med 2. + return (4 + x) * 2 + +print(m(8)) + +# definerer funksjonen +def k(x): + # returnerer parameteren x først ganget med 4 for seg og 2 for seg og så ganget med hverandre igjen. + return (4 * x) * (2 * x) + +print(k(8)) + +# definerer funksjonen +def l(x): + # returnerer parameteren x først ganget med 4 for seg og 2 for seg og så ganget med hverandre igjen for så å dele på 2. + return ((4 * x) * (2 * x))/2 + +print(l(8)) + +# definerer funksjonen +def h(x): + # returnerer parameteren x først ganget med 2 opphøyd i andre og så plusset med 4. + return 4 + x * 2**2 + +print(h(8)) + +# definerer funksjonen +def g(x): + # returnerer parameteren x først ganget med 2, deretter opphøyd i andre og så plusset med 4. + return 4 + (x * 2)**2 + +print(g(8)) + + +########## Eksempel 1 ########## + +# VARIANT MED if-elif hvilket er forkortelse av "else if". Ulempen er at hvis det er både ekstremt varmt/kaldt og storm vil +# elif som står først være den som slår inn. +def ekstremvær_if_elif(temp, vind): + if temp < -30: + return "VARSEL: Ekstremt kaldt!" + elif temp > 40: + return "VARSEL: Ekstremt varmt!" + elif vind > 20: + return "VARSEL: Storm!" + +ekstremvær_if_elif(-35, 2) + +ekstremvær_if_elif(50, 2) + +ekstremvær_if_elif(10, 25) + diff --git "a/\303\270vinger/\303\270ving_2/stud7/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud7/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..818759f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud7/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,396 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.5\n", + "Jeg burde bruke paraply i dag: Ja\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.5)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "# definerer funksjonen kake_ut_av_ovnen hvor parametren funksjonen tar inn er 'tid' og som bruker if setning (engelsk: if statement). \n", + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + "\n", + " if tid >= 50:\n", + " # denne linjen printes kun om verdien man setter inn for parameteren 'tid' er 50 eller et høyere tall.\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " # denne linjen printes uavhengig av 'tid'.\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " # skaper en prikket linje som gir luft mellom teksten og gjør det lettere å lese.\n", + " print(\"----------------------------------------\")\n", + "# her skriver man inn verdien til 'tid' manuelt.\n", + "kake_ut_av_ovnen(10)\n", + "# her skriver man inn neste verdien til 'tid' manuelt, og denne vil derfor kjøres etter linjen over har kjørt igjennom hele if-funksjonen.\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 0 minutter.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " \n", + " if tid >= 50: \n", + " print(\"Kaken kan tas ut av ovnen.\") \n", + " print(\"Tips til servering: vaniljeis.\")\n", + " \n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen_losning(0)\n", + "\n", + "kake_ut_av_ovnen_losning(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud8/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud8/aarstider.ipynb" new file mode 100644 index 0000000..5497b7f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud8/aarstider.ipynb" @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "liste = ['januar', 'februar', 'mars', 'april', 'mai', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'desember']\n", + "\n", + "#def arstid (*text,x):\n", + " # return func(text)\n", + "#for maned in ['januar', 'februar', 'mars', 'april', 'mai', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'desember']:\n", + " # x=arstid\n", + " # print(x)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n", + "Det er kald vinter.\n" + ] + } + ], + "source": [ + "\n", + "def arstid (maned, x):\n", + " for maned in liste: \n", + " if 'januar' or 'februar' in liste: \n", + " print('Det er kald vinter.') #fant ut at den skriver ut denne koden uansett\n", + " elif 'mars' in liste:\n", + " if x <= 19:\n", + " print('Det er senvinter.')\n", + " else:\n", + " print('Det er tidlig vår.') \n", + " elif 'april' or 'mai' in liste:\n", + " print('Det er vår.')\n", + " elif 'juni' in liste:\n", + " if x <= 20:\n", + " print('Det er sen vår.')\n", + " else:\n", + " print('Det er tidlig sommer.')\n", + " elif 'juli' or 'august' in liste:\n", + " print('Det er sommer.')\n", + " elif 'september' in liste:\n", + " if x <= 21:\n", + " print ('Det er sen sommer.')\n", + " else: \n", + " print('Det er tidlig høst.')\n", + " elif 'oktober' or 'november' in liste:\n", + " print ('Det er høst.')\n", + " elif 'desember' in liste:\n", + " if x <= 20:\n", + " print ('Det er sen høst, og noen vil si vinter')\n", + " else:\n", + " print ('Det er straks jul og vinter.')\n", + " else:\n", + " print ('Her ble det litt feil.')\n", + "\n", + "\n", + "arstid('mai', 6)\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Høst'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def arstid(m,d):\n", + " if m == 'mars':\n", + " if d < 20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == 'juni':\n", + " if d < 21:\n", + " return \"Vår\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m == 'september':\n", + " if d < 22:\n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == 'desember':\n", + " if d < 21:\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + " elif m == 'januar' or m == 'februar':\n", + " return 'Vinter'\n", + " elif m == 'april' or m == 'mai':\n", + " return 'Vår'\n", + " elif m == 'juli' or m == 'august':\n", + " return 'Sommer'\n", + " else:\n", + " return 'Høst'\n", + "arstid('desember', 16)" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud8/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud8/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..f754e87 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud8/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "a = 2\n", + "b = 3\n", + "c = 5 * a + b\n", + "d = a * b + c\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Skriv koden din her\n", + "def f(x):\n", + " return 2 * x + 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud8/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud8/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud8/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud8/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud8/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..a069c0f --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud8/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,616 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\" #over -30\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\" #over 40 True\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\" #under 20\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20: #temp over -30 False or temp under 40 False or vind over 20 True ergo Varsel\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = 3\n", + "y = 8\n", + "z =-3\n", + "#Uttrykk 1\n", + "-5 < z and 5 > z # True and True gir True" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Uttrykk 2\n", + "not y == 8 #not True gir False" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Uttrykk 3\n", + "x == 8 or y == 8 # (not False gir True) or (not True gir False) første er True og derfor True" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Uttrykk 4\n", + "not (x <= 3 or y >= 9) # not (True or False), første er True og derfor False" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Uttrykk 5\n", + "not (x**2 != 8 and y-z == 5) or x+y == y-z #not(9 er forkjellig fra 8 er True and 11 er lik 5 er False )or (11 er lik 11 er True)\n", + " #not(True and False) or True\n", + " # False or True, nummer to er True og derfor True" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Svar: Uttrykk 1, 3 og 5 gir svar True" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + }, + { + "data": { + "text/plain": [ + "'Minst ett av tallene er utenfor et gyldig intervall :('" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" )\n", + "\n", + "def gyldige_tall(a, b):\n", + " if (a>70 and a<<90) or (a>40 and not a>=50) and (70<b<90 or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + "\n", + "gyldige_tall(32,47)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\n" + ] + }, + { + "data": { + "text/plain": [ + "'Tallene er begge i gyldige intervall!'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + " \n", + "print(\"Gi inn a og b, begge heltall i intervall <40,50> eller <70,90>:\" ) #jeg er usikker men velger å tolke dette som fra og med, til\n", + " # dvs fra og med 40 til 50 og fra og med 70 til 90\n", + " # jeg overser at oppgaven poengterer heltall, dvs. burde \n", + " #gitt svar om at et desimaltall er ikke et heltall\n", + " #det kompliserer om jeg evt må blande inn int og float\n", + "def gyldige_tall(a, b):\n", + " if ((a>=70 and a<90) or (a>=40 and a<50)) and ((b>=70 and b<90) or (b>=40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\" \n", + " \n", + "gyldige_tall(83.2, 83.4) \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud8/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud8/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..c190075 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud8/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,433 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 22.2\n", + "Jeg burde bruke paraply i dag: Ta heller med deg snorkel og svømmeføtter\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\") #måtte bare teste litt ekstra\n", + " \n", + " \n", + " if regn > 20.0:\n", + " return \"Ta heller med deg snorkel og svømmeføtter\"\n", + " elif regn > 0.1:\n", + " return \"Ja\"\n", + " else:\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(22.2)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.2\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 10 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "kake_ut_av_ovnen(10)\n", + "\n", + "kake_ut_av_ovnen(60)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 35 minutter.\n", + "La kaken steke i 15 minutter til før du tar den ut.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " \"\"\"Skriv koden her\"\"\"\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " \n", + " if tid >= 50: \n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " else:\n", + " print(f\"La kaken steke i {50-tid} minutter til før du tar den ut.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + " \n", + " \n", + "kake_ut_av_ovnen_losning(35)\n", + "\n", + "kake_ut_av_ovnen_losning(50)\n", + "\n", + "kake_ut_av_ovnen_losning(60)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud9/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud9/aarstider.ipynb" new file mode 100644 index 0000000..44d8e24 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud9/aarstider.ipynb" @@ -0,0 +1,155 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Årstider\n", + "\n", + "**Læringsmål:**\n", + "- Betingelser\n", + "- Logiske uttrykk\n", + "\n", + "I denne oppgaven skal en bruker skrive inn dag og måned og få ut hvilken årstid datoen tilhører.\n", + "\n", + "Et år har (offisielt) fire årstider, og i denne oppgaven tar vi utgangspunkt i at årstidsskiftene følger tabellen nedenfor. **(Merk deg datoene)**\n", + "\n", + "\n", + "Årstid | Første dag\n", + "--- | ---\n", + "Vår | 20. mars\n", + "Sommer | 21. juni\n", + "Høst | 22. september\n", + "Vinter | 21. desember" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "**Oppgave:** Lag en funksjon som tar inn en måned som en streng og en dag i denne måneden som et tall fra brukeren. Funskjonen skal så returnere årstiden assosiert med denne datoen.\n", + "\n", + "Du kan anta at inputen er en gyldig dato.\n", + "\n", + "**Eksempel på kjøring:**\n", + "```python\n", + ">>>arstid('mars', 20)\n", + "\n", + "Vår\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('januar', 2)\n", + "\n", + "Vinter\n", + "``` \n", + " \n", + "```python\n", + ">>>arstid('november', 17)\n", + "\n", + "Høst\n", + "```\n", + "\n", + "___Skriv din kode her:___" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Datoen i dag er 9 mai og årstiden er <function arstid at 0x0000022B2D6A3EC0>\n" + ] + } + ], + "source": [ + "m = input(\"Hvilken måned er det? F.eks. Januar, September, Mai, osv.\")\n", + "d = int(input(\"Hvilken dato er det i dag? F.eks. 01, 13, 27, osv.\"))\n", + "\n", + "def arstid(m, d):\n", + " if m == 'mars':\n", + " if d<20:\n", + " return \"Vinter\"\n", + " else:\n", + " return \"Vår\"\n", + " elif m == 'juni':\n", + " if d<21:\n", + " return \"Vår\"\n", + " else:\n", + " return \"Sommer\"\n", + " elif m == 'september': \n", + " if d<22: \n", + " return \"Sommer\"\n", + " else:\n", + " return \"Høst\"\n", + " elif m == \"desember\":\n", + " if d<21:\n", + " return \"høst\"\n", + " else: \n", + " return \"vinter\"\n", + " elif m == \"april\" or m == \"mai\":\n", + " return \"vår\"\n", + " elif m == \"juni\" or m == \"august\":\n", + " return \"sommer\"\n", + " elif m == \"oktober\" or m == \"november\":\n", + " return \"Høst\"\n", + " else:\n", + " return \"Vinter\"\n", + "\n", + "print(\"Datoen i dag er\", d, m,\"og årstiden er\", arstid,)\n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud9/funksjoner_og_kalkulasjoner.ipynb" "b/\303\270vinger/\303\270ving_2/stud9/funksjoner_og_kalkulasjoner.ipynb" new file mode 100644 index 0000000..c35ffe9 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud9/funksjoner_og_kalkulasjoner.ipynb" @@ -0,0 +1,371 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "run_control": { + "frozen": true + } + }, + "source": [ + "# Funksjoner og kalkulasjoner\n", + "\n", + "**Læringsmål**:\n", + "\n", + "* Aritmetikk\n", + "* Funksjoner\n", + "\n", + "\n", + "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", + "metadata": { + "deletable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + }, + "solution": "hidden" + }, + "source": [ + "### Tutorial - Matteoperasjoner del 1: Vanlige operatorer, parenteser, presedens\n", + "Les gjerne denne før du starter med oppgavene" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mange likheter mellom Python og vanlig matematisk skrivemåte av aritmetiske uttrykk, men også noen forskjeller.\n", + "\n", + "Tabellen under oppsummerer det mest grunnleggende:\n", + " \n", + "Matematikk | Python | Merknad\n", + "--- | --- | ---\n", + "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.\n", + "a - b | a - b | Bruk det vanlige bindestrek-tegnet for minus\n", + "a · b |a * b| Bruk stjerntegn (asterisk) for multiplikasjon\n", + "ab|<span style=\"color:red\">**NEI**</span>| I Python må gangetegn **alltid** skrives eksplisitt, kan ikke utelates\n", + "a : b|a / b|Vanlig skråstrek brukes for divisjon, **ikke** kolon eller horsintal brøkstrek.\n", + "a<sup>b</sup>|a ** b| Dobbel stjerne for potens. De to stjernene må stå kloss inntil hverandre.\n", + "[(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.\n", + "\n", + "**Presedens** mellom operatorer fungerer som i matematikken.\n", + "\n", + "* Multiplikasjon og divisjon har høyere presedens enn addisjon og subtraksjon.\n", + " * 3 + 2 * 5 blir 13, fordi * gjøres før +.\n", + " * 5 - 1 / 2 blir 4.5, fordi / gjøres før -.\n", + "* Potens har høyere presedens enn multiplikasjon og divisjon.\n", + " * 5 * 2 ** 3 blir 40, fordi ** gjøres før *.\n", + "* Parenteser kan brukes for å få en annen rekkefølge på regneoperasjonene:\n", + " * (3 + 2) * 5 blir 25, fordi + gjøres før *.\n", + " * (5 - 1) / 2 blir 2, fordi - gjøres før /.\n", + " * (5 * 2) ** 3 blir 343, fordi * nå gjøres før **.\n", + "* Hvis du skal \"oversette\" et matematisk uttrykk med parenteser til Python, bruk parenteser på samme sted også i Python-koden.\n", + "\n", + "**I noen tilfeller kan du trenge ekstra parenteser i Python-koden som ikke var i det matematiske uttrykket. F.eks.:** \n", + "\n", + " $$\\frac{2-x}{2+x}$$ \n", + "\n", + "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)\n", + "\n", + " $$3^{xy+1}$$\n", + "\n", + "Opphøyet skrift viser at hele xy+1 er potensen. I Python må man skrive 3 ** (x * y + 1)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "### a) Korrekt programmering av aritmetiske utrykk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Skriv følgende matematikk-setninger korrekt i Python:\n", + "\n", + "La $a$ være $2$\n", + "\n", + "La $b$ være $3$\n", + "\n", + "La $c$ være $5a + b$\n", + "\n", + "La $d$ være $a * b + c$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "3\n", + "13\n", + "19\n" + ] + } + ], + "source": [ + "# Skriv koden din her\n", + "a=2\n", + "b=3\n", + "c=5*a+b\n", + "d=a*b+c\n", + "\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "2\n", + "3\n", + "13\n", + "19\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# Kjør denne kodeblokken for å sjekke at koden du har skrevet over er rett\n", + "print(a)\n", + "print(b)\n", + "print(c)\n", + "print(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Tutorial - Funksjoner:\n", + "Les gjerne denne før du begynner på oppgaven" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "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$. \n", + "\n", + "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. \n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "metadata": { + "hidden": true + }, + "source": [ + "Eksempel på den matematiske funksjonen $f(x) = 2x + 3$ i Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def f(x): # Definerer funksjonen\n", + " return 2 * x + 3 # Returnerer parameteren x ganget med 2 og plusset med 3" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### b) Skrive funksjonsuttrykk riktig i Python" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Skriv følgende matematiske funksjoner i Python:**\n", + "\n", + "$f(x) = 2x + 1$\n", + "\n", + "**_Skriv koden din i kodeblokken under_**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "**Hint:** Bruk av **numpy** biblioteket kan gjøre noen av funksjonene lettere " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "# Skriv koden din her\n", + "import math\n", + "import numpy as np\n", + "def f(x):\n", + " return 2*x + 1\n", + "\n", + "print(f(10))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hidden": true + }, + "source": [ + "Kjør kodeblokken under for å se at koden din fugerer som forventet. Hvis du har gjort alt rett, vil output være:\n", + "\n", + "```python\n", + "21\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "print(f(10))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud9/lab-2.md" "b/\303\270vinger/\303\270ving_2/stud9/lab-2.md" new file mode 100644 index 0000000..d26f4eb --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud9/lab-2.md" @@ -0,0 +1,15 @@ +# Lab-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. + +### Læringsaktiviteter + +* [Funksjoner og kalkulasjoner](funksjoner_og_kalkulasjoner.ipynb) +* [Logiske operatorer og uttrykk](logiske_operatorer_uttrykk.ipynb) +* [Valg](ulike_typer_if_setninger.ipynb) +* [Årstider](aarstider.ipynb) diff --git "a/\303\270vinger/\303\270ving_2/stud9/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud9/logiske_operatorer_uttrykk.ipynb" new file mode 100644 index 0000000..9dda0e7 --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud9/logiske_operatorer_uttrykk.ipynb" @@ -0,0 +1,488 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Logiske operatorer og logiske uttrykk\n", + "\n", + "**Læringsmål:**\n", + "- Logiske uttrykk\n", + "- Betingelser\n", + "- Kodeforståelse\n", + "- Funksjoner\n", + "\n", + "I denne oppgaven skal vi lære om logiske uttrykk og hvordan de kan settes sammen med `and`, `or` og `not`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om logiske operatorer og logiske uttrykk\n", + "\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynner." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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:\n", + "\n", + "- `==` (som betyr \"er lik\", merk at her er to likhetstegn nødvendig for å skille fra tilordningsoperatoren)\n", + "- `!=` (som betyr \"ulik\", altså det motsatte av ==)\n", + "- `>` , `<` , `>=` , `<=` (som betyr henholdsvis større, mindre, større eller lik, og mindre eller lik)\n", + "\n", + "Ofte kan beslutninger være avhengig av verdien til **flere** variable, eller for den del flere betingelser for samme variabel.\n", + "\n", + "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.\n", + "\n", + "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", + "\n", + "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", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 1 ##########\n", + "\n", + "# VARIANT MED if-elif\n", + "def ekstremvær_if_elif(temp, vind):\n", + " if temp < -30:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif temp > 40:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " elif vind > 20:\n", + " return \"VARSEL: Ekstremvær!\"\n", + " \n", + "ekstremvær_if_elif(50, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'VARSEL: Ekstremvær'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "########## Eksempel 2 ##########\n", + "\n", + "# VARIANT MED SAMMENSATT BETINGELSE\n", + "def ekstremvær_sammensatt(temp, vind):\n", + " if temp < -30 or temp > 40 or vind > 20:\n", + " return \"VARSEL: Ekstremvær\"\n", + "\n", + "ekstremvær_sammensatt(10, 40)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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...\n", + "\n", + "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", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-02T06:42:19.110725Z", + "start_time": "2019-07-02T06:42:10.950922Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 3 ##########\n", + "\n", + "def paraply(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED NØSTEDE if-setninger\n", + " if regn > 0.2:\n", + " if vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + " \n", + "\n", + "anbefaling = paraply(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Vind i sekundmeter: 6.0\n", + "Anbefaler paraply.\n" + ] + } + ], + "source": [ + "########## Eksempel 4 ##########\n", + "\n", + "def paraply_sammensatt(regn, vind):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(f\"Vind i sekundmeter: {vind}\")\n", + " \n", + " # VARIANT MED SAMMENSATT BETINGELSE\n", + " if regn > 0.2 and vind < 7.0:\n", + " return \"Anbefaler paraply.\"\n", + " return \"Anbefaler ikke paraply\"\n", + "\n", + "anbefaling = paraply_sammensatt(0.3, 6.0)\n", + "print(anbefaling)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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å.\n", + "\n", + "Det er typisk tre operatorer vi bruker for å sette sammen betingelser: `and`, `or`, `not`\n", + "\n", + "Disse virker på følgende måte:\n", + "\n", + "- betingelse1 `and` betingelse2 blir True (sant) bare hvis **både** betingelse1 og betingelse2 er True, ellers blir uttrykket False (usant)\n", + "- betingelse1 `or` betingelse2 blir True (sann) hvis **minst en** av betingelsene er True, ellers False\n", + "- `not` betingelse1 blir True hvis betingelse1 er False, og False hvis betingelse1 er True\n", + "- Man kan sette sammen mer komplekse betingelser ved å bruke flere av dem. \n", + "\n", + "Presedensregler: `not` har større presedens enn `and`, som har større enn `or`.\n", + "\n", + "F.eks. anta at\n", + "\n", + "`if regn > 0.2 and vind < 7.0 or solbrentfare > 0.9 and not solkrembeholdning > 0:` er gitt som betingelse for å ta med paraply\n", + "\n", + "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:\n", + "\n", + "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)\n", + "ELLER at `solbrentfare > 0.9` er sann, samtidig som `solkrembeholdning > 0` er usann (slik at `not solkrembeholdning > 0` vil være sann)\n", + "I det siste tilfellet er det rimelig å anta at paraply er tenkt å beskytte mot sol, ikke mot regn.\n", + "\n", + "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.\n", + "\n", + "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.\n", + "\n", + "- `not a < 10` kan like gjerne skrives `a >= 10`\n", + "- `not a == 10` kan like gjerne skrives `a != 10`\n", + "- `not (c < 0 or c > 255)` kan like gjerne skrives `c >= 0 and c <= 255` eller enda enklere `0 <= c <= 255`.\n", + "Det fins tilfeller hvor `not` er lurt å bruke, men bruk den med måte, bare når bedre alternativer ikke finnes." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Hvilke av de følgende logiske uttrykkene vil gi True om `x=3`, `y=8` og `z=-3`?\n", + "\n", + "Uttrykk 1: `-5 < z and 5 > z` \n", + "Uttrykk 2: `not y == 8` \n", + "Uttrykk 3: `x == 8 or y == 8` \n", + "Uttrykk 4: `not (x <= 3 or y >= 9)` \n", + "Uttrykk 5: `not (x**2 != 8 and y-z == 5) or x+y == y-z` \n", + "\n", + "Dobbelklikk på teksten under og skriv svaret ditt der:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hide_input": false + }, + "source": [ + "Uttrykk 1: -5 < z and 5 > z True \n", + "Uttrykk 2: not y == 8 False \n", + "Uttrykk 3: x == 8 or y == 8 True \n", + "Uttrykk 4: not (x <= 3 or y >= 9) False \n", + "Uttrykk 5: not (x**2 != 8 and y-z == 5) or x+y == y-z True \n", + "\n", + "x=3\n", + "y=8\n", + "z=-3\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "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>)`.\n", + "\n", + "Husk presedensregler: `not` har større presedens enn `and`, som har større enn `or`. \n", + "Du kan teste kode her:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=3\n", + "y=8\n", + "z=-3\n", + "\n", + "-5 < z and 5 > z\n", + "\n", + "not y == 8 \n", + "\n", + "x == 8 or y == 8 \n", + "\n", + "not (x <= 3 or y >= 9)\n", + "\n", + "not (x**2 != 8 and y-z == 5) or x+y == y-z\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "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.\n", + "\n", + "Dessverre er det feil i koden som gjør at den ikke fungerer slik den skal. Din oppgave er å rette opp i disse feilene.\n", + "\n", + "***Rett opp feilene under og sjekk at koden fungerer for alle tilfeller***" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minst ett av tallene er utenfor et gyldig intervall :(\n" + ] + } + ], + "source": [ + "\n", + "def gyldige_tall(a, b):\n", + " if ((a>70 and a<90) or (a>40 and not a>=50) and (70<b<90) or (b>40 and b<50)):\n", + " return \"Tallene er begge i gyldige intervall!\"\n", + " else:\n", + " return \"Minst ett av tallene er utenfor et gyldig intervall :(\"\n", + " \n", + "print(gyldige_tall(40,50) or (70,90))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "#### Hint" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Husk parenteser!" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/\303\270vinger/\303\270ving_2/stud9/ulike_typer_if_setninger.ipynb" "b/\303\270vinger/\303\270ving_2/stud9/ulike_typer_if_setninger.ipynb" new file mode 100644 index 0000000..4ef1e8b --- /dev/null +++ "b/\303\270vinger/\303\270ving_2/stud9/ulike_typer_if_setninger.ipynb" @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "# Ulike typer if-setninger\n", + "\n", + "**Læringsmål:**\n", + "\n", + "- Betingelser" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "heading_collapsed": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "## Generelt om if-setninger\n", + "Dette er ikke en del av oppgaven, men kan være lurt å lese før du begynnner. **Trykk på pilen til venstre for å lese**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "I oppgavene i øving 1 har det vært slik at alle setningene i programmet skulle utføres hver gang programmet kjørte. De fleste nyttige programmer er ikke så enkle. Ofte skal visse programsetninger kun utføres under gitte betingelser. Overtidslønn skal utbetales bare hvis det har vært jobbet overtid. Monsteret du kjemper mot i et spill, skal miste liv bare hvis skuddet eller sverdslaget ditt har truffet. En alarm skal aktiveres bare hvis pasientens hjerterytme er blitt unormal. En sosial app på mobilen skal gi et spesielt varsel bare hvis du har fått nye meldinger der. Funksjonen nedenfor viser et eksempel hvor alle linjene blir utført uavhengig av hva som gis som input - denne funksjonen vil anbefale paraply uansett hvordan været er." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Da anbefaler jeg paraply!\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_simpel(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_simpel(0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Paraply bør anbefales bare ved behov, f.eks. hvis det var meldt mer enn 0.2 mm regn. Det oppnår vi ved å inkludere en if-setning i funksjonen som undersøker hvor mye regn det er meldt:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.1\n", + "Jeg burde bruke paraply i dag: Nei\n" + ] + } + ], + "source": [ + "def paraply_anbefaling(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " return \"Ja\"\n", + " return \"Nei\"\n", + "\n", + "anbefaling = paraply_anbefaling(0.1)\n", + "print(f\"Jeg burde bruke paraply i dag: {anbefaling}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Den ovenstående funksjonen viser en if-setning. Den har følgende struktur:\n", + "\n", + "- starter med ordet `if`, dette er et beskyttet ord i Python og kan derfor ikke brukes som variabelnavn e.l.\n", + "- bak if kommer en logisk betingelse - i dette tilfellet `regn > 0.2` - som vil være enten sann (`True`) eller usann (`False`), her avhengig av innholdet i variabelen regn\n", + "- bak betingelsen **må** if-setningen ha `:` **(kolon)** - hvis du glemmer kolon vil du få syntaksfeil. \n", + "- kodelinjen like under if har et innrykk (tabulator), dette betyr at denne linjen - `return \"Ja\"` - er del av if-setningen. Den vil bli utført **kun hvis betingelsen i if-setningen er sann**, som vil inntreffe hvis brukeren skriver inn et større tall enn 0.2\n", + "- siste kodelinje, `return \"Nei\"` har ikke innrykk, og vil utføres dersom det ikke har blitt returnert noe fra funksjonen enda, med andre ord, dersom `if`-blokken ikke ble gjennomført" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Det er mulig å ha flere programsetninger som del av if-setningen, for eksempel:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regn i mm: 0.3\n", + "Da anbefaler jeg paraply!\n", + "Gjerne en paraply med NTNU-logo.\n", + "Ha en fin tur til universitetet!\n" + ] + } + ], + "source": [ + "def paraply_if(regn):\n", + " print(f\"Regn i mm: {regn}\")\n", + " \n", + " if regn > 0.2:\n", + " print(\"Da anbefaler jeg paraply!\")\n", + " print(\"Gjerne en paraply med NTNU-logo.\")\n", + " print(\"Ha en fin tur til universitetet!\")\n", + "\n", + "paraply_if(0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T08:54:49.298821Z", + "start_time": "2019-07-01T08:54:49.289265Z" + }, + "deletable": false, + "editable": false, + "hidden": true, + "run_control": { + "frozen": true + } + }, + "source": [ + "Her vil begge \"print\"-setningene om paraply kun bli utført hvis betingelsen er sann, mens \"fin tur\"-setningen fortsatt blir utført uansett utfall av if-setningen.\n", + "\n", + "**Altså: I Python viser innrykk hvor mange av de påfølgende setningene som styres av if-betingelsen.** Det er derfor viktig å være nøye med innrykkene og få alle programsetninger på korrekt indentasjonsnivå.\n", + "\n", + "Test gjerne ut koden over med forskjellige svar på mm regn for å se hvordan den virker." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "## a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "editable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Du lager en banankake som skal stå minst 50 min i ovnen. Ta utgangspunkt i følgende program, som har den svakheten at det sier at kaken skal ut uansett hvor lenge den har stekt.\n", + "\n", + "___Endre programmet slik at \"Kaken kan tas ut av ovnen\" kun printes hvis kaken har stått minst 50 minutt. \"Større eller lik\" skrives i Python >=___ \n", + "___Tips til servering... skal derimot printes uansett.___" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2019-07-01T15:44:45.569935Z", + "start_time": "2019-07-01T15:44:42.453083Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Kaken er ikke ferdig stekt.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 60 minutter.\n", + "Kaken kan tas ut av ovnen.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n", + "Kaken har vært i ovnen i 22 minutter.\n", + "Kaken er ikke ferdig stekt.\n", + "Tips til servering: vaniljeis.\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "def kake_ut_av_ovnen(tid):\n", + " print(f\"Kaken har vært i ovnen i {tid} minutter.\")\n", + " if tid > 49:\n", + " print(\"Kaken kan tas ut av ovnen.\")\n", + " if tid < 50:\n", + " print(\"Kaken er ikke ferdig stekt.\")\n", + " print(\"Tips til servering: vaniljeis.\")\n", + " print(\"----------------------------------------\")\n", + "\n", + "\n", + "kake_ut_av_ovnen(50)\n", + "kake_ut_av_ovnen(35)\n", + "kake_ut_av_ovnen(60)\n", + "kake_ut_av_ovnen(22)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def kake_ut_av_ovnen_losning(tid):\n", + " \"\"\"Skriv koden her\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "deletable": false, + "run_control": { + "frozen": true + } + }, + "source": [ + "Eksempel på utskrift fra tre ulike kjøringer, hvis du har fått det til riktig:\n", + "```\n", + "kake_ut_av_ovnen_losning(35)\n", + "Kaken har vært i ovnen i 35 minutter.\n", + "Tips til servering: vaniljeis. \n", + ">>> \n", + " \n", + "kake_ut_av_ovnen_losning(50)\n", + "Kaken har vært i ovnen i 50 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis. \n", + ">>>\n", + " \n", + "kake_ut_av_ovnen_losning(65)\n", + "Kaken har vært i ovnen i 65 minutter.\n", + "Kaken kan tas ut av ovnen. \n", + "Tips til servering: vaniljeis.\n", + ">>>\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "265px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} -- GitLab