diff --git a/lectures/chap5/lab/database_name.db b/lectures/chap5/lab/database_name.db
new file mode 100644
index 0000000000000000000000000000000000000000..445206da94529925a8de9c8aed4778620352e5e9
Binary files /dev/null and b/lectures/chap5/lab/database_name.db differ
diff --git a/lectures/chap5/lab/databaser.ipynb b/lectures/chap5/lab/databaser.ipynb
index 41c8d0dd36e4efb7cf3780c20015cf961230c719..3f7ae267ead47cce86def1142c2f61ac544c0f48 100644
--- a/lectures/chap5/lab/databaser.ipynb
+++ b/lectures/chap5/lab/databaser.ipynb
@@ -26,70 +26,104 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
- "# Viser hvordan vi kobler oss mot MySQL og leser/oppdaterer data.\n",
- "# Må installere PyMySQL først: pip install pymysql\n",
- "import pymysql"
+ "# Viser hvordan vi kobler oss mot SQLite og leser/oppdaterer data.\n",
+ "# Importerer modulen sqlite3 (trenger ikke installasjon)\n",
+ "import sqlite3 as sql"
]
},
{
- "attachments": {},
- "cell_type": "markdown",
+ "cell_type": "code",
+ "execution_count": 11,
"metadata": {},
+ "outputs": [],
"source": [
- "For å logge oss inn på databasen, må vi ha en konto på database-serveren.\n",
- "\n",
- "Følgende informasjon må vi ha:\n",
- "\n",
- "- host: navn på database-server\n",
- "- user: brukernavn for å koble oss til serveren\n",
- "- password: passord for å koble oss til serveren\n",
- "- database: database seed (en database server kan inneholde mange database instanser)\n",
- "\n",
- "Dersom vi ikke ønsker å \"hardkode\" passord (skrive det i programmet i klar tekst eller i en fil), kan vi bruke modulen **getPass** for å taste inn passordet når programmet starter.\n"
+ "# Oppretter en tilkobling til databasen\n",
+ "# Hvis databasen ikke eksisterer, opprettes den\n",
+ "# Hvis databasen eksisterer, kobler vi oss til den\n",
+ "connection = sql.connect('database_name.db')"
]
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
- "# importer funksjonen getpass fra modulen getpass.\n",
- "# Vi bruker getpass for å lese passord fra bruker (slik at det ikke vises i klartekst)\n",
- "from getpass import getpass"
+ "# Oppretter en cursor som lar oss utføre SQL-kommandoer\n",
+ "# Cursor er en peker som lar oss utføre SQL-kommandoer\n",
+ "# En peker er en variabel som inneholder en adresse til et objekt\n",
+ "cursor = connection.cursor()"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 13,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<sqlite3.Cursor at 0x1b1563627c0>"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "# Database connection object\n",
- "global db_connection\n",
- "db_connection = None\n",
+ "# Oppretter en tabell\n",
+ "# Hvis tabellen ikke eksisterer, opprettes den\n",
+ "# Hvis tabellen eksisterer, opprettes den ikke på nytt\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "table_name = 'brukere'\n",
"\n",
- "my_host = \"mysql.stud.iie.ntnu.no\"\n",
- "my_user = \"rouhani\" # Skriv inn brukernavnet ditt her\n",
- "my_password = getpass()\n",
- "my_database = \"rouhani\"\n",
+ "create_table = f'''\n",
+ " CREATE TABLE IF NOT EXISTS {table_name} (\n",
+ " id INTEGER PRIMARY KEY,\n",
+ " name TEXT\n",
+ " )\n",
+ "'''\n",
"\n",
- "def get_db_connection():\n",
- " if 'db_connection' in globals():\n",
- " db_connection = pymysql.connect(host = my_host, user = my_user, password = my_password, database = my_database)\n",
- " return db_connection"
+ "cursor.execute(create_table)"
]
},
{
- "attachments": {},
- "cell_type": "markdown",
+ "cell_type": "code",
+ "execution_count": 14,
"metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<sqlite3.Cursor at 0x1b1563627c0>"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "### Koble opp mot databasen og les fra en tabell"
+ "# Definer data som skal settes inn i tabellen\n",
+ "# Liste med tupler\n",
+ "user_data = [\n",
+ " (1, 'John'),\n",
+ " (2, 'Jane'),\n",
+ " (3, 'Alice')\n",
+ "]\n",
+ "\n",
+ "# Insert the data into the table\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "# Vi kan bruke executemany for å sette inn flere rader samtidig\n",
+ "cursor.executemany(f'''\n",
+ " INSERT OR REPLACE INTO {table_name} (id, name)\n",
+ " VALUES (?, ?)\n",
+ "''', user_data)"
]
},
{
@@ -101,184 +135,74 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "('TBM.0832', 'Stol', 1, '12.04.2023', 'Hanne', '12.04.2023', 'Kristin', 'Olsen Giver', 'PL.A1.B2', 'Tester')\n",
- "('TBM.4892', 'Kommode', 1, '03.04.2011', 'Museumsbestyrer Olav N', '29.04.2012', 'Museumsbestyrer Olav Nilsen', 'Museumsbestyrer Olav Nilsen', 'M1.R2.P1.H1', '')\n"
+ "(1, 'John')\n",
+ "(2, 'Jane')\n",
+ "(3, 'Alice')\n"
]
}
],
"source": [
+ "# Henter ut data fra tabellen\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "# Vi kan bruke * for å hente ut alle kolonner\n",
+ "# Vi kan bruke WHERE for å filtrere data\n",
+ "# Vi kan bruke ORDER BY for å sortere data\n",
+ "# Vi kan bruke LIMIT for å begrense antall rader\n",
+ "# Vi kan bruke OFFSET for å hoppe over rader\n",
+ "# Vi kan bruke LIKE for å filtrere data med et mønster (wildcard)\n",
+ "# Vi kan bruke IN for å filtrere data med flere verdier\n",
+ "# Vi kan bruke IS NULL for å filtrere data som er NULL\n",
+ "# Vi kan bruke IS NOT NULL for å filtrere data som ikke er NULL\n",
+ "# Vi kan bruke DISTINCT for å filtrere ut duplikater\n",
+ "# Vi kan bruke COUNT for å telle antall rader\n",
+ "cursor.execute(f'SELECT * FROM {table_name}')\n",
"\n",
+ "# Fetch all rows as a list of tuples\n",
+ "rows = cursor.fetchall()\n",
"\n",
- "with get_db_connection() as my_db:\n",
- " my_cursor = my_db.cursor()\n",
- "\n",
- " my_sql = \"SELECT * FROM objects\"\n",
- " my_cursor.execute(my_sql)\n",
- "\n",
- " for row in my_cursor:\n",
- " print(row)\n",
- "\n"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Koble opp mot databasen og oppdater rader i en tabell\n"
+ "# Print the rows\n",
+ "# Vi kan bruke for-løkke for å iterere over resultatet\n",
+ "for row in rows:\n",
+ " print(row)\n"
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
- "#Sjekk om regnr existerer i databasen\n",
- "def reg_no_exist(reg_no,table_name):\n",
- " \"\"\"\n",
- " Sjekk om regnnr existerer allerede i basen\n",
- " :param regnr: type string\n",
- " :return: boolean\n",
- " \"\"\"\n",
- " with get_db_connection() as db:\n",
- "\n",
- " cursor = db.cursor()\n",
- " sql = \"SELECT count(reg_no) as reg_no_count FROM {0} WHERE reg_no='{1}'\".format(table_name,reg_no)\n",
- " cursor.execute(sql)\n",
- "\n",
- " reg_no_count = 0\n",
- "\n",
- " for row in cursor:\n",
- " reg_no_count= row[0]\n",
- "\n",
- " if reg_no_count==0:\n",
- " return False\n",
- " else:\n",
- " return True\n",
- "\n",
- "#Lagrer gjenstand i basen\n",
- "def save_object_db(giver_val,\n",
- " innlemmet_dato_val,\n",
- " kategori_id,\n",
- " kommentar_val,\n",
- " mottatt_av_val,\n",
- " navn_val,\n",
- " plassering_val,\n",
- " registrert_av_val,\n",
- " registrerings_dato_val,\n",
- " reg_no):\n",
- " \"\"\"\n",
- " Lagre gjenstand info i databasen.\n",
- " Dersom den finnes allerede, blir gjenstand oppdatert\n",
- " Dersom den ikke finnes, blir den opprettet.\n",
- " :param giver_val: string\n",
- " :param innlemmet_dato_val: string\n",
- " :param kategori_id: int\n",
- " :param kommentar_val: string\n",
- " :param mottatt_av_val: string\n",
- " :param navn_val: string\n",
- " :param plassering_val: string\n",
- " :param registrert_av_val: string\n",
- " :param registrerings_dato_val: string\n",
- " :param regnr: string\n",
- " :return:\n",
- " \"\"\"\n",
+ "# Oppdaterer data i tabellen\n",
+ "connection.commit()\n",
"\n",
- " #****************************************\n",
- " # Oppgave 4.1\n",
- " # Fullfør innholdet i denne funksjonen!\n",
- " #****************************************\n",
- "\n",
- " with get_db_connection() as my_db:\n",
- "\n",
- " my_db.autocommit(True)\n",
- " cursor = my_db.cursor()\n",
- "\n",
- " if reg_no_exist(reg_no,'objects'):\n",
- " cursor.execute(\"UPDATE objects SET giver=%s,in_date=%s,category_id=%s,comment=%s,received_by=%s,name=%s,placement=%s,reg_by=%s,reg_date=%s WHERE reg_no=%s\",\n",
- " (giver_val,innlemmet_dato_val,kategori_id,kommentar_val,mottatt_av_val,navn_val,plassering_val,registrert_av_val,registrerings_dato_val,reg_no))\n",
- " else:\n",
- " cursor.execute(\"INSERT INTO objects (giver,in_date,category_id,comment,received_by,name,placement,reg_by,reg_date,reg_no) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\",\n",
- " (giver_val,innlemmet_dato_val,kategori_id,kommentar_val,mottatt_av_val,navn_val,plassering_val,registrert_av_val,registrerings_dato_val,reg_no))\n",
- "\n",
- "#Oppdater eksisterende rad\n",
- "save_object_db('Olsen Giver','12.04.2023', 1, 'Tester', 'Kristin', 'Stol', 'PL.A1.B2','Hanne','12.04.2023','TBM.0832')\n",
- "\n",
- "\n",
- "#legg til ny rad\n",
- "save_object_db('Olsen Giver','12.04.2023', 1, 'Tester', 'Kristin', 'Stol', 'PL.A1.B2','Hanne','12.04.2023','TBM.0832-N')\n"
+ "# Lukker tilkoblingen til databasen\n",
+ "connection.close()"
]
},
{
- "attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Koble opp mot databasen og fjern rader fra en tabell"
+ "## Oppgave a)\n",
+ "Lag en ny tabell og kall den **emner**. Definer emnekode, tittel og beskrivelse (alle av typen streng)."
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
- "#Slett gjenstand\n",
- "def delete_object(reg_no):\n",
- " \"\"\"\n",
- " :param regnr: Registreriongsnr på gjenstand som skal slettes\n",
- " :return: ingen returverdi.\n",
- "\n",
- " Funksjonen skal finne gjenstanden og slette denne.\n",
- " 1. Slett fra properties-tabellen for det gitte registreringsnummeret\n",
- " 2. Slett fra provenances-tabellen for det gitte registreringsnummeret\n",
- " 3. Slett fra objects-tabellen for det gitte registreringsnummeret\n",
- "\n",
- " Dersom sletting går bra, skriv en melding til skjermen.\n",
- " \"\"\"\n",
- "\n",
- " #******************************************\n",
- " # Oppgave 4.3\n",
- " # Fullfør denne funksjonen\n",
- " #******************************************\n",
- "\n",
- "\n",
- " with get_db_connection() as db:\n",
- " db.autocommit(True)\n",
- "\n",
- " cursor = db.cursor()\n",
- " cursor.execute(\"DELETE from properties where reg_no='\" + reg_no+\"'\")\n",
- " cursor.execute(\"DELETE from provenances where reg_no='\" + reg_no+\"'\")\n",
- " cursor.execute(\"DELETE from objects where reg_no='\" + reg_no+\"'\")\n",
- "\n",
- "\n",
- "delete_object('TBM.0832-N')"
+ "# Svar"
]
},
{
- "attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
- "### a) Lag en funksjon som legger til nye kategorier i databasen"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Skriv kode her"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### b) Lag en funksjon som søker etter et object basert på reg_no"
+ "## Oppgave b\n",
+ "\n",
+ "Endre i tabellen \"brukere\" slik at det er en kobling mellom \"brukere\" og \"emner\". Nøkkel kan være emnekode."
]
},
{
@@ -287,24 +211,24 @@
"metadata": {},
"outputs": [],
"source": [
- "# Skriv kode her"
+ "# Svar"
]
},
{
- "attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
- "### c) Frivillig: Endre funksjonen i oppgave b slik at det søkes på enten reg_no eller navn (deler eller hele reg_no/navn)"
+ "## Oppgave C\n",
+ "Skriv kode som fyller tabellen emner med data fra en liste. Oppdater tabellen brukere slik at hver bruker peker på en eller flere emner."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
- "# Skriv kode her"
+ "# Svar "
]
}
],
diff --git a/lectures/chap5/lab/lotto.ipynb b/lectures/chap5/lab/lotto.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..090ce29638765cd71c30d61800618a0dc8b0ff6f
--- /dev/null
+++ b/lectures/chap5/lab/lotto.ipynb
@@ -0,0 +1,414 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "# Lotto\n",
+ "\n",
+ "**Læringsmål:**\n",
+ "\n",
+ "* Lister\n",
+ "* Tilfeldige tall\n",
+ "\n",
+ "\n",
+ "I denne oppgaven lage du lage en lottosimulator. \n",
+ "\n",
+ "Reglene er som følger:\n",
+ "\n",
+ "* Det trekkes ut 7 lottotall og 3 tilleggstall fra og med 1 til og med 34. Alle tallene som trekkes skal være unike.\n",
+ "* Premier deles ut basert på følgende tabell:\n",
+ "\n",
+ "Premiergruppe|Premie (kr)\n",
+ ":---|---\n",
+ "7 rette\t|2 749 455\n",
+ "6 rette + 1 tilleggstall\t|102 110\n",
+ "6 rette\t|3 385\n",
+ "5 rette\t|95\n",
+ "4 rette + 1 tilleggstall\t|45"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave a: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en liste som heter `numbers` og som inneholder alle heltall fra og med 1 til og med 34.\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:21:03.176781Z",
+ "start_time": "2019-07-03T10:21:03.167560Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave b: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en liste som heter `my_guess` med 7 tall. Denne listen inneholder tallene som du tipper.\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:21:45.639510Z",
+ "start_time": "2019-07-03T10:21:45.634558Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave c: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som tar inn `n` som argument og som trekker ut `n` tall ut av listen `numbers` og legger de i en egen liste. \n",
+ "For å gjøre ting tilfeldig: `import random` og `random.randint(n,N)` gir tilfeldige tall fra og med n til og med N.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ ">>>print(draw_numbers(numbers, 7))\n",
+ "[16, 33, 5, 20, 7, 4, 8]\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:25:33.636784Z",
+ "start_time": "2019-07-03T10:25:33.631639Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "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": [
+ "Hint: Bruk funksjonene `pop()` og `append()` for å fjerne og legge til elementer i en liste. Husk at pop fjerner et element i en indeks i lista, den fjerner ikke tallet. Så numbers.pop(rand_num) fjerner elementet på indeks rand_num - altså hvis rand_num er 13 fjernes tallet på indeks 13, ikke tallet 13!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave d: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag funksjonen `comp_list` som sammenligner to lister med tall. Antall like tall i listene skal returneres.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ ">>>print(comp_list(draw_n_umbers(numbers,7),my_guess))\n",
+ "1\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:28:03.696473Z",
+ "start_time": "2019-07-03T10:28:03.691094Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave e: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Lag en funksjon som tar inn antall like tall og like tilleggstall, og returnerer premien du har vunnet.\n",
+ "\n",
+ "Eksempel på kjøring:\n",
+ "\n",
+ "```python\n",
+ ">>>print(winnings(7,1))\n",
+ "2749455\n",
+ ">>>print(winnings(5,2))\n",
+ "95\n",
+ ">>>print(winnings(3,1))\n",
+ "0\n",
+ "```\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:30:20.037475Z",
+ "start_time": "2019-07-03T10:30:20.032125Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave f: frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Funksjonene skal settes sammen i main() slik at dette blir en fullverdig lottosimulator (for en lottorekke). Tallene du skal trekke ut (både lottotallene og tilleggstallene) kan legges i samme liste. Funksjonen `comp_list` kan da sammenligne de første 7 tallene, og så de siste 3 tallene, for å finne ut hvor mange like tall du har. main() skal returnere hvor mye du har tjent eller mest sannsynlig tapt på denne lottorekken. Dersom en lottorekke kosten 5 kroner, vil -5 returneres dersom winnings() er 0. Hvis du er heldig og winnings() blir 95 skal 90 returneres fra main(). \n",
+ "\n",
+ "**Husk at du kan bruke alle funksjoner du har definert over!**\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:32:57.485045Z",
+ "start_time": "2019-07-03T10:32:57.477602Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "## Oppgave g: frivillig\n",
+ "Frivillig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "deletable": false,
+ "editable": false,
+ "run_control": {
+ "frozen": true
+ }
+ },
+ "source": [
+ "Finn ut hvor mye man har vunnet etter å ha tippet en million ganger. Anta at premiepotten er det samme hver uke, og at en lottorekke koster 5 kroner.\n",
+ "\n",
+ "***Skriv koden din i boksen under.***"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2019-07-03T10:33:24.728040Z",
+ "start_time": "2019-07-03T10:33:24.722740Z"
+ }
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.10.6 64-bit",
+ "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.6"
+ },
+ "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/lectures/chap5/notes/codes/databaser.ipynb b/lectures/chap5/notes/codes/databaser.ipynb
index c4885d37a8c3d59dd72661117f4950d4267d31a8..36f5b4cf3569244811651761ae9d8028b8378d7c 100644
--- a/lectures/chap5/notes/codes/databaser.ipynb
+++ b/lectures/chap5/notes/codes/databaser.ipynb
@@ -26,225 +26,157 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
- "# Viser hvordan vi kobler oss mot MySQL og leser/oppdaterer data.\n",
- "# Må installere PyMySQL først: pip install pymysql\n",
- "import pymysql"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "For å logge oss inn på databasen, må vi ha en konto på database-serveren.\n",
- "\n",
- "Følgende informasjon må vi ha:\n",
- "\n",
- "- host: navn på database-server\n",
- "- user: brukernavn for å koble oss til serveren\n",
- "- password: passord for å koble oss til serveren\n",
- "- database: database seed (en database server kan inneholde mange database instanser)\n",
- "\n",
- "Dersom vi ikke ønsker å \"hardkode\" passord (skrive det i programmet i klar tekst eller i en fil), kan vi bruke modulen **getPass** for å taste inn passordet når programmet starter.\n"
+ "# Viser hvordan vi kobler oss mot SQLite og leser/oppdaterer data.\n",
+ "# Importerer modulen sqlite3 (trenger ikke installasjon)\n",
+ "import sqlite3 as sql"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
- "# importer funksjonen getpass fra modulen getpass.\n",
- "# Vi bruker getpass for å lese passord fra bruker (slik at det ikke vises i klartekst)\n",
- "from getpass import getpass"
+ "# Oppretter en tilkobling til databasen\n",
+ "# Hvis databasen ikke eksisterer, opprettes den\n",
+ "# Hvis databasen eksisterer, kobler vi oss til den\n",
+ "connection = sql.connect('database_name.db')"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
- "# Database connection object\n",
- "global db_connection\n",
- "db_connection = None\n",
- "\n",
- "my_host = \"mysql.stud.iie.ntnu.no\"\n",
- "my_user = \"rouhani\" # Skriv inn brukernavnet ditt her\n",
- "my_password = getpass()\n",
- "my_database = \"rouhani\"\n",
- "\n",
- "def get_db_connection():\n",
- " if 'db_connection' in globals():\n",
- " db_connection = pymysql.connect(host = my_host, user = my_user, password = my_password, database = my_database)\n",
- " return db_connection"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Koble opp mot databasen og les fra en tabell"
+ "# Oppretter en cursor som lar oss utføre SQL-kommandoer\n",
+ "# Cursor er en peker som lar oss utføre SQL-kommandoer\n",
+ "# En peker er en variabel som inneholder en adresse til et objekt\n",
+ "cursor = connection.cursor()"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "\n",
- "\n",
- "with get_db_connection() as my_db:\n",
- " my_cursor = my_db.cursor()\n",
- "\n",
- " my_sql = \"SELECT * FROM objects\"\n",
- " my_cursor.execute(my_sql)\n",
- "\n",
- " for row in my_cursor:\n",
- " print(row)\n",
- "\n"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
+ "execution_count": 19,
"metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<sqlite3.Cursor at 0x25729d10fc0>"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "### Koble opp mot databasen og oppdater rader i en tabell\n"
+ "# Oppretter en tabell\n",
+ "# Hvis tabellen ikke eksisterer, opprettes den\n",
+ "# Hvis tabellen eksisterer, opprettes den ikke på nytt\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "table_name = 'users'\n",
+ "\n",
+ "create_table = f'''\n",
+ " CREATE TABLE IF NOT EXISTS {table_name} (\n",
+ " id INTEGER PRIMARY KEY,\n",
+ " name TEXT\n",
+ " )\n",
+ "'''\n",
+ "\n",
+ "cursor.execute(create_table)"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 29,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<sqlite3.Cursor at 0x25729d10fc0>"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "#Sjekk om regnr existerer i databasen\n",
- "def reg_no_exist(reg_no,table_name):\n",
- " \"\"\"\n",
- " Sjekk om regnnr existerer allerede i basen\n",
- " :param regnr: type string\n",
- " :return: boolean\n",
- " \"\"\"\n",
- " with get_db_connection() as db:\n",
- "\n",
- " cursor = db.cursor()\n",
- " sql = f\"SELECT count(reg_no) as reg_no_count FROM {table_name} WHERE reg_no='{reg_no}'\"\n",
- " cursor.execute(sql)\n",
- "\n",
- " reg_no_count = 0\n",
- "\n",
- " for row in cursor:\n",
- " reg_no_count= row[0]\n",
- "\n",
- " if reg_no_count==0:\n",
- " return False\n",
- " else:\n",
- " return True\n",
- "\n",
- "#Lagrer gjenstand i basen\n",
- "def save_object_db(giver_val,\n",
- " innlemmet_dato_val,\n",
- " kategori_id,\n",
- " kommentar_val,\n",
- " mottatt_av_val,\n",
- " navn_val,\n",
- " plassering_val,\n",
- " registrert_av_val,\n",
- " registrerings_dato_val,\n",
- " reg_no):\n",
- " \"\"\"\n",
- " Lagre gjenstand info i databasen.\n",
- " Dersom den finnes allerede, blir gjenstand oppdatert\n",
- " Dersom den ikke finnes, blir den opprettet.\n",
- " :param giver_val: string\n",
- " :param innlemmet_dato_val: string\n",
- " :param kategori_id: int\n",
- " :param kommentar_val: string\n",
- " :param mottatt_av_val: string\n",
- " :param navn_val: string\n",
- " :param plassering_val: string\n",
- " :param registrert_av_val: string\n",
- " :param registrerings_dato_val: string\n",
- " :param regnr: string\n",
- " :return:\n",
- " \"\"\"\n",
- "\n",
- " #****************************************\n",
- " # Oppgave 4.1\n",
- " # Fullfør innholdet i denne funksjonen!\n",
- " #****************************************\n",
- "\n",
- " with get_db_connection() as my_db:\n",
- "\n",
- " my_db.autocommit(True)\n",
- " cursor = my_db.cursor()\n",
- " \n",
- " if reg_no_exist(reg_no,'objects'):\n",
- " sql = f\"UPDATE objects SET giver='{giver_val}',in_date='{innlemmet_dato_val}',category_id='{kategori_id}',comment='{kommentar_val}',received_by='{mottatt_av_val}',name='{navn_val}',placement='{plassering_val}',reg_by='{registrert_av_val}',reg_date='{registrerings_dato_val}' WHERE reg_no='{reg_no}'\"\n",
- " cursor.execute(sql)\n",
- " else:\n",
- " sql = f\"INSERT INTO objects (giver,in_date,category_id,comment,received_by,name,placement,reg_by,reg_date,reg_no) VALUES('{giver_val}','{innlemmet_dato_val}','{kategori_id}','{kommentar_val}','{mottatt_av_val}','{navn_val}','{plassering_val}','{registrert_av_val}','{registrerings_dato_val}','{reg_no}')\"\n",
- " cursor.execute(sql)\n",
- "\n",
- "#Oppdater eksisterende rad\n",
- "save_object_db('Olsen Giver','12.04.2023', 1, 'Tester', 'Kristin', 'Stol', 'PL.A1.B2','Hanne','12.04.2023','TBM.0832')\n",
- "\n",
- "\n",
- "#legg til ny rad\n",
- "save_object_db('Olsen Giver','12.04.2023', 1, 'Tester', 'Kristin', 'Stol', 'PL.A1.B2','Hanne','12.04.2023','TBM.0832-N')\n"
+ "# Definer data som skal settes inn i tabellen\n",
+ "# Liste med tupler\n",
+ "user_data = [\n",
+ " (1, 'John'),\n",
+ " (2, 'Jane'),\n",
+ " (3, 'Alice')\n",
+ "]\n",
+ "\n",
+ "# Insert the data into the table\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "# Vi kan bruke executemany for å sette inn flere rader samtidig\n",
+ "cursor.executemany(f'''\n",
+ " INSERT OR REPLACE INTO {table_name} (id, name)\n",
+ " VALUES (?, ?)\n",
+ "''', user_data)"
]
},
{
- "attachments": {},
- "cell_type": "markdown",
+ "cell_type": "code",
+ "execution_count": 30,
"metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(1, 'John 2')\n",
+ "(2, 'Jane')\n",
+ "(3, 'Alice')\n"
+ ]
+ }
+ ],
"source": [
- "### Koble opp mot databasen og fjern rader fra en tabell"
+ "# Henter ut data fra tabellen\n",
+ "# Vi kan bruke f-strings for å sette inn variabler i SQL-kommandoer\n",
+ "# Vi kan bruke * for å hente ut alle kolonner\n",
+ "# Vi kan bruke WHERE for å filtrere data\n",
+ "# Vi kan bruke ORDER BY for å sortere data\n",
+ "# Vi kan bruke LIMIT for å begrense antall rader\n",
+ "# Vi kan bruke OFFSET for å hoppe over rader\n",
+ "# Vi kan bruke LIKE for å filtrere data med et mønster (wildcard)\n",
+ "# Vi kan bruke IN for å filtrere data med flere verdier\n",
+ "# Vi kan bruke IS NULL for å filtrere data som er NULL\n",
+ "# Vi kan bruke IS NOT NULL for å filtrere data som ikke er NULL\n",
+ "# Vi kan bruke DISTINCT for å filtrere ut duplikater\n",
+ "# Vi kan bruke COUNT for å telle antall rader\n",
+ "cursor.execute(f'SELECT * FROM {table_name}')\n",
+ "\n",
+ "# Fetch all rows as a list of tuples\n",
+ "rows = cursor.fetchall()\n",
+ "\n",
+ "# Print the rows\n",
+ "# Vi kan bruke for-løkke for å iterere over resultatet\n",
+ "for row in rows:\n",
+ " print(row)\n"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
- "#Slett gjenstand\n",
- "def delete_object(reg_no):\n",
- " \"\"\"\n",
- " :param regnr: Registreriongsnr på gjenstand som skal slettes\n",
- " :return: ingen returverdi.\n",
- "\n",
- " Funksjonen skal finne gjenstanden og slette denne.\n",
- " 1. Slett fra properties-tabellen for det gitte registreringsnummeret\n",
- " 2. Slett fra provenances-tabellen for det gitte registreringsnummeret\n",
- " 3. Slett fra objects-tabellen for det gitte registreringsnummeret\n",
- "\n",
- " Dersom sletting går bra, skriv en melding til skjermen.\n",
- " \"\"\"\n",
- "\n",
- " #******************************************\n",
- " # Oppgave 4.3\n",
- " # Fullfør denne funksjonen\n",
- " #******************************************\n",
- "\n",
- "\n",
- " with get_db_connection() as db:\n",
- " db.autocommit(True)\n",
- "\n",
- " cursor = db.cursor()\n",
- " cursor.execute(f\"DELETE from properties where reg_no='{reg_no}'\")\n",
- " cursor.execute(f\"DELETE from provenances where reg_no='{reg_no}'\")\n",
- " cursor.execute(f\"DELETE from objects where reg_no='{reg_no}'\")\n",
- "\n",
+ "# Oppdaterer data i tabellen\n",
+ "connection.commit()\n",
"\n",
- "delete_object('TBM.0832-N')"
+ "# Lukker tilkoblingen til databasen\n",
+ "connection.close()"
]
}
],
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/adams/.DS_Store" "b/\303\270vinger/\303\270ving_1/innlevering/adams/.DS_Store"
deleted file mode 100644
index 2050b4a70160277369ed3fed8e4f8cf1cb364056..0000000000000000000000000000000000000000
Binary files "a/\303\270vinger/\303\270ving_1/innlevering/adams/.DS_Store" and /dev/null differ
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/adams/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/adams/intro_til_jupyter.ipynb"
deleted file mode 100644
index 1273df32927fc4c1ac223d2f8e213d8be6806abd..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/adams/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,376 +0,0 @@
-{
- "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\")\n"
- ]
- },
- {
- "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 program i jupyter\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Vince\n",
- "Da er du 30 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er mitt første program i jupyter\") #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": 17,
- "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": 16,
- "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": 15,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Vince\n"
- ]
- }
- ],
- "source": [
- "navn = input(\"Hva heter du?\")\n",
- "print(\"Hei,\", navn)\n"
- ]
- },
- {
- "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*"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**Ditt svar:** <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",
- "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_1/innlevering/adams/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/adams/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/adams/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/adams/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/adams/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 8075f9095daa1ca70c3c79dc67a8f179ac67d915..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/adams/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1251 +0,0 @@
-{
- "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": 79,
- "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": 80,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-10\n",
- "-10\n",
- "-100\n",
- "0\n",
- "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 * 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": 81,
- "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": 82,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 83,
- "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": 84,
- "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": 85,
- "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": 86,
- "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": 87,
- "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": 88,
- "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": 89,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her har du en liste med tall: [5, 6, 7, 8]\n"
- ]
- }
- ],
- "source": [
- "liste_med_tall = [5, 6, 7, 8]\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": 90,
- "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": 16,
- "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": 44,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[44], line 12\u001b[0m\n\u001b[1;32m 8\u001b[0m alder_mor \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39m37\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 10\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[0;32m---> 12\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 1,
- "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": 1,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def legg_til_landskode (telefonnummer,landskode):\n",
- " return \"+\" + str(landskode) + \" \" + str(telefonnummer)\n",
- "\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": 28,
- "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": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2.45'\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(a)\n",
- "b = int(b)\n",
- "c = int(c)\n",
- "d = int(float(d))\n",
- "e = int(float(e))\n"
- ]
- },
- {
- "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": 62,
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'liste' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "\u001b[1;32mc:\\Users\\rouhani\\gitlab\\lbas2002-1\\øvinger\\øving_1\\innlevering\\adams\\tall_og_typekonvertering.ipynb Cell 60\u001b[0m line \u001b[0;36m6\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y113sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmult_list_with_x\u001b[39m(l, x):\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y113sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y113sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m arr1 \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(liste)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y113sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m result \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mmultiply(arr1,skalar)\n",
- "\u001b[1;31mNameError\u001b[0m: name 'liste' is not defined"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(result)\n",
- "arr1 = np.array(liste)\n",
- "result = np.multiply(arr1,skalar)\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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'result' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "\u001b[1;32mc:\\Users\\rouhani\\gitlab\\lbas2002-1\\øvinger\\øving_1\\innlevering\\adams\\tall_og_typekonvertering.ipynb Cell 62\u001b[0m line \u001b[0;36m4\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y115sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m liste \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m, \u001b[39m1.5\u001b[39m, \u001b[39m2\u001b[39m, \u001b[39m2.5\u001b[39m, \u001b[39m3\u001b[39m]\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y115sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m skalar \u001b[39m=\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y115sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m mult_list_with_x(liste, skalar)\n",
- "\u001b[1;32mc:\\Users\\rouhani\\gitlab\\lbas2002-1\\øvinger\\øving_1\\innlevering\\adams\\tall_og_typekonvertering.ipynb Cell 62\u001b[0m line \u001b[0;36m5\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y115sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmult_list_with_x\u001b[39m(l, x):\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/rouhani/gitlab/lbas2002-1/%C3%B8vinger/%C3%B8ving_1/innlevering/adams/tall_og_typekonvertering.ipynb#Y115sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n",
- "\u001b[1;31mNameError\u001b[0m: name 'result' is not defined"
- ]
- }
- ],
- "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": 6,
- "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": 45,
- "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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " return round(tall, desimaler)\n",
- "\n",
- "\n",
- "\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": 8,
- "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))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "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
- },
- "vscode": {
- "interpreter": {
- "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/adams/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/adams/variabler.ipynb"
deleted file mode 100644
index c42a1aed86fdbed755d57247abf81e2ab73a877f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/adams/variabler.ipynb"
+++ /dev/null
@@ -1,602 +0,0 @@
-{
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1 + 1 = 2\n",
- "10 = 10\n"
- ]
- }
- ],
- "source": [
- "print(f'1 + 1 = {1 + 1}')\n",
- "print(f'{5 * 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",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = 'Ada'\n",
- "fag = 'LBAS2002'\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}')\n"
- ]
- },
- {
- "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": 12,
- "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": 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 numpy as np\n",
- "import math\n",
- " \n",
- "r = 5.4\n",
- "h = 7.9\n",
- "omkrets = math.tau * r\n",
- "areal = np.pi * r**2\n",
- "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n",
- "print(\"Omkrets av sirkelen:\", omkrets) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", areal)\n",
- "print(\"Areal av sylinderen:\", omkrets * h + 2 * math.pi * r ** 2)\n",
- "\n",
- "\n"
- ]
- },
- {
- "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": 23,
- "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",
- "antall = 1 # variabelen må stå på venstre side\n",
- "#antall + 1 = antall # og v.s. kan KUN inneholde et variabelnavn, ikke et større uttrykk\n",
- "kamp10 = \"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",
- "alkoholPros = 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": [
- "navn = \"Per\"\n",
- "ideal_alder = 42\n",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\n",
- "print(f'{navn} er {differanse} år unna idealalderen')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "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
- },
- "vscode": {
- "interpreter": {
- "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/anastasia/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anastasia/intro_til_jupyter.ipynb"
deleted file mode 100644
index a4d550c7d494eaa96beb26b5b45c5bbfa4c74900..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anastasia/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 4,
- "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": 6,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Dette er et mitt første jupyter\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Erik\n",
- "Da er du 25 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er et mitt første jupyter\") #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": 2,
- "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": 3,
- "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, \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": [
- "**Ditt svar:** <dobbelklikk 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_1/innlevering/anastasia/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anastasia/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 75e4e85e2bc89c44f6eae1b4231f631f525e1f1d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anastasia/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1101 +0,0 @@
-{
- "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": 3,
- "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": 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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'd' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[7], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(d \u001b[39m+\u001b[39m e) \u001b[39m# Samme som 1.2 + (-4.2)\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(c \u001b[39m-\u001b[39m e) \u001b[39m# Samme som 1.2 - (-4.2)\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(f \u001b[39m*\u001b[39m e) \u001b[39m# Samme som 0.0 * (4.2)\u001b[39;00m\n",
- "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
- ]
- }
- ],
- "source": [
- "print(d + 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 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": 11,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+47 12345678\n",
- "+46 87654321\n"
- ]
- }
- ],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " p_string = \"+\"\n",
- " t_string = str(telefonnummer)\n",
- " l_string = str(landskode)\n",
- " m_strin = \" \"\n",
- " return (str(p_string + t_string + m_strin + l_string))\n",
- "\n",
- "print(legg_til_landskode(47, 12345678))\n",
- "\n",
- "print(legg_til_landskode(46, 87654321))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": []
- },
- {
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(\"1\")\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(float(\"1.5\"))\n",
- "e = int(float(\"2.35\"))"
- ]
- },
- {
- "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": 5,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l))\n",
- "print(mult_list_with_x([1, 1.5, 2, 2.5, 3],2))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "def rund_av(base_number, decimals):\n",
- " multiply = 10**decimals\n",
- " return int(base_number * multiply) / multiply\n",
- "\n",
- "print(rund_av(1.23456, 2))\n",
- "print(rund_av(1234.5432, -3))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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_1/innlevering/anastasia/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anastasia/variabler.ipynb"
deleted file mode 100644
index 8b069dd3732ac448e8fe684c217e3627ad406f55..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anastasia/variabler.ipynb"
+++ /dev/null
@@ -1,566 +0,0 @@
-{
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "ITGK = \"LBAS2002\"\n",
- "Navn = \"Ada\"\n",
- "print('Hei, Ada')\n",
- "print(f'{ITGK} - interessant!')\n",
- "print(f'Ha en fin dag, {Navn}')\n",
- "print('- og lykke til med LBAS2002')"
- ]
- },
- {
- "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": 1,
- "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 numpy as np\n",
- "import math\n",
- "\n",
- "radius = 5.4\n",
- "høyde = 7.9\n",
- "omkrets = math.tau * radius\n",
- "areal_sirkel = np.pi * radius*2\n",
- "areal_sylinder = (omkrets*høyde) + (2 * areal_sirkel)\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "idealalder = 42\n",
- "kundensAlder = 37\n",
- "differanse = idealalder - kundensAlder\n",
- "print(f'{navn} 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.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_1/innlevering/anna/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anna/intro_til_jupyter.ipynb"
deleted file mode 100644
index 72a7fb59184d04e32a85d05c5a18d4fdfc0eed58..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anna/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 4,
- "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 Anna\n",
- "Da er du 26 å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": 1,
- "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": 2,
- "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, Anna\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": [
- "**Ditt svar:** <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_1/innlevering/anna/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/anna/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anna/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/anna/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anna/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index bc519f92858aa28f43bef55aca19eeb0179e70d7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anna/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1232 +0,0 @@
-{
- "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": 224,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = -10\n",
- "b = 1\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": 225,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-9\n",
- "-9\n",
- "-100\n",
- "10\n",
- "-10.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 / 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": 226,
- "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": 227,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 228,
- "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": 229,
- "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": 230,
- "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": 231,
- "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": 232,
- "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": 233,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 234,
- "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": 235,
- "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": 236,
- "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": 237,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[237], line 9\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[1;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": null,
- "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": 26,
- "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": 59,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "\n",
- "\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return '+' + str(landskode) + ' ' + str(telefonnummer)\n",
- "\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": 43,
- "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",
- "\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": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": 63,
- "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\n",
- "\n"
- ]
- },
- {
- "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": 67,
- "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": 113,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "\n",
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(en, x):\n",
- " return(np.array(liste) * skalar)\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": 114,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 114,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "liste = [1, 1.5, 2, 2.5, 3]\n",
- "skalar = 2\n",
- "\n",
- "list(mult_list_with_x(liste, skalar))\n"
- ]
- },
- {
- "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": 16,
- "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": 17,
- "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": 108,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "\n",
- "\n",
- "def rund_av(tall, desimaler):\n",
- " return (round(tall, desimaler))\n",
- "\n",
- "\n",
- "\n",
- "\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": 109,
- "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_1/innlevering/anna/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/anna/variabler.ipynb"
deleted file mode 100644
index 1f0db17c5038d5001fa264c00ede406733ef7e35..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/anna/variabler.ipynb"
+++ /dev/null
@@ -1,603 +0,0 @@
-{
- "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": 3,
- "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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = 'Ada' \n",
- "favorittfag = 'LBAS2002'\n",
- "\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": 16,
- "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": 45,
- "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.9\n",
- "Areal av sirkelen: 91.6\n",
- "Areal av sylinderen: 451.3\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "import math\n",
- " \n",
- "\n",
- "\n",
- "r = 5.4\n",
- "h = 7.9\n",
- "os = math.tau * 5.4\n",
- "asi = np.pi * 5.4**2\n",
- "asy = math.tau * 5.4 * 7.9 + 2 * math.pi *5.4 ** 2\n",
- "\n",
- "\n",
- "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n",
- "print(\"Omkrets av sirkelen:\", round(os,1)) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", round(asi,1))\n",
- "print(\"Areal av sylinderen:\", round(asy,1))\n"
- ]
- },
- {
- "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": 47,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (1274524858.py, line 12)",
- "output_type": "error",
- "traceback": [
- "\u001b[1;36m Cell \u001b[1;32mIn[47], line 12\u001b[1;36m\u001b[0m\n\u001b[1;33m 10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "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": 50,
- "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",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\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.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_1/innlevering/audun/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/audun/intro_til_jupyter.ipynb"
deleted file mode 100644
index aa335db2548cd951176e36febb30f4b52e0a811f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/audun/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,343 +0,0 @@
-{
- "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": null,
- "metadata": {},
- "outputs": [],
- "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": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Dette er mitt første Jupter-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": 1,
- "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": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Wow, Jupyter er kult!\n"
- ]
- }
- ],
- "source": [
- "print(message)\n"
- ]
- },
- {
- "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": 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:** Programmering er gøy.\n"
- ]
- },
- {
- "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": 4
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/audun/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/audun/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index fe5c1ca7fd52b89132bbfb547bea1a69b90d8159..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/audun/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1013 +0,0 @@
-{
- "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"
- ]
- },
- {
- "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(d + e) # Samme som 1.2 + (-4.2) #endret fra c til d\n",
- "print(d - e) # Samme som 1.2 - (-4.2) #endret fra c til d\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": "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 = [3, 4, 1, 5]\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": null,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-01T11:24:13.550825Z",
- "start_time": "2019-07-01T11:24:13.542723Z"
- },
- "hidden": true
- },
- "outputs": [],
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "telefonnummer1 = 12345678\n",
- "landskode1 = 47\n",
- "\n",
- "telefonnummer2 = 87654321\n",
- "landskode2 = 46\n",
- "\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return print(f'+{landskode} {telefonnummer}')\n",
- "legg_til_landskode(telefonnummer1, landskode1)\n",
- "legg_til_landskode(telefonnummer2, landskode2)\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": 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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = 1.5\n",
- "e = 2.45\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(a)\n",
- "b = int(b)\n",
- "c = int(c)\n",
- "d = int(d)\n",
- "e = int(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": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l))\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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 4,
- "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": null,
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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": 4
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/audun/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/audun/variabler.ipynb"
deleted file mode 100644
index b3e8e3f9e6ca805b0ed149fdf44a329e74c6805f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/audun/variabler.ipynb"
+++ /dev/null
@@ -1,574 +0,0 @@
-{
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Navn?, Ada\n",
- "Hei, Ada\n",
- "Favorittfag?, LBAS2002\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = \"Ada\"\n",
- "fav_fag = \"LBAS2002\"\n",
- "print(f'Navn?, {navn}')\n",
- "print(f'Hei, {navn}')\n",
- "print(f'Favorittfag?, {fav_fag}')\n",
- "print(f'{fav_fag} - interessant!') \n",
- "print(f'Ha en fin dag, {navn}')\n",
- "print(f'- og lykke til med {fav_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": 3,
- "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": 1,
- "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 numpy as np\n",
- "import math\n",
- "\n",
- "r = 5.4\n",
- "h = 7.9\n",
- "O = 33.929200658769766\n",
- "A_sirkel = 91.60884177867838\n",
- " \n",
- "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * r) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * r**2)\n",
- "print(\"Areal av sylinderen:\", O * h + 2 * A_sirkel)"
- ]
- },
- {
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "_4navn = \"Per\"\n",
- "ideal_alder = 42\n",
- "kundens_Alder = 37 \n",
- "differanse = ideal_alder - kundens_Alder\n",
- "print(f'{_4navn} 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": 4
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/benjamin/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/benjamin/intro_til_jupyter.ipynb"
deleted file mode 100644
index d8b33952ca138b8f77e97bf3bc8bac1209c851fb..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/benjamin/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 3,
- "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 Benjamin\n",
- "Da er du 26 å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": 6,
- "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": 7,
- "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": 9,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, \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": [
- "**Mitt svar:** 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.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_1/innlevering/benjamin/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/benjamin/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 2e153105d8a7c8774111095b922f31ae56a474b0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/benjamin/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1205 +0,0 @@
-{
- "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": 2,
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'a' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(a \u001b[39m+\u001b[39m b) \u001b[39m# Samme som å si -10 + 0\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(b \u001b[39m-\u001b[39m c) \u001b[39m# Samme som 0 - 10\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(a \u001b[39m*\u001b[39m c) \u001b[39m# Samme som -10 * 10\u001b[39;00m\n",
- "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
- ]
- }
- ],
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "c = 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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-3.0\n",
- "5.4\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 6,
- "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": 7,
- "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": 8,
- "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": 9,
- "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": 10,
- "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": 30,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[30], line 10\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 8\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[1;32m---> 10\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "source": [
- "alder = '13'\n",
- "alder_mor = '37'\n",
- "sum_alder = alder + alder_mor\n",
- "\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": 31,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 23,
- "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": 23,
- "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": 32,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+47 12345678\n",
- "+46 87654321\n"
- ]
- }
- ],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " telefonnummer_str = str(telefonnummer)\n",
- " landskode_str = str(landskode)\n",
- " return \"+\" + landskode_str + \" \" + telefonnummer_str\n",
- "\n",
- "telefonnummer1 = 12345678\n",
- "landskode1 = 47\n",
- "\n",
- "telefonnummer2 = 87654321\n",
- "landskode2 = 46\n",
- "\n",
- "resultat1 = legg_til_landskode(telefonnummer1, landskode1)\n",
- "resultat2 = legg_til_landskode(telefonnummer2, landskode2)\n",
- "\n",
- "print(resultat1)\n",
- "print(resultat2)\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": 49,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = int('1')\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(float('1.5'))\n",
- "e = int(float('2.45'))\n"
- ]
- },
- {
- "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": 50,
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]\n"
- ]
- }
- ],
- "source": [
- "import numpy as np #sliter veldig med å få lasta ned numpy, pip install numpy funker ikke for meg?\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l))\n",
- "print(mult_list_with_x([1, 1.5, 2, 2.5, 3],2))"
- ]
- },
- {
- "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": 61,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "TypeError",
- "evalue": "'int' object is not iterable",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[61], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m liste \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m, \u001b[39m1.5\u001b[39m, \u001b[39m2\u001b[39m, \u001b[39m2.5\u001b[39m, \u001b[39m3\u001b[39m]\n\u001b[0;32m 2\u001b[0m skalar \u001b[39m=\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m----> 4\u001b[0m mult_list_with_x(liste, skalar)\n",
- "Cell \u001b[1;32mIn[59], line 2\u001b[0m, in \u001b[0;36mmult_list_with_x\u001b[1;34m(l, x)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmult_list_with_x\u001b[39m(l, x):\n\u001b[1;32m----> 2\u001b[0m \u001b[39mreturn\u001b[39;00m [element \u001b[39m*\u001b[39m x \u001b[39mfor\u001b[39;00m element \u001b[39min\u001b[39;00m \u001b[39m1\u001b[39m]\n",
- "\u001b[1;31mTypeError\u001b[0m: 'int' object is not iterable"
- ]
- }
- ],
- "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": 44,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "def rund_av(tall, desimaler):\n",
- " multiplier = 10**desimaler\n",
- " return round(tall * multiplier) / multiplier\n",
- "\n",
- "print(rund_av(1.23456, 2))\n",
- "print(rund_av(1234.5432, -3))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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.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_1/innlevering/benjamin/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/benjamin/variabler.ipynb"
deleted file mode 100644
index 076003b0019b93fd780465cfd42e1c60411ffc28..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/benjamin/variabler.ipynb"
+++ /dev/null
@@ -1,584 +0,0 @@
-{
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1 + 1 = 2\n",
- "2 * 5 = 10\n"
- ]
- }
- ],
- "source": [
- "print(f'1 + 1 = {1 + 1}')\n",
- "print(f'2 * 5 = {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": 16,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = 'Ada'\n",
- "favorittfag = 'LBAS2002'\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": 17,
- "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": 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 numpy as np\n",
- "import math\n",
- "\n",
- "radius = 5.4\n",
- "hoyde = 7.9\n",
- "\n",
- "omkrets_sirkel = math.tau * radius\n",
- "areal_sirkel = np.pi * radius**2\n",
- "areal_sylinder = omkrets_sirkel * hoyde + 2\n",
- "np.pi * radius**2\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 19,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "idealalder = 42\n",
- "kundensAlder = 37\n",
- "differanse = 5\n",
- "differanse - idealalder - kundensAlder\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.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_1/innlevering/sten/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/sten/intro_til_jupyter.ipynb"
deleted file mode 100644
index 4cc3c600d99cb3386f2716205d4b8115b466c50f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/sten/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,335 +0,0 @@
-{
- "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": null,
- "metadata": {},
- "outputs": [],
- "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": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(\"Dette er et program i jupyter\") #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": "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.9.10"
- },
- "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_1/innlevering/sten/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/sten/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/sten/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/sten/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/sten/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 7cbf469e5ee3a890f078589da30b0fc65a81ca52..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/sten/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1073 +0,0 @@
-{
- "cells": [
- {
- "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": 1,
- "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": 1,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+47 12345678\n"
- ]
- }
- ],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return \"+\" + str(landskode) + \" \" + str(telefonnummer)\n",
- "\n",
- "print (legg_til_landskode(12345678, 47))"
- ]
- },
- {
- "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": 3,
- "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": 20,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(1)\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(1.5)\n",
- "e = int(2.45)"
- ]
- },
- {
- "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": 21,
- "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": 43,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np\n",
- "def mult_list_with_x(l, x):\n",
- " l = np.multiply(l, x) \n",
- " print (l)"
- ]
- },
- {
- "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": 47,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2. 3. 4. 5. 6.]\n"
- ]
- }
- ],
- "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,
- "tags": []
- },
- "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": 35,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "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": 36,
- "metadata": {
- "hidden": true,
- "tags": []
- },
- "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))"
- ]
- },
- {
- "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.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_1/innlevering/sten/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/sten/variabler.ipynb"
deleted file mode 100644
index c3315720e50f7c29e266a87211dabc8e2f3169b4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/sten/variabler.ipynb"
+++ /dev/null
@@ -1,572 +0,0 @@
-{
- "cells": [
- {
- "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": 3,
- "metadata": {
- "hidden": true,
- "tags": []
- },
- "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"
- ]
- },
- {
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = 'Ada'\n",
- "favorittfag = 'LBAS2002'\n",
- "print('Hei, ' + navn)\n",
- "print(favorittfag + ' - interessant!')\n",
- "print('Ha en fin dag, ' + navn)\n",
- "print('- og lykke til med ' + favorittfag)"
- ]
- },
- {
- "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)"
- ]
- },
- {
- "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 "
- ]
- },
- {
- "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": 9,
- "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 numpy as np\n",
- "import math\n",
- "\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "radius = 5.4\n",
- "høyde = 7.9\n",
- "omkrets = (math.tau * 5.4)\n",
- "print(\"Omkrets av sirkelen:\", omkrets) #tau er det samme som 2 pi\n",
- "arealSirkel = (np.pi * radius**2)\n",
- "print(\"Areal av sirkelen:\", arealSirkel)\n",
- "arealSylinder = math.tau * radius * høyde + math.tau * radius ** 2\n",
- "print(\"Areal av sylinderen:\", arealSylinder)"
- ]
- },
- {
- "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": 10,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (2066608501.py, line 1)",
- "output_type": "error",
- "traceback": [
- "\u001b[0;36m Cell \u001b[0;32mIn[10], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 4navn = \"Per\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "ideal_alder = 42\n",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\n",
- "print(f'{navn} 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.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_1/innlevering/stud1/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud1/intro_til_jupyter.ipynb"
deleted file mode 100644
index a4d550c7d494eaa96beb26b5b45c5bbfa4c74900..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud1/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 4,
- "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": 6,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Dette er et mitt første jupyter\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Erik\n",
- "Da er du 25 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er et mitt første jupyter\") #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": 2,
- "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": 3,
- "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, \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": [
- "**Ditt svar:** <dobbelklikk 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_1/innlevering/stud1/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud1/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 75e4e85e2bc89c44f6eae1b4231f631f525e1f1d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud1/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1101 +0,0 @@
-{
- "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": 3,
- "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": 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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'd' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[7], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(d \u001b[39m+\u001b[39m e) \u001b[39m# Samme som 1.2 + (-4.2)\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(c \u001b[39m-\u001b[39m e) \u001b[39m# Samme som 1.2 - (-4.2)\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(f \u001b[39m*\u001b[39m e) \u001b[39m# Samme som 0.0 * (4.2)\u001b[39;00m\n",
- "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined"
- ]
- }
- ],
- "source": [
- "print(d + 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 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": 11,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+47 12345678\n",
- "+46 87654321\n"
- ]
- }
- ],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " p_string = \"+\"\n",
- " t_string = str(telefonnummer)\n",
- " l_string = str(landskode)\n",
- " m_strin = \" \"\n",
- " return (str(p_string + t_string + m_strin + l_string))\n",
- "\n",
- "print(legg_til_landskode(47, 12345678))\n",
- "\n",
- "print(legg_til_landskode(46, 87654321))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": []
- },
- {
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(\"1\")\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(float(\"1.5\"))\n",
- "e = int(float(\"2.35\"))"
- ]
- },
- {
- "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": 5,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l))\n",
- "print(mult_list_with_x([1, 1.5, 2, 2.5, 3],2))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "def rund_av(base_number, decimals):\n",
- " multiply = 10**decimals\n",
- " return int(base_number * multiply) / multiply\n",
- "\n",
- "print(rund_av(1.23456, 2))\n",
- "print(rund_av(1234.5432, -3))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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_1/innlevering/stud1/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud1/variabler.ipynb"
deleted file mode 100644
index 8b069dd3732ac448e8fe684c217e3627ad406f55..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud1/variabler.ipynb"
+++ /dev/null
@@ -1,566 +0,0 @@
-{
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "ITGK = \"LBAS2002\"\n",
- "Navn = \"Ada\"\n",
- "print('Hei, Ada')\n",
- "print(f'{ITGK} - interessant!')\n",
- "print(f'Ha en fin dag, {Navn}')\n",
- "print('- og lykke til med LBAS2002')"
- ]
- },
- {
- "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": 1,
- "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 numpy as np\n",
- "import math\n",
- "\n",
- "radius = 5.4\n",
- "høyde = 7.9\n",
- "omkrets = math.tau * radius\n",
- "areal_sirkel = np.pi * radius*2\n",
- "areal_sylinder = (omkrets*høyde) + (2 * areal_sirkel)\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "idealalder = 42\n",
- "kundensAlder = 37\n",
- "differanse = idealalder - kundensAlder\n",
- "print(f'{navn} 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.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_1/innlevering/stud10/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud10/intro_til_jupyter.ipynb"
deleted file mode 100644
index c02b1eadf14a5f5b0c2ca08256934375aa5bd117..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud10/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 20,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Dette er mitt første Jypyter-program\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Ada\n",
- "Da er du 25 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er mitt første Jypyter-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": 1,
- "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": 2,
- "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": 18,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\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": [
- "**Ditt svar:** 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_1/innlevering/stud10/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud10/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud10/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud10/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud10/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 3b3e14a4e7e775830027f8a97dd7efa1888cfe97..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud10/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1291 +0,0 @@
-{
- "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": 26,
- "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": 28,
- "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": 5,
- "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": 6,
- "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": 1,
- "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": 2,
- "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": 3,
- "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": 4,
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 86,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her har du en liste med tall: (1, 2, 3, 4, 5)\n"
- ]
- }
- ],
- "source": [
- "liste_med_tall = (1, 2, 3, 4, 5)\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": 7,
- "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": 8,
- "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": 9,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[9], line 9\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[1;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": 10,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 17,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-01T11:24:13.550825Z",
- "start_time": "2019-07-01T11:24:13.542723Z"
- },
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "25\n"
- ]
- }
- ],
- "source": [
- "def legg_sammen_to_tall(a, b):\n",
- " return str(a) + str(b)\n",
- "sum= int(a) + int(b)\n",
- "legg_sammen_to_tall(10, 15)\n",
- "print( sum)"
- ]
- },
- {
- "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": 27,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return \"+\" + str(landskode) + \" \" + str(telefonnummer)"
- ]
- },
- {
- "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": 28,
- "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": 57,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = int(1)\n",
- "b = int(1)\n",
- "c = int(0)\n",
- "d = int (1.5)\n",
- "e = int (2.45)\n",
- "\n",
- "\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": 58,
- "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": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Collecting matplotlib\n",
- " Obtaining dependency information for matplotlib from https://files.pythonhosted.org/packages/4d/9c/65830d4a56c47f5283eaa244dc1228c5da9c844a9f999ebcc2e69bf6cc65/matplotlib-3.7.2-cp311-cp311-win_amd64.whl.metadata\n",
- " Downloading matplotlib-3.7.2-cp311-cp311-win_amd64.whl.metadata (5.8 kB)\n",
- "Collecting contourpy>=1.0.1 (from matplotlib)\n",
- " Obtaining dependency information for contourpy>=1.0.1 from https://files.pythonhosted.org/packages/16/09/989b982322439faa4bafffcd669e6f942b38fee897c2664c987bcd091dec/contourpy-1.1.0-cp311-cp311-win_amd64.whl.metadata\n",
- " Downloading contourpy-1.1.0-cp311-cp311-win_amd64.whl.metadata (5.7 kB)\n",
- "Collecting cycler>=0.10 (from matplotlib)\n",
- " Downloading cycler-0.11.0-py3-none-any.whl (6.4 kB)\n",
- "Collecting fonttools>=4.22.0 (from matplotlib)\n",
- " Obtaining dependency information for fonttools>=4.22.0 from https://files.pythonhosted.org/packages/95/b6/9a5133deb5838c4dbe3ea27e8dba123622aa5112d43a079e9587636b4faf/fonttools-4.42.1-cp311-cp311-win_amd64.whl.metadata\n",
- " Downloading fonttools-4.42.1-cp311-cp311-win_amd64.whl.metadata (154 kB)\n",
- " ---------------------------------------- 0.0/154.1 kB ? eta -:--:--\n",
- " -- ------------------------------------- 10.2/154.1 kB ? eta -:--:--\n",
- " --------- --------------------------- 41.0/154.1 kB 991.0 kB/s eta 0:00:01\n",
- " -------------------------------------- 154.1/154.1 kB 1.8 MB/s eta 0:00:00\n",
- "Collecting kiwisolver>=1.0.1 (from matplotlib)\n",
- " Obtaining dependency information for kiwisolver>=1.0.1 from https://files.pythonhosted.org/packages/1e/37/d3c2d4ba2719059a0f12730947bbe1ad5ee8bff89e8c35319dcb2c9ddb4c/kiwisolver-1.4.5-cp311-cp311-win_amd64.whl.metadata\n",
- " Downloading kiwisolver-1.4.5-cp311-cp311-win_amd64.whl.metadata (6.5 kB)\n",
- "Requirement already satisfied: numpy>=1.20 in c:\\users\\eilee\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (1.25.2)\n",
- "Requirement already satisfied: packaging>=20.0 in c:\\users\\eilee\\appdata\\roaming\\python\\python311\\site-packages (from matplotlib) (23.1)\n",
- "Collecting pillow>=6.2.0 (from matplotlib)\n",
- " Obtaining dependency information for pillow>=6.2.0 from https://files.pythonhosted.org/packages/66/d4/054e491f0880bf0119ee79cdc03264e01d5732e06c454da8c69b83a7c8f2/Pillow-10.0.0-cp311-cp311-win_amd64.whl.metadata\n",
- " Downloading Pillow-10.0.0-cp311-cp311-win_amd64.whl.metadata (9.6 kB)\n",
- "Collecting pyparsing<3.1,>=2.3.1 (from matplotlib)\n",
- " Downloading pyparsing-3.0.9-py3-none-any.whl (98 kB)\n",
- " ---------------------------------------- 0.0/98.3 kB ? eta -:--:--\n",
- " ---------------------------------------- 98.3/98.3 kB 5.5 MB/s eta 0:00:00\n",
- "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\eilee\\appdata\\roaming\\python\\python311\\site-packages (from matplotlib) (2.8.2)\n",
- "Requirement already satisfied: six>=1.5 in c:\\users\\eilee\\appdata\\roaming\\python\\python311\\site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
- "Downloading matplotlib-3.7.2-cp311-cp311-win_amd64.whl (7.5 MB)\n",
- " ---------------------------------------- 0.0/7.5 MB ? eta -:--:--\n",
- " -- ------------------------------------- 0.5/7.5 MB 14.5 MB/s eta 0:00:01\n",
- " ----- ---------------------------------- 1.0/7.5 MB 13.3 MB/s eta 0:00:01\n",
- " -------- ------------------------------- 1.7/7.5 MB 13.4 MB/s eta 0:00:01\n",
- " ------------ --------------------------- 2.4/7.5 MB 15.3 MB/s eta 0:00:01\n",
- " -------------- ------------------------- 2.8/7.5 MB 13.7 MB/s eta 0:00:01\n",
- " ------------------- -------------------- 3.7/7.5 MB 15.0 MB/s eta 0:00:01\n",
- " ----------------------- ---------------- 4.5/7.5 MB 16.0 MB/s eta 0:00:01\n",
- " ---------------------------- ----------- 5.4/7.5 MB 15.6 MB/s eta 0:00:01\n",
- " ------------------------------- -------- 6.0/7.5 MB 16.0 MB/s eta 0:00:01\n",
- " ------------------------------------ --- 6.9/7.5 MB 16.2 MB/s eta 0:00:01\n",
- " --------------------------------------- 7.5/7.5 MB 16.5 MB/s eta 0:00:01\n",
- " ---------------------------------------- 7.5/7.5 MB 15.5 MB/s eta 0:00:00\n",
- "Downloading contourpy-1.1.0-cp311-cp311-win_amd64.whl (470 kB)\n",
- " ---------------------------------------- 0.0/470.9 kB ? eta -:--:--\n",
- " --------------------------------------- 470.9/470.9 kB 14.4 MB/s eta 0:00:00\n",
- "Downloading fonttools-4.42.1-cp311-cp311-win_amd64.whl (2.1 MB)\n",
- " ---------------------------------------- 0.0/2.1 MB ? eta -:--:--\n",
- " ------------ --------------------------- 0.7/2.1 MB 21.5 MB/s eta 0:00:01\n",
- " ----------------------------- ---------- 1.5/2.1 MB 19.6 MB/s eta 0:00:01\n",
- " ---------------------------------------- 2.1/2.1 MB 15.0 MB/s eta 0:00:00\n",
- "Downloading kiwisolver-1.4.5-cp311-cp311-win_amd64.whl (56 kB)\n",
- " ---------------------------------------- 0.0/56.1 kB ? eta -:--:--\n",
- " ---------------------------------------- 56.1/56.1 kB ? eta 0:00:00\n",
- "Downloading Pillow-10.0.0-cp311-cp311-win_amd64.whl (2.5 MB)\n",
- " ---------------------------------------- 0.0/2.5 MB ? eta -:--:--\n",
- " --------- ------------------------------ 0.6/2.5 MB 12.0 MB/s eta 0:00:01\n",
- " ------------------- -------------------- 1.2/2.5 MB 15.5 MB/s eta 0:00:01\n",
- " -------------------------------- ------- 2.1/2.5 MB 16.5 MB/s eta 0:00:01\n",
- " --------------------------------------- 2.5/2.5 MB 16.0 MB/s eta 0:00:01\n",
- " ---------------------------------------- 2.5/2.5 MB 14.6 MB/s eta 0:00:00\n",
- "Installing collected packages: pyparsing, pillow, kiwisolver, fonttools, cycler, contourpy, matplotlib\n",
- "Successfully installed contourpy-1.1.0 cycler-0.11.0 fonttools-4.42.1 kiwisolver-1.4.5 matplotlib-3.7.2 pillow-10.0.0 pyparsing-3.0.9\n",
- "Note: you may need to restart the kernel to use updated packages.\n"
- ]
- }
- ],
- "source": [
- "pip install matplotlib"
- ]
- },
- {
- "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": 20,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np \n",
- "\n",
- "def multi_list_with_x(en, *x):\n",
- " return (np.array(liste) * skalar)"
- ]
- },
- {
- "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": 22,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 22,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "liste = [1, 1.5, 2, 2.5, 3]\n",
- "skalar = 2\n",
- "\n",
- "list(multi_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": 81,
- "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": 82,
- "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": [
- "# Skriv koden din her\n",
- "rund_av=round"
- ]
- },
- {
- "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_1/innlevering/stud10/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud10/variabler.ipynb"
deleted file mode 100644
index 631e6073fb6311f05a979192710770c9904bc0c5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud10/variabler.ipynb"
+++ /dev/null
@@ -1,593 +0,0 @@
-{
- "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": 3,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn=input(\"Hva heter du?\")\n",
- "fag=input(\"Hva er favorittfaget ditt?\")\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": 15,
- "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": 1,
- "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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "cannot assign to literal here. Maybe you meant '==' instead of '='? (219688234.py, line 10)",
- "output_type": "error",
- "traceback": [
- "\u001b[1;36m Cell \u001b[1;32mIn[18], line 10\u001b[1;36m\u001b[0m\n\u001b[1;33m 1 = antall # variabelen må stå på venstre side\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to literal here. Maybe you meant '==' instead of '='?\n"
- ]
- }
- ],
- "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": 23,
- "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",
- "kundensAlder= 37\n",
- "differanse = ideal_alder - kundensAlder\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_1/innlevering/stud11/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud11/intro_til_jupyter.ipynb"
deleted file mode 100644
index 28631f2f2b05bb7e13e4da806342371c3c53f327..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud11/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,362 +0,0 @@
-{
- "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": 9,
- "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 Mari\n",
- "Da er du 41 å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": 2,
- "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": 3,
- "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": 14,
- "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 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_1/innlevering/stud11/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud11/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud11/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud11/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud11/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index c37b1ce7902a3106a19bbc8549dd9ec1fcaae0aa..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud11/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1092 +0,0 @@
-{
- "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": [
- "\n",
- "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 = 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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "liste_med_tall = [12, 2, 134, 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": 38,
- "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": 38,
- "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": 20,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+47 12345678\n",
- "+46 87654321\n"
- ]
- }
- ],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " telefonnummer = str(telefonnummer)\n",
- " landskode = str(landskode)\n",
- "\n",
- " kode_nummer = '+' + landskode + ' ' + telefonnummer\n",
- " \n",
- " return kode_nummer\n",
- "\n",
- "telefonnummer1 = 12345678\n",
- "telefonnummer2 = 87654321\n",
- "\n",
- "landskode1 = 47\n",
- "landskode2 = 46\n",
- "\n",
- "nummer1 = legg_til_landskode(telefonnummer1, landskode1)\n",
- "nummer2 = legg_til_landskode(telefonnummer2, landskode2)\n",
- "\n",
- "print(nummer1)\n",
- "print(nummer2)\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": "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": 21,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "# Skriv koden din her\n",
- "\n",
- "a = int(a)\n",
- "b = int(b == 'true' or 1)\n",
- "c = int(c == 'false')\n",
- "d = int(1.5)\n",
- "e= int(2.45)"
- ]
- },
- {
- "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": 34,
- "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": 53,
- "metadata": {
- "hidden": true
- },
- "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(start_liste, x):\n",
- " input_array = np.array(start_liste)\n",
- "\n",
- " result_array = input_array * x\n",
- "\n",
- " return result_array\n",
- "\n",
- "start_liste = [1, 1.5, 2, 2.5, 3]\n",
- "skalar = 2\n",
- "\n",
- "ferdig_liste = mult_list_with_x(start_liste, skalar)\n",
- "\n",
- "print(ferdig_liste)\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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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": 62,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "def rund_av(tall, desimaler):\n",
- " tall = round(tall, desimaler)\n",
- " return tall\n",
- "\n",
- "\n",
- "rundt_tall = rund_av(tall, desimaler)\n",
- "\n",
- "tall = 1.23456\n",
- "desimaler = 2\n",
- "\n",
- "print(rundt_tall)\n",
- "\n",
- "tall2 = 1234.5432\n",
- "desimaler2 = -3\n",
- "\n",
- "rundt_tall2 = rund_av(tall2, desimaler2)\n",
- "\n",
- "print(rundt_tall2)"
- ]
- },
- {
- "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": 50,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'rund_av' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[50], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(rund_av(\u001b[39m1.23456\u001b[39m, \u001b[39m2\u001b[39m))\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(rund_av(\u001b[39m1234.5432\u001b[39m, \u001b[39m-\u001b[39m\u001b[39m3\u001b[39m))\n",
- "\u001b[1;31mNameError\u001b[0m: name 'rund_av' is not defined"
- ]
- }
- ],
- "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_1/innlevering/stud11/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud11/variabler.ipynb"
deleted file mode 100644
index 276faa60b54a1378dc0601e79ae003f318410f25..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud11/variabler.ipynb"
+++ /dev/null
@@ -1,616 +0,0 @@
-{
- "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": 8,
- "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": 3,
- "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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei Mari\n",
- "javvist er LBAS2002 interessant!\n",
- "Ha en fin dag Mari\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = input('hva heter du: ')\n",
- "fav_fag = \"LBAS2002\"\n",
- "\n",
- "print('Hei' , navn)\n",
- "print(f'javvist er {fav_fag}' , 'interessant!')\n",
- "print('Ha en fin dag', navn)\n",
- "print('- og lykke til med', fav_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": 18,
- "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": 19,
- "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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 40,
- "metadata": {},
- "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",
- "Sirkelens omkrets er, 33.929200658769766\n",
- "Areal av sirkelen er 91.60884177867838\n",
- "Sylinderens areal er 451.25836876163794\n"
- ]
- }
- ],
- "source": [
- "\n",
- "radius = \"5.4\"\n",
- "høyde = \"7.9\"\n",
- "omkrets = (math.tau * 5.4)\n",
- "sir_areal = (np.pi * 5.4**2)\n",
- "syl_areal = (math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 **2)\n",
- "\n",
- "print(f'Har en sirkel med radius {radius}, som er grunnflate i en sylinder med høyde, {høyde}')\n",
- "print(f'Sirkelens omkrets er, {omkrets}')\n",
- "print(f'Areal av sirkelen er {sir_areal}')\n",
- "print(f'Sylinderens areal er {syl_areal}')\n",
- " \n",
- "\n"
- ]
- },
- {
- "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": 42,
- "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",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\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_1/innlevering/stud12/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud12/intro_til_jupyter.ipynb"
deleted file mode 100644
index 8512c753251f60c97eb354055c2cd31c4d14f2ec..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud12/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,343 +0,0 @@
-{
- "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": null,
- "metadata": {},
- "outputs": [],
- "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": null,
- "metadata": {},
- "outputs": [],
- "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! Jupyter 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": "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, ewi\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 såkalt 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_1/innlevering/stud12/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud12/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud12/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud12/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud12/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index a9c2eb39fd10d98d91f5b848dbbcee8a6ffbbeb3..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud12/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1228 +0,0 @@
-{
- "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": 3,
- "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": 5,
- "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": 6,
- "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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 8,
- "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": 9,
- "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": 10,
- "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": 11,
- "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": 12,
- "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": 14,
- "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": 15,
- "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": 16,
- "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": 17,
- "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": 20,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[20], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[39mprint\u001b[39m (\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[0;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": 21,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 23,
- "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": 23,
- "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": 33,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return \"+\" + str(landskode) + \" \" + str(telefonnummer) "
- ]
- },
- {
- "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": 34,
- "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": 41,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2.45'\n",
- "\n",
- "# Skriv koden din her\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": 42,
- "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": 17,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "\n",
- "import numpy as np\n",
- "\n",
- "\n",
- "def mult_list_with_x(l,x):\n",
- " return list(result)\n",
- "l = np.array(liste)\n",
- "x = skalar\n",
- "result=np.multiply(l,x)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "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": 16,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 16,
- "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": 11,
- "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": 12,
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "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.9.10"
- },
- "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_1/innlevering/stud12/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud12/variabler.ipynb"
deleted file mode 100644
index 3f5dd61e2f4798cd1f469aaa9fa023582df46a5c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud12/variabler.ipynb"
+++ /dev/null
@@ -1,549 +0,0 @@
-{
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "print('Hei, Ada')\n",
- "print('LBAS2002 - interessant!')\n",
- "print('Ha en fin dag, Ada')\n",
- "print('- og lykke til med LBAS2002')"
- ]
- },
- {
- "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": 1,
- "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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (1274524858.py, line 12)",
- "output_type": "error",
- "traceback": [
- "\u001b[0;36m Cell \u001b[0;32mIn[2], line 12\u001b[0;36m\u001b[0m\n\u001b[0;31m 10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "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": 5,
- "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",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\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_1/innlevering/stud13/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud13/intro_til_jupyter.ipynb"
deleted file mode 100644
index 27bd6ddadf87670c8ce06047aa1d4236b664c2d7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud13/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 33,
- "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": 23,
- "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 Runa\n",
- "Da er du 30 å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": 28,
- "metadata": {},
- "outputs": [],
- "source": [
- "message = \"Wow, Jupyter er råkult!\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Kjør så kodeblokken nedenfor:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 30,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Wow, Jupyter er rå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": 32,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Runa\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": [
- "**Ditt svar:** <hghgjghjkghjk\\>"
- ]
- },
- {
- "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_1/innlevering/stud13/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud13/lab-1.md"
deleted file mode 100644
index 016417fd5c1ae41a269a7cec6e4a9c1378042479..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud13/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud13/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud13/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 5a367d8de6c114636f621e01aa9d522d6933fc40..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud13/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1177 +0,0 @@
-{
- "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": 44,
- "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": 8,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-10\n",
- "-10\n",
- "-100\n",
- "0\n",
- "1\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 // a) # Samme som -10 : -10"
- ]
- },
- {
- "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": 9,
- "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": 11,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 12,
- "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": 13,
- "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": 14,
- "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": 15,
- "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": 17,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her er et tall: 123456\n"
- ]
- }
- ],
- "source": [
- "tall = 123456\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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 19,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her har du en liste med kule tall: [1, 2, 3, 4, 6, 7, 8, 8, 10]\n"
- ]
- }
- ],
- "source": [
- "liste_med_tall = [1, 2, 3, 4,6,7,8,8,10]\n",
- "print(f'Her har du en liste med kule 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": 20,
- "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": 24,
- "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": 68,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[68], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[0;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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 ' + 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": 69,
- "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": 71,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "25\n"
- ]
- }
- ],
- "source": [
- "def legg_sammen_to_tall(a, b):\n",
- " str(a) + str(b)\n",
- " print (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": 121,
- "metadata": {},
- "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('+' , str(landskode1), str(telefonnummer1))\n",
- "print('+', str(landskode2), str(telefonnummer2))"
- ]
- },
- {
- "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": "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": 129,
- "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": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = 1.5\n",
- "e = 2.45\n",
- "\n",
- "print(f'a er nå {int(a)}')\n",
- "print(f'b er nå {int(b)}')\n",
- "print(f'c er nå {int(c)}')\n",
- "print(f'd er nå {int(d)}')\n",
- "print(f'e er nå {int(e)}')\n"
- ]
- },
- {
- "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": "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": 24,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[20. 30. 40. 50. 60.]\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return l*x\n",
- "\n",
- "liste = [1,1.5,2, 2.5, 3]\n",
- "skalar = 20\n",
- "\n",
- "print(mult_list_with_x(np.array(liste),skalar))\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": "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": 25,
- "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": 134,
- "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": 26,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall,desimaler):\n",
- " return round(tall,desimaler)\n",
- "\n",
- "print(rund_av(1.23456,2))\n",
- "print(rund_av(1234.5432, -3))"
- ]
- },
- {
- "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": 138,
- "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_1/innlevering/stud13/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud13/variabler.ipynb"
deleted file mode 100644
index c6f4d275d4b7b0bb40e683255dfbbd6b811d39c4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud13/variabler.ipynb"
+++ /dev/null
@@ -1,579 +0,0 @@
-{
- "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": 5,
- "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": "markdown",
- "metadata": {
- "hidden": true
- },
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "print('Hei, Ada')\n",
- "print('LBAS2002 - interessant!')\n",
- "print('Ha en fin dag, Ada')\n",
- "print('- og lykke til med LBAS2002')"
- ]
- },
- {
- "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": 1,
- "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": 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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 9,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (2464945294.py, line 12)",
- "output_type": "error",
- "traceback": [
- "\u001b[0;36m Cell \u001b[0;32mIn[9], line 12\u001b[0;36m\u001b[0m\n\u001b[0;31m 10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "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": 24,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna ideal_alderen\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 ideal_alderen')"
- ]
- }
- ],
- "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_1/innlevering/stud14/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud14/intro_til_jupyter.ipynb"
deleted file mode 100644
index ebab61edcc4641eecb58dae5a1155d70635f6b61..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud14/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,359 +0,0 @@
-{
- "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": 10,
- "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": null,
- "metadata": {},
- "outputs": [],
- "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": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "message= \"Jeg elsker koding 100%\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Kjør så kodeblokken nedenfor:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg elsker koding 100%\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": 9,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, kk\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": [
- "**Ditt svar:** <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_1/innlevering/stud14/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud14/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 64a625c8cc0a5944a4638eef401e7dec08bff969..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud14/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1220 +0,0 @@
-{
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "136\n"
- ]
- }
- ],
- "source": [
- "a = -10\n",
- "b = 0\n",
- "c = 10\n",
- "print(a**2+c-b+26)"
- ]
- },
- {
- "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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-10\n",
- "-10\n",
- "-100\n",
- "0\n",
- "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 * 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": 8,
- "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": 12,
- "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": {},
- "source": []
- },
- {
- "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": 13,
- "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": 14,
- "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": 15,
- "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": 16,
- "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": 17,
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 19,
- "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": 20,
- "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": 21,
- "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": 141,
- "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 = '13'\n",
- "alder_mor = '37'\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!')\n",
- "\n",
- "alder = '13'\n",
- "sum_alder = int(alder) + int(alder_mor)\n",
- "\n",
- "print(f'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": 27,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 93,
- "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": 93,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "def f(a, b):\n",
- " return int(a) + int(b)\n",
- "\n",
- "f(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": 213,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "def legg_til_landskode(landskode, telefonnummer):\n",
- " return '+' + str(telefonnummer), str(landskode)"
- ]
- },
- {
- "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": 212,
- "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": 91,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = 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": 92,
- "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": 266,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l)) \n",
- " \n",
- " \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": 267,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 267,
- "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": 136,
- "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": 137,
- "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": 138,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "def rund_av(a, b):\n",
- " return round(a, b)"
- ]
- },
- {
- "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": 139,
- "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_1/innlevering/stud14/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud14/variabler.ipynb"
deleted file mode 100644
index ae9986bb37ac77698b484df47f7e02d70906c82a..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud14/variabler.ipynb"
+++ /dev/null
@@ -1,576 +0,0 @@
-{
- "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": 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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, mox\n",
- "koding - interessant!\n",
- "Ha en fin dag, mox\n",
- "- og lykke til med koding\n"
- ]
- }
- ],
- "source": [
- "\n",
- "navn = input('Hva heter du? ')\n",
- "print(f'Hei, {navn}')\n",
- "favorittfag = input('Favorittfag?')\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": 8,
- "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": 17,
- "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 as m\n",
- "r = 5.4\n",
- "h = 7.9\n",
- " \n",
- "print(f\"Har en sirkel med radius\", {r}, \"som er grunnflate i en sylinder med høyde\", {h})\n",
- "print(f\"Omkrets av sirkelen:\", {m.tau * r}) #tau er det samme som 2 pi\n",
- "print(f\"Areal av sirkelen:\", {m.pi * r**2})\n",
- "print(f\"Areal av sylinderen:\", {m.tau * r * h + 2 * m.pi * r ** 2})"
- ]
- },
- {
- "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": 19,
- "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_1/innlevering/stud15/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud15/intro_til_jupyter.ipynb"
deleted file mode 100644
index c982078c372d5d8f078937e85fb3cf206c93dd15..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud15/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,335 +0,0 @@
-{
- "cells": [
- {
- "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": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "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": null,
- "metadata": {},
- "outputs": [],
- "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! 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": 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": "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"
- ]
- },
- {
- "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:** 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.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_1/innlevering/stud15/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud15/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud15/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud15/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud15/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 178b494b4e5ef2891c0b0255deef50f291b09ca6..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud15/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1248 +0,0 @@
-{
- "cells": [
- {
- "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": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = -10\n",
- "b = 1\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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-9\n",
- "-9\n",
- "-100\n",
- "10\n",
- "-10.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 / 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": 5,
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 7,
- "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": 8,
- "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": 9,
- "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: False\n"
- ]
- }
- ],
- "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": 14,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her har du en liste med tall: [1, 2, 3, 10]\n"
- ]
- }
- ],
- "source": [
- "liste_med_tall = [1, 2, 3, 10]\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": 15,
- "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": 16,
- "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": 8,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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(f'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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 25,
- "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": 25,
- "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": 41,
- "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(f'+{landskode1} {telefonnummer1}')\n",
- "print(f'+{landskode2} {telefonnummer2}')"
- ]
- },
- {
- "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": 47,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "12345678\n",
- "46\n"
- ]
- }
- ],
- "source": [
- "telefonnummer1 = 12345678\n",
- "landskode1 = 47\n",
- "\n",
- "telefonnummer2 = 87654321\n",
- "landskode2 = 46\n",
- "\n",
- "print(telefonnummer1)\n",
- "print(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": 58,
- "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": [
- "a = int(1)\n",
- "b = int(1)\n",
- "c = int(0)\n",
- "d = int(1.5)\n",
- "e = int(2.45)\n",
- "\n",
- "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": {
- "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": 59,
- "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": 78,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]\n"
- ]
- }
- ],
- "source": [
- "liste = [2.0 , 3.0 , 4.0 , 5.0 , 6.0]\n",
- "skalar = 1\n",
- "\n",
- "print (liste* skalar)"
- ]
- },
- {
- "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": 35,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "array([1. , 1.5, 2. , 2.5, 3. , 1. , 1.5, 2. , 2.5, 3. ])"
- ]
- },
- "execution_count": 35,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "import numpy as np\n",
- "\n",
- "liste = [1, 1.5, 2, 2.5, 3]\n",
- "skalar = 2\n",
- "\n",
- "np.array(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": 2,
- "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": 80,
- "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": 82,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "print(round(1.23456, 2))\n",
- "print(round(1234.5432, -3))"
- ]
- },
- {
- "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": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "print(round(1.23456, 2))\n",
- "print(round(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.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_1/innlevering/stud15/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud15/variabler.ipynb"
deleted file mode 100644
index 84f52565e0c474cad4a72fbbcb71de1c9b29e4f7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud15/variabler.ipynb"
+++ /dev/null
@@ -1,601 +0,0 @@
-{
- "cells": [
- {
- "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": 4,
- "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}') "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## a) Huske verdier i variable"
- ]
- },
- {
- "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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdin",
- "output_type": "stream",
- "text": [
- "Navn? Kjersti\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei Kjersti\n"
- ]
- },
- {
- "name": "stdin",
- "output_type": "stream",
- "text": [
- "Favorittfag? Informatikk\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Informatikk - interessant!\n",
- "Ha en fin dag, Kjersti\n",
- "- og lykke til med Informatikk\n"
- ]
- }
- ],
- "source": [
- "Navn = input(\"Navn?\")\n",
- "print(\"Hei\", Navn)\n",
- "Fag = input(\"Favorittfag?\")\n",
- "print(f'{Fag} - interessant!')\n",
- "print(f'Ha en fin dag, {Navn}')\n",
- "print(f'- og lykke til med {Fag}')"
- ]
- },
- {
- "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": 16,
- "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)"
- ]
- },
- {
- "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 "
- ]
- },
- {
- "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": 19,
- "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 numpy as np\n",
- "import math\n",
- "\n",
- "r = 5.4\n",
- "h = 7.9\n",
- "\n",
- "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * r) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * r **2)\n",
- "print(\"Areal av sylinderen:\", math.tau * r * h + 2 * math.pi * r ** 2)"
- ]
- },
- {
- "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": 21,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 8 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn4 = \"Per\"\n",
- "ideal_alder = 42\n",
- "kundens_Alder= 34\n",
- "differanse = ideal_alder - kundens_Alder\n",
- "print(f'{navn4} 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.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_1/innlevering/stud2/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud2/intro_til_jupyter.ipynb"
deleted file mode 100644
index 9693bb7620c59e2e657ba444ed12a40d87cfbd78..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud2/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,374 +0,0 @@
-{
- "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": 5,
- "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 Pia\n",
- "Da er du 28 å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": 6,
- "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": 7,
- "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": 8,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Pia\n"
- ]
- }
- ],
- "source": [
- "navn = input(\"Hva heter du?\")\n",
- "print(\"Hei,\", navn)\n",
- "# Skjønner ikke hva Kernel er, men finner både Restart og Clear All Outputs i menyen over. \n",
- "# Ser ikke stjernetegn ved blokkene\n",
- "# Clear all outputs virker mindre skummelt enn Restart, alle outputs forsvant, men jeg gjennomgikk dem igjen\n",
- "# Prøvde å trykke restart - beskjed om at 'All variables will be lost', men de er her fortsatt - ingenting forsvant!\n"
- ]
- },
- {
- "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:** <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_1/innlevering/stud2/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud2/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud2/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud2/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud2/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 1509cf25f760cfba98d358ec57fe64000b9a1509..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud2/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1264 +0,0 @@
-{
- "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 forskjellige 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": {},
- "source": []
- },
- {
- "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": 2,
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-10\n",
- "-10\n",
- "-100\n",
- "0\n",
- "0.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(b / c) # Samme som 0 : 10"
- ]
- },
- {
- "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": 5,
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "source": [
- "print(c + e) # Samme som 1.2 + (-4.2), stemmer ikke, det er det samme som 10 + (-4.2) og da stemmer svaret i output\n",
- "print(c - e) # Samme som 1.2 - (-4.2), stemmer ikke, det er det samme som 10 - (-4.2)\n",
- "print(f * e) # Samme som 0.0 * (4.2)\n",
- "# Her brukes ikke variablen d som er ovenfor, men variablen c lenger opp som gir verdien 10"
- ]
- },
- {
- "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": 7,
- "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)\n",
- "# Det utgjør ingen forskjell om det brukes enkelt- eller dobbeltfnutter, med trippelfnutter er det mulig å skrive på flere linjer"
- ]
- },
- {
- "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": 8,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "101520\n"
- ]
- }
- ],
- "source": [
- "s4 = '10' + '15' + '20'\n",
- "print(s4)\n",
- "# Da kommer sifrene ut etter hverandre uten mellomrom, tallene oppfattes som tekst og ikke heltall (integers)\n",
- "# Leser under at det heter at strengene blir konkatinert"
- ]
- },
- {
- "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": 9,
- "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)\n"
- ]
- },
- {
- "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: False\n"
- ]
- }
- ],
- "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": 67,
- "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": 13,
- "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": 14,
- "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": 68,
- "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('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": 22,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 116,
- "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": 116,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "def legg_sammen_to_tall(a, b):\n",
- " #return str(a) + str(b)\n",
- " return int(a) +int(b)\n",
- "legg_sammen_to_tall (10, 15)\n"
- ]
- },
- {
- "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": 71,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "# legg_til_landskode int(telefonnummer, landskode)\n",
- "\n",
- "# name=legg_til_landskode\n",
- "\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return '+' + 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": 72,
- "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": 76,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "<class 'int'>\n",
- "<class 'int'>\n",
- "<class 'int'>\n",
- "<class 'int'>\n",
- "<class 'int'>\n"
- ]
- }
- ],
- "source": [
- "#a = '1'\n",
- "#b = True\n",
- "#c = False\n",
- "#d = '1.5'\n",
- "#e = '2,45'\n",
- "#print(type(a))\n",
- "#print(type(b))\n",
- "# Skriv koden din her\n",
- "a = int('1')\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(float('1.5'))\n",
- "e = int(float('2.45')) #endret til punktum istedet for komma\n",
- "print(type(a))\n",
- "print(type(b))\n",
- "print(type(c))\n",
- "print(type(d))\n",
- "print(type(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": 77,
- "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}')\n"
- ]
- },
- {
- "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": 130,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[ 40 80 120 160]\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np\n",
- "#def mult_list_with_x(liste, skalar):\n",
- "# return np.array(liste) * skalar\n",
- "#print(type(skalar))\n",
- "\n",
- "def mult_list_whit_x(l,x): \n",
- " resultat = l*x\n",
- " return resultat\n",
- "\n",
- "l = np.array([10,20,30,40])\n",
- "print(mult_list_whit_x(l,4))"
- ]
- },
- {
- "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": 137,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "array([2., 3., 4., 5., 6.])"
- ]
- },
- "execution_count": 137,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "#liste =[1, 1.5, 2, 2.5, 3]\n",
- "#skalar = 2\n",
- "\n",
- "#mult_list_whit_x(liste,skalar)\n",
- "\n",
- "\n",
- "l = np.array([1, 1.5, 2, 2.5, 3])\n",
- "x = 2\n",
- "\n",
- "# print(liste * skalar)\n",
- "\n",
- "\n",
- "mult_list_with_x(l, x)"
- ]
- },
- {
- "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": 110,
- "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": 111,
- "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": 113,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " return round(tall, desimaler)\n",
- "\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": 114,
- "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_1/innlevering/stud2/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud2/variabler.ipynb"
deleted file mode 100644
index 31480cd4778f3a583d0b7354e203927370626b17..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud2/variabler.ipynb"
+++ /dev/null
@@ -1,605 +0,0 @@
-{
- "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}') #{pi} er variabel og peker tilbake på tallet - kan gjenbrukes flere ganger\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": 3,
- "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? #rettet opp gangestykket slik at det ble rett svar."
- ]
- },
- {
- "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": 54,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Monica\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Monica\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "#print('Hei, Ada')\n",
- "#print('LBAS2002 - interessant!')\n",
- "#print('Ha en fin dag, Ada')\n",
- "#print('- og lykke til med LBAS2002')\n",
- "\n",
- "navn = input('Navn?')\n",
- "print('Hei, ' + navn)\n",
- "fag = input('Favorittfag?')\n",
- "print(fag + ' - interessant!')\n",
- "print('Ha en fin dag, ' + navn)\n",
- "print('- 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": 56,
- "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": 63,
- "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": [
- "33.928200000000004\n",
- "Har en sirkel med radius 5.4 som er grunnflate i en sylinder med høyde 7.9\n",
- "Omkrets av sirkelen: 33.9\n",
- "Areal av sirkelen: 92\n",
- "Areal av sylinderen: 451\n"
- ]
- }
- ],
- "source": [
- "#import numpy as np #feilmelding No module named 'numpy'\n",
- "import math\n",
- " \n",
- "#print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "#print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "#print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "#print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)\n",
- "\n",
- "r = 5.4\n",
- "\n",
- "pi = math.pi \n",
- "h_sylinder = 7.9\n",
- "o_sirkel = 2 * pi * r\n",
- "a_sirkel = pi * r ** 2\n",
- "print(o)\n",
- "print(\"Har en sirkel med radius \" + str(r) + \" som er grunnflate i en sylinder med høyde \" + str(h_sylinder)) \n",
- "print(\"Omkrets av sirkelen: \" + str(round(o_sirkel,1))) \n",
- "print(\"Areal av sirkelen: \" + str(round(a_sirkel)))\n",
- "print(\"Areal av sylinderen: \" + str(round(o_sirkel * h_sylinder + 2 * a_sirkel)))\n",
- "#mente jeg kunne bestemme desimaler ved å skrive :0.1f, men det ga bare feilmelding.\n",
- "\n",
- "#forsøkte etterpå å bruke round for å ta bort desimaler, det virket"
- ]
- },
- {
- "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": 30,
- "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",
- "#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\n",
- "\n",
- "# satte alle dysfunksjonelle tilordninger som merknad"
- ]
- },
- {
- "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": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## c) Variabelnavn"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 29,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn4 = \"Per\"\n",
- "ideal_alder = 42\n",
- "kundensAlder = 37\n",
- "differanse = ideal_alder - kundensAlder\n",
- "print(f'{navn4} 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_1/innlevering/stud3/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud3/intro_til_jupyter.ipynb"
deleted file mode 100644
index fcdd1bcb531545e39233009b459f783f94ba0afc..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud3/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 5,
- "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": 4,
- "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 Jannicke\n",
- "Da er du 31 å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": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "message = \"Nå lærer jeg noe nytt!\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Kjør så kodeblokken nedenfor:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Nå lærer jeg noe nytt!\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, Jannicke\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": [
- "**Ditt svar:** <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_1/innlevering/stud3/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud3/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud3/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud3/lab.zip" "b/\303\270vinger/\303\270ving_1/innlevering/stud3/lab.zip"
deleted file mode 100644
index d9ce5eb6d06bc549c66c7088cd79c1f779305c42..0000000000000000000000000000000000000000
Binary files "a/\303\270vinger/\303\270ving_1/innlevering/stud3/lab.zip" and /dev/null differ
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/stud3/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud3/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index a64cf53e3e8ff48448030b20465db0499fe91fb8..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud3/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1245 +0,0 @@
-{
- "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": 3,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = -10\n",
- "b = 1\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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-9\n",
- "-9\n",
- "-100\n",
- "10\n",
- "-10.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 / 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": 5,
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 7,
- "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": 8,
- "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": 9,
- "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": 13,
- "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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Her har du en liste med tall: [33, 6783, 1, 238]\n"
- ]
- }
- ],
- "source": [
- "liste_med_tall = [33, 6783, 1, 238]\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": 16,
- "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": 17,
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[18], line 9\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[1;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": 19,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 22,
- "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": 22,
- "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": 44,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "+ 47 12345678\n",
- "+ 46 87654321\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "telefonnummer1 = 12345678\n",
- "landskode1 = 47\n",
- "\n",
- "telefonnummer2 = 87654321\n",
- "landskode2 = 46\n",
- "\n",
- "print('+' , str(landskode1) , str(telefonnummer1))\n",
- "print('+' , str(landskode2) , str(telefonnummer2))"
- ]
- },
- {
- "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": 68,
- "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": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = 1.5\n",
- "e = 2.45\n",
- "\n",
- "# Skriv koden din her\n",
- "print(f'a er nå {int(a)}')\n",
- "print(f'b er nå {int(b)}')\n",
- "print(f'c er nå {int(c)}')\n",
- "print(f'd er nå {int(d)}')\n",
- "print(f'e er nå {int(e)}')\n",
- "\n"
- ]
- },
- {
- "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": 23,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'a' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[23], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39ma er nå \u001b[39m\u001b[39m{\u001b[39;00ma\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m)\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mb er nå \u001b[39m\u001b[39m{\u001b[39;00mb\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m)\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mc er nå \u001b[39m\u001b[39m{\u001b[39;00mc\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
- ]
- }
- ],
- "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": 53,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2. 3. 4. 5. 6.]\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "\n",
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " resultat = l*x\n",
- " return resultat\n",
- "l = np.array([1, 1.5, 2, 2.5, 3])\n",
- "\n",
- "print(mult_list_with_x(l,2))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "liste = [1, 1.5, 2, 2.5, 3]\n",
- "skalar = 2\n",
- "\n",
- "mult_list_with_x(liste, skalar)\n",
- "list() \n",
- "import numpy as np\n",
- "np.array()"
- ]
- },
- {
- "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": 79,
- "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": 80,
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " return round(tall, desimaler)\n",
- "\n",
- "print(rund_av(1.23456, 2))\n",
- "print(rund_av(1234.5432, -3))\n",
- "\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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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_1/innlevering/stud3/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud3/variabler.ipynb"
deleted file mode 100644
index d8e2ec468be3dd35c5cbd3d82a3af8318d4e9ad4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud3/variabler.ipynb"
+++ /dev/null
@@ -1,587 +0,0 @@
-{
- "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": 4,
- "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": 3,
- "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": 8,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS1002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS1002\n"
- ]
- }
- ],
- "source": [
- "navn= 'Ada'\n",
- "fag= 'LBAS1002'\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": 9,
- "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": 41,
- "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.60882272000002\n",
- "Areal av sylinderen: 451.25836876163794\n"
- ]
- }
- ],
- "source": [
- "import math \n",
- "\n",
- "pi = 3.141592\n",
- "r = 5.4 \n",
- "h = 7.9\n",
- "\n",
- "print(f\"Har en sirkel med radius {r} som er grunnflate i en sylinder med høyde {h}\")\n",
- "print(f\"Omkrets av sirkelen: {math.tau * r}\")\n",
- "print(f\"Areal av sirkelen: {pi * r**2}\")\n",
- "print(f\"Areal av sylinderen: {math.tau * r * h + 2 * math.pi * r ** 2}\")\n"
- ]
- },
- {
- "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": 49,
- "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",
- "kunde_alder = 37\n",
- "differanse = ideal_alder - kunde_alder\n",
- "print(f'{navn} er {differanse} år unna idealalderen')\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_1/innlevering/stud4/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud4/intro_til_jupyter.ipynb"
deleted file mode 100644
index cfdc0332e79878fbf01140c2c8a4dfee7effd8a8..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud4/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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 Aurora\n",
- "Da er du 37 å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": 7,
- "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": 8,
- "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": 9,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, \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": [
- "**Ditt svar:** <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_1/innlevering/stud4/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud4/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud4/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud4/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud4/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 24ca13efc6d2bb51bd504ae4502fc9d29fb58dac..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud4/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1254 +0,0 @@
-{
- "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": 2,
- "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": 75,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"bool\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[75], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(a \u001b[39m+\u001b[39;49m b) \u001b[39m# Samme som å si -10 + 0\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \u001b[39mprint\u001b[39m(b \u001b[39m-\u001b[39m c) \u001b[39m# Samme som 0 - 10\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[39mprint\u001b[39m(a \u001b[39m*\u001b[39m c) \u001b[39m# Samme som -10 * 10\u001b[39;00m\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"bool\") to str"
- ]
- }
- ],
- "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": 6,
- "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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 8,
- "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": 9,
- "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": 10,
- "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": 11,
- "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": 12,
- "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": 13,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 14,
- "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": 15,
- "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": 16,
- "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": 20,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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!')"
- ]
- },
- {
- "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": 25,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 38,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2019-07-01T11:24:13.550825Z",
- "start_time": "2019-07-01T11:24:13.542723Z"
- },
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "25\n"
- ]
- }
- ],
- "source": [
- "def legg_sammen_to_tall(a, b):\n",
- " return str(a) + str(b)\n",
- "\n",
- "legg_sammen_to_tall(10, 15)\n",
- "s1 = (10) + (15)\n",
- "print(s1)"
- ]
- },
- {
- "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": 66,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "47 12345678\n"
- ]
- }
- ],
- "source": [
- "telefonnummer = 12345678\n",
- "landskode = 47\n",
- "print(landskode, telefonnummer)\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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'legg_til_landskode' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[1], line 7\u001b[0m\n\u001b[0;32m 4\u001b[0m telefonnummer2 \u001b[39m=\u001b[39m \u001b[39m87654321\u001b[39m\n\u001b[0;32m 5\u001b[0m landskode2 \u001b[39m=\u001b[39m \u001b[39m46\u001b[39m\n\u001b[1;32m----> 7\u001b[0m \u001b[39mprint\u001b[39m(legg_til_landskode(telefonnummer1, landskode1))\n\u001b[0;32m 8\u001b[0m \u001b[39mprint\u001b[39m(legg_til_landskode(telefonnummer2, landskode2))\n",
- "\u001b[1;31mNameError\u001b[0m: name 'legg_til_landskode' is not defined"
- ]
- }
- ],
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "a er nå 1\n",
- "b er nå True\n",
- "c er nå False\n",
- "d er nå 2\n",
- "e er nå 2\n"
- ]
- }
- ],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '2'\n",
- "e = '2'\n",
- "\n",
- "\n",
- "# Skriv koden din her\n",
- "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}')\n"
- ]
- },
- {
- "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": 10,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "a er nå 1\n",
- "b er nå True\n",
- "c er nå False\n",
- "d er nå 2\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": 94,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[ 50 100 150]\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np \n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " resultat = l * x \n",
- " return resultat\n",
- "\n",
- "min_liste = np.array([10,20,30])\n",
- "x=5\n",
- "\n",
- "print(mult_list_with_x(min_liste, x))\n",
- "\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": 77,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'mult_list_with_x' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[77], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m liste \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m, \u001b[39m1.5\u001b[39m, \u001b[39m2\u001b[39m, \u001b[39m2.5\u001b[39m, \u001b[39m3\u001b[39m]\n\u001b[0;32m 2\u001b[0m skalar \u001b[39m=\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m----> 4\u001b[0m mult_list_with_x(liste, skalar)\n",
- "\u001b[1;31mNameError\u001b[0m: name 'mult_list_with_x' is not defined"
- ]
- }
- ],
- "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": 59,
- "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": 60,
- "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": 74,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.2\n"
- ]
- }
- ],
- "source": [
- "print(round(1.234, 1))\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": 72,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "print(round(1.23456, 2))\n",
- "print(round(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_1/innlevering/stud4/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud4/variabler.ipynb"
deleted file mode 100644
index 64ec783fa53e8d4f5953e7f67b90be88289498f4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud4/variabler.ipynb"
+++ /dev/null
@@ -1,592 +0,0 @@
-{
- "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": 19,
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1 + 1 = 2\n",
- "2 * 5 = 10\n"
- ]
- }
- ],
- "source": [
- "print(f'1 + 1 = {1 + 1}')\n",
- "print(f'2 * 5 = {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": 40,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei Ada\n",
- "Favorittfag? LBAS2002\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = ('Ada')\n",
- "fag = ('LBAS2002')\n",
- "print('Hei', navn)\n",
- "print('Favorittfag?', fag)\n",
- "print('Ha en fin dag,', navn)\n",
- "print('- 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": 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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 42,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (1274524858.py, line 12)",
- "output_type": "error",
- "traceback": [
- "\u001b[1;36m Cell \u001b[1;32mIn[42], line 12\u001b[1;36m\u001b[0m\n\u001b[1;33m 10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "idealAlder = 42\n",
- "kundensAlder = 37\n",
- "differanse = idealAlder - kundensAlder\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_1/innlevering/stud5/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud5/intro_til_jupyter.ipynb"
deleted file mode 100644
index 72b41a427d7ba0eab20d9296481bf7821a01ab38..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud5/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,405 +0,0 @@
-{
- "cells": [
- {
- "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": [
- "hello world\n"
- ]
- }
- ],
- "source": [
- "print(\"hello world\")"
- ]
- },
- {
- "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"
- ]
- },
- {
- "name": "stdin",
- "output_type": "stream",
- "text": [
- "Hva heter du? Sindre\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei Sindre\n"
- ]
- },
- {
- "name": "stdin",
- "output_type": "stream",
- "text": [
- "Hvor gammel er du? 27\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Da er du 32 å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": 3,
- "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": 2,
- "metadata": {},
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'message' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mmessage\u001b[49m)\n",
- "\u001b[0;31mNameError\u001b[0m: name 'message' is not defined"
- ]
- }
- ],
- "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": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdin",
- "output_type": "stream",
- "text": [
- "Hva heter du? \n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, \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"
- ]
- },
- {
- "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:** <Programering 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.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_1/innlevering/stud5/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud5/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud5/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud5/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud5/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 69fea1fb0dcbcbaba570e860eda8cdbbf5b2aa51..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud5/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1249 +0,0 @@
-{
- "cells": [
- {
- "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": 10,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = -10\n",
- "b = 2\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": 11,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-8\n",
- "-8\n",
- "-100\n",
- "20\n",
- "-5.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 / 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": 6,
- "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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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": 12,
- "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": 13,
- "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": 14,
- "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": 17,
- "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": 16,
- "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": 18,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 19,
- "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": 20,
- "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": 21,
- "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": 22,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[22], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGratulerer, til sammen er dere \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msum_alder\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m år!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m sum_alder \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(alder) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mint\u001b[39m(alder_mor)\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mGratulerer, til sammen er dere \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43msum_alder\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m år!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
- "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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": 24,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 1,
- "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": 1,
- "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": 29,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "47 12345678\n",
- "47 87654321\n"
- ]
- }
- ],
- "source": [
- "telefonnummer1 = 12345678\n",
- "telefonnummer2 = 87654321\n",
- "\n",
- "landskode1 = 47\n",
- "landskode2 = 48\n",
- "\n",
- "print(landskode1, telefonnummer1)\n",
- "print(landskode1, telefonnummer2)"
- ]
- },
- {
- "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": 46,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "46 87654321\n",
- "47 12345678\n"
- ]
- }
- ],
- "source": [
- "telefonnummer1 = 12345678\n",
- "landskode1 = 47\n",
- "\n",
- "telefonnummer2 = 87654321\n",
- "landskode2 = 46\n",
- "\n",
- "print(landskode2, telefonnummer2)\n",
- "print(landskode1, telefonnummer1)\n"
- ]
- },
- {
- "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": 47,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "\n"
- ]
- },
- {
- "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": 48,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "a er nå 1\n",
- "b er nå True\n",
- "c er nå False\n",
- "d er nå 1.5\n",
- "e er nå 2,45\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": 66,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2.0, 3.0, 5.0, 6.0] [[2.0, 3.0, 5.0, 6.0], 1]\n"
- ]
- }
- ],
- "source": [
- "liste =[2.0, 3.0, 5.0, 6.0]\n",
- "skala = [l,1]\n",
- " \n",
- "print(liste, skala)"
- ]
- },
- {
- "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": 75,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "<built-in function array> 2\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "\n",
- "np.array([2.0, 3.0, 5.0, 6.0])\n",
- "\n",
- "skalar = 2\n",
- "\n",
- "print(np.array, 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": 96,
- "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": 97,
- "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": 101,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.2345: 12345.00\n",
- "1000: 1000.0\n"
- ]
- }
- ],
- "source": [
- "print(f'1.2345: {12345:.2f}')\n",
- "\n",
- "print(f'1000: {1000:.1f}')"
- ]
- },
- {
- "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": 102,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23456: 1.23\n",
- "1234.5432: 1234.543200\n"
- ]
- }
- ],
- "source": [
- "print(f'1.23456: {1.23456:.2f}')\n",
- "\n",
- "print(f'1234.5432: {1234.5432:-3f}')"
- ]
- },
- {
- "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.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_1/innlevering/stud5/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud5/variabler.ipynb"
deleted file mode 100644
index cab11025e5135aa6bdc65b98ed6084134406bbdb..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud5/variabler.ipynb"
+++ /dev/null
@@ -1,531 +0,0 @@
-{
- "cells": [
- {
- "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`.riabelnavnet **ikke** skal ha fn\n",
- "* linje 2, variabelen `pi` brukes sist i f-strengen i print-setningen. Merk at vautter 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": 7,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1 + 3 = 4\n",
- "2 * 80 = 160\n"
- ]
- }
- ],
- "source": [
- "print(f'1 + 3 = {1 + 3}')\n",
- "print(f'2 * 80 = {2 * 80}') "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## a) Huske verdier i variable"
- ]
- },
- {
- "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": "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)"
- ]
- },
- {
- "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 "
- ]
- },
- {
- "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": 18,
- "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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (2066608501.py, line 1)",
- "output_type": "error",
- "traceback": [
- "\u001b[0;36m Cell \u001b[0;32mIn[2], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 4navn = \"Per\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "source": [
- "4navn = \"Per\"\n",
- "ideal alder = 42\n",
- "37 = kundensAlder\n",
- "differanse = ideal alder - kundensAlder\n",
- "print(f'{4navn} 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.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_1/innlevering/stud6/Intro til Jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud6/Intro til Jupyter.ipynb"
deleted file mode 100644
index cd8116f12bc3ae2862bbd3b1d6b896ddc8172349..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud6/Intro til Jupyter.ipynb"
+++ /dev/null
@@ -1,341 +0,0 @@
-{
- "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": null,
- "metadata": {},
- "outputs": [],
- "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": 1,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Dette er mitt program i jupyter\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Silje Melhus\n",
- "Da er du 33 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er mitt program i jupyter\") #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": 13,
- "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": [
- "**Svaret ditt:** <dobbelklikk her for å svare\\>"
- ]
- },
- {
- "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_1/innlevering/stud6/Tall og Typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud6/Tall og Typekonvertering.ipynb"
deleted file mode 100644
index d629f42248dcd23f019cbb08dfa8d786d2ae9710..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud6/Tall og Typekonvertering.ipynb"
+++ /dev/null
@@ -1,1231 +0,0 @@
-{
- "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",
- "-10\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 * -10\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": 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": 8,
- "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": 9,
- "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": 10,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 11,
- "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": 12,
- "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": 13,
- "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": 36,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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(f'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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 37,
- "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": 37,
- "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": 77,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return '+' + str(landskode) + ' ' + str(telefonnummer)"
- ]
- },
- {
- "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": 76,
- "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": 86,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = 'True'\n",
- "c = 'False'\n",
- "d = '1.5'\n",
- "e = '2.45'\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(a)\n",
- "b = int(True)\n",
- "c = int(False)\n",
- "d = int(1.5)\n",
- "e = int(2.45)"
- ]
- },
- {
- "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": 87,
- "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": 15,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[ 40 80 120 160 200]\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([10,20,30,40,50])\n",
- "\n",
- "print(mult_list_with_x(l,4))"
- ]
- },
- {
- "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": 19,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 19,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "liste = [2.0, 3.0, 4.0, 5.0, 6.0]\n",
- "skalar = 1\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": 20,
- "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": 1,
- "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": 9,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.23456 avrundet til 2 desimaler er: 1.23\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " avrundet_tall = round(tall, desimaler)\n",
- " return avrundet_tall\n",
- "\n",
- "print(f'1.23456 avrundet til 2 desimaler er: {1.23456:.2f}')"
- ]
- },
- {
- "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": 10,
- "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_1/innlevering/stud6/Variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud6/Variabler.ipynb"
deleted file mode 100644
index 8b080e6cfe4146c65991673f63fe0f20ca85e150..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud6/Variabler.ipynb"
+++ /dev/null
@@ -1,593 +0,0 @@
-{
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1 + 1 = 2\n",
- "2 * 5 = 10\n"
- ]
- }
- ],
- "source": [
- "print(f'1 + 1 = {1 + 1}')\n",
- "print(f'2 * 5 = {2 * 5}') # Her er det noe feil. Kan du fikse opp?\n"
- ]
- },
- {
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn = 'Ada'\n",
- "favorittfag = 'LBAS2002'\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}')\n"
- ]
- },
- {
- "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": 12,
- "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",
- "round\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": 16,
- "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.9\n",
- "Areal av sirkelen: 91.6\n",
- "Areal av sylinderen: 451.3\n"
- ]
- }
- ],
- "source": [
- "import math\n",
- "import numpy as np\n",
- "\n",
- "r = 5.4\n",
- "h = 7.9\n",
- "\n",
- "omkrets_sirkel = round(math.tau * r, 1)\n",
- "areal_sirkel = round(np.pi * r**2, 1)\n",
- "\n",
- "areal_sylinder = round(math.tau * r * h + 2 * math.pi * r**2, 1)\n",
- "\n",
- "print(\"Har en sirkel med radius\", r, \"som er grunnflate i en sylinder med høyde\", h)\n",
- "print(\"Omkrets av sirkelen:\", omkrets_sirkel)\n",
- "print(\"Areal av sirkelen:\", areal_sirkel)\n",
- "print(\"Areal av sylinderen:\", areal_sylinder)\n"
- ]
- },
- {
- "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": 17,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "ename": "SyntaxError",
- "evalue": "invalid decimal literal (1274524858.py, line 12)",
- "output_type": "error",
- "traceback": [
- "\u001b[1;36m Cell \u001b[1;32mIn[17], line 12\u001b[1;36m\u001b[0m\n\u001b[1;33m 10kamp = \"gøy\" # variabel kan ikke begynne med tall, kun bokstav eller _\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n"
- ]
- }
- ],
- "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": 24,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn4 = \"Per\"\n",
- "idealalder = 42\n",
- "kundensAlder = 37\n",
- "differanse = idealalder - kundensAlder\n",
- "print(f'{navn4} 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_1/innlevering/stud7/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud7/intro_til_jupyter.ipynb"
deleted file mode 100644
index 59a22e871ad28ba7803c14ce20c0b35cfb86b19f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud7/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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_1/innlevering/stud7/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud7/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud7/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud7/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud7/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index c5c1d8ab65ee0f77f9464cd2cf104f259b111f2f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud7/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1212 +0,0 @@
-{
- "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_1/innlevering/stud7/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud7/variabler.ipynb"
deleted file mode 100644
index ea3d6a92f8b18bb8009be4b04c15981b55a32553..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud7/variabler.ipynb"
+++ /dev/null
@@ -1,589 +0,0 @@
-{
- "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_1/innlevering/stud8/aritmetiske_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud8/aritmetiske_uttrykk.ipynb"
deleted file mode 100644
index 1b84685c80c440783fefeda08c08257db89d8067..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud8/aritmetiske_uttrykk.ipynb"
+++ /dev/null
@@ -1,424 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "4aadc21c",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "# Aritmetiske uttrykk\n",
- "\n",
- "Motivasjon\n",
- "- Datamaskiner er gode til å regne raskt\n",
- " - kan også regne veldig mye _feil_ veldig raskt\n",
- " - hvis vi skriver feilaktige aritmetiske uttrykk"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "d38d3327",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "source": [
- "__Viktig å skrive aritmetiske uttrykk riktig!__"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "be0de705",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "Disposisjon\n",
- "- Skrive tall i Python\n",
- "- Vanlige regneoperatorer\n",
- "- Presedens (regnerekkefølge) og parentesbruk\n",
- "- Uttrykk med variable"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "15d3717a",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Tall i Python\n",
- "|Type tall|Eksempel|Python|Merknad|\n",
- "|:-------|:----------|:------|:-------|\n",
- "|Desimaltall|$3,25$ |3.25| __.__ før desimal|\n",
- "|Lange heltall|1.000.000 |1000000|~oppdeling~|\n",
- "||1,000,000 |1000000|~oppdeling~|\n",
- "|Vitsk.notasjon|$$1.6 \\cdot 10^{12}$$ |1.6e12|1600000000000|\n",
- "||$$1.6 \\cdot 10^{-9}$$ |1.6e-9|0.0000000016|\n",
- "|Komplekse tall|2+3i|(2+3j)|$$2+3\\sqrt{-1}$$|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "7649c678",
- "metadata": {
- "scrolled": true,
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "3.25"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "5145893e",
- "metadata": {},
- "outputs": [],
- "source": [
- "3e2"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "937cc562",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Vanlige regneoperatorer\n",
- "\n",
- "|Operator|Eksempel|Python|Merknad|\n",
- "|:-------|----------|------|-------|\n",
- "|Addisjon|$3+2.5$|3 + 2.5| |\n",
- "|Subtraksjon|$3-2.5$|3 - 2.5| bindestrek |\n",
- "|Multiplikasjon|$3\\cdot2.5$|3 \\* 2.5| \\*|\n",
- "||$(-3)2$|(-3) * 2|Gangetegn _må_ med|\n",
- "|Potens|$2^3$|2 \\*\\* 3|2\\*2\\*2 blir 8|\n",
- "|Divisjon|$7\\colon2$ eller $\\frac{7}{2}$|7 / 2|Blir 3.5|\n",
- "|Heltallsdivisjon|$7\\colon2$|7 // 2|Blir 3|\n",
- "|Modulo|rest av $7\\colon2$|7 % 2|Blir 1|\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "bab7fcaf",
- "metadata": {},
- "outputs": [],
- "source": [
- "-2**2"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "34aa32d0",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "523 // 100"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "907b587c",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "523 % 100"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "9313ef4e",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Bruk av mellomrom i aritmetiske uttrykk\n",
- "- valgfritt å ha mellomrom _rundt_ aritmetiske operatorer\n",
- " - ofte anbefalt for bedre lesbarhet\n",
- "- forbudt med mellomrom _i_ aritmetiske operatorer\n",
- " - ** og // må skrives med symbolene kloss sammen"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "6b1c97c9",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "5//2, 5 // 2, 2**3, 2 ** 3"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "d99e626e",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "5/ /2, 2* *3"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "8f5c98f5",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Operatorpresedens, parentesbruk\n",
- "(Regnerekkefølge)\n",
- "\n",
- "|Operatorer|Presedens|\n",
- "|:-----|:------|\n",
- "|\\*\\*|høy|\n",
- "|\\* / // %|middels|\n",
- "|+ -|lav|"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "4dcd2135",
- "metadata": {
- "slideshow": {
- "slide_type": "subslide"
- }
- },
- "source": [
- "Som i matematikken: bruk parentes for å endre rekkefølge:\n",
- "\n",
- "|Uttrykk|Resultat|Fordi|\n",
- "|:-----|:------|:-----|\n",
- "|5 + 2 \\* 3 |11|ganger først, plusser etterpå|\n",
- "|(5 + 2) \\* 3|21|plusser først, ganger etterpå|\n",
- "|5 \\* 3 \\*\\* 2|45|potenserer først, ganger etterpå|\n",
- "|(5 \\* 3) \\*\\* 2|225|ganger først, potenserer etterpå|\n",
- "|(6 - (5-2) // 3) \\* 4|20|innerste parentes først, // før -|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "97808599",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "(-3)**2"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "070c1d63",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Parentesbruk, forskjell matematikk - Python\n",
- "Det meste er likt, men\n",
- "- Python: kun én type parentes ()\n",
- " - \\{ \\} og \\[ \\] brukes til andre formål i Python\n",
- " - kan __ikke__ brukes til å endre regnerekkefølge\n",
- "- Python trenger () noen flere sted enn matte-uttrykk\n",
- " - f.eks. hvor () unødig i matte-uttrykk pga layout\n",
- "\n",
- "|Matematikk |Python |Merknad |\n",
- "|:-------------------------|:--------------------------|:--------------------------------|\n",
- "|$5^{2+3}$|5 \\*\\* (2 + 3)|parentes i Python|\n",
- "|$\\frac{5+2}{3-2}$|(5 + 2) / (3 - 2)|parentes i Python|\n",
- "|$3\\{2+[0.5-0.7(1+3)+5]-2\\}$|3\\*(2 + (0.5 - 0.7 \\* (1 + 3) + 5) - 2)|kun () i Python|"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "3066cd87",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "(5 + 2) / (3 - 2)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "aef631ef",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Uttrykk med variable\n",
- "\n",
- "|Matematikk |Python|\n",
- "|:-----------------|:----------------------------|\n",
- "|$2x + 3$ |2 \\* x + 3 |\n",
- "|$5^{a+b}$ |5 \\*\\* (a + b) |\n",
- "\n",
- "Operatorer og presedens som før. \n",
- "\n",
- "Variable __MÅ__ få verdi før uttrykk kan kjøres i Python"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "3d01ee0a",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "outputs": [],
- "source": [
- "x = 2.5\n",
- "2 * x + 3"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "411e2ce9",
- "metadata": {
- "slideshow": {
- "slide_type": "slide"
- }
- },
- "source": [
- "## Oppsummering\n",
- "- Tall\n",
- " - 1000000 (~oppdeling~)\n",
- " - 2.35 (desimalpunktum)\n",
- " - 3.25e-15 (vitsk.notasjon)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "7cd265d4",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "source": [
- "- Operatorer: + - * / // % **\n",
- " - ikke utelate *"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "26acfc5e",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "source": [
- "- Uttrykk med variable\n",
- " - Variable __må__ ha fått verdi før kjøring"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "id": "68fd6020",
- "metadata": {
- "slideshow": {
- "slide_type": "fragment"
- }
- },
- "source": [
- "- Presedens og parentesbruk\n",
- " - som i matematikken\n",
- " - Kun én type () \n",
- " - Ekstra parenteser f.eks. horisontal brøkstrek"
- ]
- }
- ],
- "metadata": {
- "celltoolbar": "Slideshow",
- "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.6"
- },
- "rise": {
- "scroll": true,
- "start_slideshow_at": "beginning",
- "theme": "sky"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git "a/\303\270vinger/\303\270ving_1/innlevering/stud8/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud8/intro_til_jupyter.ipynb"
deleted file mode 100644
index db82813a386eab564b18ace58126db25faf09e38..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud8/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,385 +0,0 @@
-{
- "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\")"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "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 et program i jupyter\n",
- "Nå skal programmet stille et spørsmål\n",
- "Hei Ane\n",
- "Da er du 27 år gammel om 5 år\n"
- ]
- }
- ],
- "source": [
- "print(\"Dette er et program i jupyter\") #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\")"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# Variabler mellom kodeblokker"
- ]
- },
- {
- "attachments": {},
- "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": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "message = \"Wow! Dette var kult!\""
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "Kjør så kodeblokken nedenfor:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Wow! Dette var kult!\n"
- ]
- }
- ],
- "source": [
- "print(message)"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# Restarting dersom problemer skulle oppstå"
- ]
- },
- {
- "attachments": {},
- "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": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ane\n"
- ]
- }
- ],
- "source": [
- "navn = input(\"Hva heter du?\")\n",
- "print(\"Hei,\", navn)"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "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*"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**Ditt svar:** Programmering er gøy."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# En advarsel"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "# Til slutt"
- ]
- },
- {
- "attachments": {},
- "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_1/innlevering/stud8/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud8/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud8/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud8/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud8/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 8b38b4f2623302b18040adab47eea2b0b1c7ea7d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud8/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1257 +0,0 @@
-{
- "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"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true
- },
- "source": [
- "## Tutorial: Datatyper"
- ]
- },
- {
- "attachments": {},
- "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"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### Integer"
- ]
- },
- {
- "attachments": {},
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = -10\n",
- "b = 0\n",
- "c = 10"
- ]
- },
- {
- "attachments": {},
- "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": 3,
- "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 : 10"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### Float"
- ]
- },
- {
- "attachments": {},
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "d = 1.2\n",
- "e = -4.2\n",
- "f = 0.0"
- ]
- },
- {
- "attachments": {},
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "5.8\n",
- "14.2\n",
- "-0.0\n"
- ]
- }
- ],
- "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)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### String"
- ]
- },
- {
- "attachments": {},
- "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": 7,
- "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)"
- ]
- },
- {
- "attachments": {},
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "101520\n"
- ]
- }
- ],
- "source": [
- "s4 = '10' + '15' + '20'\n",
- "print(s4)"
- ]
- },
- {
- "attachments": {},
- "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": 13,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "10101010101010101010\n"
- ]
- }
- ],
- "source": [
- "s5 = '10' * 10\n",
- "print(s5)"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "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": 14,
- "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)"
- ]
- },
- {
- "attachments": {},
- "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": 15,
- "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)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### Boolean"
- ]
- },
- {
- "attachments": {},
- "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": 21,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "source": [
- "gjort_oving = False\n",
- "print(f'Jeg har gjort øvingen min: {gjort_oving}')"
- ]
- },
- {
- "attachments": {},
- "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:"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### List"
- ]
- },
- {
- "attachments": {},
- "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": 22,
- "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}')"
- ]
- },
- {
- "attachments": {},
- "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": 23,
- "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}')"
- ]
- },
- {
- "attachments": {},
- "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": 24,
- "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)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Tutorial: Konvertering mellom datatyper"
- ]
- },
- {
- "attachments": {},
- "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": 27,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n"
- ]
- },
- {
- "ename": "TypeError",
- "evalue": "can only concatenate str (not \"int\") to str",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[1;32mIn[27], line 9\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mGratulerer, til sammen er dere \u001b[39m\u001b[39m{\u001b[39;00msum_alder\u001b[39m}\u001b[39;00m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m 7\u001b[0m sum_alder \u001b[39m=\u001b[39m \u001b[39mint\u001b[39m(alder) \u001b[39m+\u001b[39m \u001b[39mint\u001b[39m(alder_mor)\n\u001b[1;32m----> 9\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mGratulerer, til sammen er dere \u001b[39;49m\u001b[39m'\u001b[39;49m \u001b[39m+\u001b[39;49m sum_alder \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m år!\u001b[39m\u001b[39m'\u001b[39m)\n",
- "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
- ]
- }
- ],
- "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!')"
- ]
- },
- {
- "attachments": {},
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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!')"
- ]
- },
- {
- "attachments": {},
- "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()`."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## a)"
- ]
- },
- {
- "attachments": {},
- "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"
- ]
- },
- {
- "attachments": {},
- "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": 36,
- "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": 36,
- "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)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "deletable": false,
- "editable": false,
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## b)"
- ]
- },
- {
- "attachments": {},
- "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": 8,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def legg_til_landskode(telefonnummer, landskode):\n",
- " return '+' + str(landskode) + ' ' + str(telefonnummer)\n",
- " #alternativ løsning: return f'+{landskode} {telefonnummer}'"
- ]
- },
- {
- "attachments": {},
- "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": 9,
- "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))"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true
- },
- "source": [
- "## c)"
- ]
- },
- {
- "attachments": {},
- "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": 4,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = 1.5\n",
- "e = 2.45\n",
- "\n",
- "# Skriv koden din her\n",
- "a = int(a)\n",
- "b = int(b)\n",
- "c = int(c)\n",
- "d = int(d)\n",
- "e = int(e)"
- ]
- },
- {
- "attachments": {},
- "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": 5,
- "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}')"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true
- },
- "source": [
- "## d)"
- ]
- },
- {
- "attachments": {},
- "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": 1,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "# Skriv koden din her\n",
- "def mult_list_with_x(l, x):\n",
- " return list(x * np.array(l))\n"
- ]
- },
- {
- "attachments": {},
- "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": 2,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 2,
- "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)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### Hint"
- ]
- },
- {
- "attachments": {},
- "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`."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Tutorial del 2: avrunding av flyttall"
- ]
- },
- {
- "attachments": {},
- "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": 11,
- "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))"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "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}')"
- ]
- },
- {
- "attachments": {},
- "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."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## e)"
- ]
- },
- {
- "attachments": {},
- "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": 12,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " return round (tall, desimaler)"
- ]
- },
- {
- "attachments": {},
- "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": 13,
- "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_1/innlevering/stud8/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud8/variabler.ipynb"
deleted file mode 100644
index b48257e553e64ca77fbb226d60892f9dee0dec2e..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud8/variabler.ipynb"
+++ /dev/null
@@ -1,581 +0,0 @@
-{
- "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"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Tutorial del 1: variable - grunnleggende intro"
- ]
- },
- {
- "attachments": {},
- "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')"
- ]
- },
- {
- "attachments": {},
- "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"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "hidden": true
- },
- "source": [
- "### Rask intro til f-strenger"
- ]
- },
- {
- "attachments": {},
- "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?"
- ]
- },
- {
- "attachments": {},
- "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, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "navn='Ada'\n",
- "fag='LBAS2002'\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",
- "```"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Tutorial del 2 - bruk av variable i beregninger"
- ]
- },
- {
- "attachments": {},
- "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.**"
- ]
- },
- {
- "attachments": {},
- "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": 18,
- "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.9\n",
- "Areal av sirkelen: 91.6\n",
- "Areal av sylinderen: 451.3\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "import math\n",
- "radius=5.4\n",
- "høyde=7.9\n",
- "omkrets=2*np.pi*radius\n",
- "areal_sirkel=np.pi*radius**2\n",
- "\n",
- "print(\"Har en sirkel med radius\", radius, \"som er grunnflate i en sylinder med høyde\", høyde)\n",
- "print(\"Omkrets av sirkelen:\", round(omkrets,1)) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", round(areal_sirkel,1))\n",
- "print(\"Areal av sylinderen:\", round(omkrets * høyde + 2*areal_sirkel,1))\n",
- "\n"
- ]
- },
- {
- "attachments": {},
- "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",
- "```"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## Tutorial del 3: Navngiving av variable"
- ]
- },
- {
- "attachments": {},
- "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"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {
- "heading_collapsed": true,
- "run_control": {
- "frozen": true
- }
- },
- "source": [
- "## c) Variabelnavn"
- ]
- },
- {
- "attachments": {},
- "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": 5,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er 5 år unna idealalderen\n"
- ]
- }
- ],
- "source": [
- "navn = \"Per\"\n",
- "idealalder = 42\n",
- "kundensalder = 37\n",
- "differanse = idealalder - kundensalder\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_1/innlevering/stud9/intro_til_jupyter.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud9/intro_til_jupyter.ipynb"
deleted file mode 100644
index 0f6c72bf28112ba387e516a1fbbf5a5d3e01ab62..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud9/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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": 3,
- "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 Vendela\n",
- "Da er du 32 å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": 13,
- "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": 14,
- "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": 15,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Vendela\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": [
- "**Ditt svar:** 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_1/innlevering/stud9/lab-1.md" "b/\303\270vinger/\303\270ving_1/innlevering/stud9/lab-1.md"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud9/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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_1/innlevering/stud9/tall_og_typekonvertering.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud9/tall_og_typekonvertering.ipynb"
deleted file mode 100644
index 393e7c7db14817e27ba0ff49d2f2e964793928ce..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud9/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1190 +0,0 @@
-{
- "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": 58,
- "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": 1,
- "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": 2,
- "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": 3,
- "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": 4,
- "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": 5,
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Jeg har gjort øvingen min: False\n"
- ]
- }
- ],
- "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": 7,
- "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": 8,
- "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": 9,
- "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": 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": 11,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Gratulerer, til sammen er dere 1337 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n",
- "Gratulerer, til sammen er dere 50 år!\n"
- ]
- }
- ],
- "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": 15,
- "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": 15,
- "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": 57,
- "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('+', str(landskode1), str(telefonnummer1))\n",
- "print ('+', str(landskode2), str (telefonnummer2)) "
- ]
- },
- {
- "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": 30,
- "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": [
- "a = '1'\n",
- "b = True\n",
- "c = False\n",
- "d = '1.5'\n",
- "e = '2,45'\n",
- "\n",
- "# Skriv koden din her\n",
- "print ('a', 'er nå', 1) \n",
- "print ('b', 'er nå', 1)\n",
- "print ('c', 'er nå', 0)\n",
- "print ('d', 'er nå', 1)\n",
- "print ('e', 'er nå', 2)"
- ]
- },
- {
- "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": 53,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "a er nå 1\n",
- "b er nå True\n",
- "c er nå False\n",
- "d er nå 1.5\n",
- "e er nå (2, 45)\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": 86,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[2.0, 3.0, 4.0, 5.0, 6.0]"
- ]
- },
- "execution_count": 86,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "import numpy as np\n",
- "\n",
- "def mult_list_with_x(l, x):\n",
- " resultat = l*x\n",
- " return resultat\n",
- "l = np.array([1,1.5,2,2.5, 3])\n",
- "\n",
- "list(mult_list_with_x(l,2))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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": 39,
- "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": 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": 42,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1.12\n",
- "1000.0\n"
- ]
- }
- ],
- "source": [
- "# Skriv koden din her\n",
- "def rund_av(tall, desimaler):\n",
- " return round(tall, desimaler)\n",
- "print(rund_av (1.123456,2))\n",
- "print(rund_av (1234.5432, -3))"
- ]
- },
- {
- "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": null,
- "metadata": {
- "hidden": true
- },
- "outputs": [],
- "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_1/innlevering/stud9/variabler.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/stud9/variabler.ipynb"
deleted file mode 100644
index aadf18fb30341f1d96b66d056f7abd5454c1d8e0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/stud9/variabler.ipynb"
+++ /dev/null
@@ -1,582 +0,0 @@
-{
- "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": 5,
- "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? *fikset feilen til 2 * 2 i krøllparentes"
- ]
- },
- {
- "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": 6,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hei, Ada\n",
- "LBAS2002 - interessant!\n",
- "Ha en fin dag, Ada\n",
- "- og lykke til med LBAS2002\n"
- ]
- }
- ],
- "source": [
- "print('Hei, Ada')\n",
- "print('LBAS2002 - interessant!')\n",
- "print('Ha en fin dag, Ada')\n",
- "print('- og lykke til med LBAS2002')"
- ]
- },
- {
- "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": 3,
- "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": 7,
- "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 numpy as np\n",
- "import math\n",
- " \n",
- "print(\"Har en sirkel med radius\", 5.4, \"som er grunnflate i en sylinder med høyde\", 7.9)\n",
- "print(\"Omkrets av sirkelen:\", math.tau * 5.4) #tau er det samme som 2 pi\n",
- "print(\"Areal av sirkelen:\", np.pi * 5.4**2)\n",
- "print(\"Areal av sylinderen:\", math.tau * 5.4 * 7.9 + 2 * math.pi * 5.4 ** 2)"
- ]
- },
- {
- "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": 45,
- "metadata": {
- "hidden": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Per er (42, -37) år unna ideal_alderen\n"
- ]
- }
- ],
- "source": [
- "navn = 'Per'\n",
- "ideal_alder = 42\n",
- "kunde_alder = 37 \n",
- "differanse = ideal_alder, - kunde_alder\n",
- "\n",
- "print(f'{navn} er {differanse} år unna ideal_alderen') "
- ]
- }
- ],
- "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_1/innlevering/zip_for_download.ipynb" "b/\303\270vinger/\303\270ving_1/innlevering/zip_for_download.ipynb"
deleted file mode 100644
index 1b1622f5a782d93d165f7fb43dd13b1e89e8e35d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_1/innlevering/zip_for_download.ipynb"
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Adding file: ./lab/lab_1/variabler.ipynb\n",
- "Adding file: ./lab/lab_1/intro_til_jupyter.ipynb\n",
- "Adding file: ./lab/lab_1/lab-1.md\n",
- "Adding file: ./lab/lab_1/tall_og_typekonvertering.ipynb\n",
- "Adding file: ./lab/lab_1/lister.jupynb\n"
- ]
- }
- ],
- "source": [
- "# How to use this file:\n",
- "# 1. Copy the file and paste in your root folder (same level as shared)\n",
- "# 2. Update the value of src_path and filename (below) depending on what you want to zip\n",
- "# 3. Run the content of the cell\n",
- "\n",
- "src_path = 'lab/lab_1'\n",
- "filename = 'lab_1.zip'\n",
- "\n",
- "import glob\n",
- "import zipfile\n",
- "import os\n",
- "\n",
- "# Create target-folders if not exist:\n",
- "subfolder=filename.split('.')[0]\n",
- "target_path = \"./\"+src_path+\"/\"\n",
- "target_subfolder = target_path+subfolder\n",
- "\n",
- "# Check whether the specified path exists or not\n",
- "isPathExist = os.path.exists(target_path)\n",
- "\n",
- "if not isPathExist:\n",
- " print(\"Directory do not exist!\")\n",
- "\n",
- "isTargetZipExist = os.path.exists(filename)\n",
- "if isTargetZipExist:\n",
- " os.remove(filename)\n",
- "\n",
- "# zip files\n",
- "files = glob.glob(\"./\"+src_path+\"/*.*\")\n",
- "for file in files:\n",
- " print('Adding file:',file)\n",
- " \n",
- " with zipfile.ZipFile(filename, mode=\"a\") as archive:\n",
- " archive.write(file)"
- ]
- },
- {
- "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.10.8"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git "a/\303\270vinger/\303\270ving_2/stud1/.DS_Store" "b/\303\270vinger/\303\270ving_2/stud1/.DS_Store"
deleted file mode 100644
index fee4843f77bb5c65d77cb4a0159837960705d9b5..0000000000000000000000000000000000000000
Binary files "a/\303\270vinger/\303\270ving_2/stud1/.DS_Store" and /dev/null differ
diff --git "a/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb" "b/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb"
deleted file mode 100644
index 0ae731916764d7ddd3b060bc6bceed93fd3a97e6..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud1/aarstider.ipynb"
+++ /dev/null
@@ -1,159 +0,0 @@
-{
- "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"
deleted file mode 100644
index c3ece5e56a50c6649070541838681d6bd4edbd9b..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud1/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,368 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud1/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 6bd9fdc6ec962118f8759126c76792355c29dac5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud1/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,506 +0,0 @@
-{
- "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"
deleted file mode 100644
index ff604303935103c0c0f2ee4526cc16db608c4f30..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud1/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,407 +0,0 @@
-{
- "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"
deleted file mode 100644
index 69a43c898b1c195a9dba920e4033da73a161870c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud10/aarstider.ipynb"
+++ /dev/null
@@ -1,176 +0,0 @@
-{
- "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"
deleted file mode 100644
index c8a0b063c1a8ff6ec180f0611a2e5871c2ffad8e..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud10/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,652 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud10/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 6046d20b673d2890d249d43ce8a631923db324cc..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud10/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,601 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6843a2cc6140dd6ee5a07bb6ced7defa2f3fb617..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud10/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,1476 +0,0 @@
-{
- "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"
deleted file mode 100644
index e5a78dff70436239de5a545a8bded9eb1dcedcd5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud11/aarstider.ipynb"
+++ /dev/null
@@ -1,146 +0,0 @@
-{
- "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"
deleted file mode 100644
index 3f87180e5008b429584759251048e2cfd21bc766..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud11/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,362 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud11/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 53020f849e7390bce19fb56cbc45a840df083e4f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud11/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,484 +0,0 @@
-{
- "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"
deleted file mode 100644
index f80ec3151cddc6026764860bb2cfdc95c1e221e9..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud11/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,368 +0,0 @@
-{
- "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"
deleted file mode 100644
index 59a22e871ad28ba7803c14ce20c0b35cfb86b19f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud12/intro_til_jupyter.ipynb"
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "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"
deleted file mode 100644
index 548bb68a31f447650b3ef3735de099a8e0c39dd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud12/lab-1.md"
+++ /dev/null
@@ -1,14 +0,0 @@
-# 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"
deleted file mode 100644
index c5c1d8ab65ee0f77f9464cd2cf104f259b111f2f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud12/tall_og_typekonvertering.ipynb"
+++ /dev/null
@@ -1,1212 +0,0 @@
-{
- "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"
deleted file mode 100644
index ea3d6a92f8b18bb8009be4b04c15981b55a32553..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud12/variabler.ipynb"
+++ /dev/null
@@ -1,589 +0,0 @@
-{
- "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"
deleted file mode 100644
index a797c742400b31e14bf0c8a379764f82e1e98b1c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud13/aarstider.ipynb"
+++ /dev/null
@@ -1,175 +0,0 @@
-{
- "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"
deleted file mode 100644
index 4600b0e7beac40e6df1664dd0309d627eca7c258..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud13/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,362 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud13/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 14b51a554c2152f18f7dfb19c8c0fb1cea0c32b2..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud13/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,488 +0,0 @@
-{
- "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"
deleted file mode 100644
index 7a0975e485fefe2a6d19123f3f1babc13d678a15..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud13/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,398 +0,0 @@
-{
- "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"
deleted file mode 100644
index 4b0906e54d751b40df53d3ab7fd216dc4777157d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud14/aarstider.ipynb"
+++ /dev/null
@@ -1,145 +0,0 @@
-{
- "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"
deleted file mode 100644
index 17b310d607e7e467eaf36e93e95bb548eb4f9ae1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud14/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,363 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud14/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index a58cb3e2d0798d63b8ded8a65a882944fd338bac..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud14/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,480 +0,0 @@
-{
- "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"
deleted file mode 100644
index 832f26f7b3843465b8a7893d89c8adec1e96517d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud14/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,399 +0,0 @@
-{
- "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"
deleted file mode 100644
index c8402a70a99f19e8983aebfaa875eaad10259e05..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud15/Funksjoner og Kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,366 +0,0 @@
-{
- "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"
deleted file mode 100644
index d1678d4131e6e486a2b6155a630e6586d621ccc0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud15/Logiske Operatorer Uttrykk.ipynb"
+++ /dev/null
@@ -1,505 +0,0 @@
-{
- "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"
deleted file mode 100644
index 16b5a0a4ba485568ab43115ac44f5dfab37f331d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud15/Ulike Typer if-setninger.ipynb"
+++ /dev/null
@@ -1,392 +0,0 @@
-{
- "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"
deleted file mode 100644
index f7442ccf8a44faedb7347397fb0c09f7140e2cee..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud15/\303\205rstider.ipynb"
+++ /dev/null
@@ -1,163 +0,0 @@
-{
- "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"
deleted file mode 100644
index 89fa9c9eff71d26b896d36d7cdaf06aaf3af32d5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud16/aarstider.ipynb"
+++ /dev/null
@@ -1,141 +0,0 @@
-{
- "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"
deleted file mode 100644
index d34ce187006fac45b36153c1adda2685b2f2f97e..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud16/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,360 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud16/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 6eea19af85e8e17823d5c225fd32b3c6a8193b46..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud16/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,479 +0,0 @@
-{
- "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"
deleted file mode 100644
index 4c226851d907bfb1f6fbf0b2058aa864b8403eb4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud16/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,392 +0,0 @@
-{
- "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"
deleted file mode 100644
index ee9ba52c4a6848fc283403fff1908c793ad70aeb..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud17/aarstider.ipynb"
+++ /dev/null
@@ -1,162 +0,0 @@
-{
- "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"
deleted file mode 100644
index 9b0f7cdd7e2aeb6429bc1ff0e9857274bf1238bb..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud17/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,354 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud17/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index f43d095b038f569a7728f16254ac13a6bc802bd1..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud17/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,498 +0,0 @@
-{
- "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"
deleted file mode 100644
index d6188afa9c5f89d6f7dd514663d04fa66090c0ca..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud17/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,377 +0,0 @@
-{
- "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"
deleted file mode 100644
index ec35a8212a6ed7af4b7f11bfeaed9337c0efd7aa..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud18/aarstider.ipynb"
+++ /dev/null
@@ -1,150 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6213fb2533177720f0eaf7531d1a1209422def01..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud18/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,360 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud18/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 39bf1ceda056ef36866b0767aa4b473148854070..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud18/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,470 +0,0 @@
-{
- "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"
deleted file mode 100644
index c3b81d8b07b385eac0d738a0c02889b94e47d0a5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud18/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,395 +0,0 @@
-{
- "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"
deleted file mode 100644
index 283652fd1834d18f5b8faeae40cddf22997e036f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud19/aarstider.ipynb"
+++ /dev/null
@@ -1,111 +0,0 @@
-{
- "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"
deleted file mode 100644
index f2958d927597709f234a215d99e8ca0262125751..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud19/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,326 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud19/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index ec15effe94d8b3084fac81519e61ebebc2ebf875..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud19/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,454 +0,0 @@
-{
- "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"
deleted file mode 100644
index e595a3ae8f429f3fd04e9eb90f3efcefd7567823..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud19/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,369 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6c37f600183a6b1ed7b15a0c3c8d0c5eef9ce6d7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud2/aarstider.ipynb"
+++ /dev/null
@@ -1,165 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6d69342e1481adfbef0b6a7380c0654bf9beeed4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud2/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,357 +0,0 @@
-{
- "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"
deleted file mode 100644
index 24cc7c523599e52c79ea53485e2c79a3e81a306b..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud2/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,478 +0,0 @@
-{
- "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"
deleted file mode 100644
index eabc9a630daedf66322a38bfbac7f871ba040f9f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud2/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,392 +0,0 @@
-{
- "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"
deleted file mode 100644
index 8aa21b8b53334268981323a4a72e217bb85cbc07..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud20/aarstider.ipynb"
+++ /dev/null
@@ -1,139 +0,0 @@
-{
- "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"
deleted file mode 100644
index f409aaf4d7a48319ab3dcbe487a2c15f1fb44376..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud20/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,372 +0,0 @@
-{
- "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"
deleted file mode 100644
index 96fc672a5c2cce8e9664c59f177d677bc7f67c26..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud20/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,456 +0,0 @@
-{
- "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"
deleted file mode 100644
index 8d08755943277ec3bfcf560886c87d367ac963f0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud20/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,383 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6c37f600183a6b1ed7b15a0c3c8d0c5eef9ce6d7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud3/aarstider.ipynb"
+++ /dev/null
@@ -1,165 +0,0 @@
-{
- "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"
deleted file mode 100644
index 6d69342e1481adfbef0b6a7380c0654bf9beeed4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud3/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,357 +0,0 @@
-{
- "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"
deleted file mode 100644
index 24cc7c523599e52c79ea53485e2c79a3e81a306b..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud3/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,478 +0,0 @@
-{
- "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"
deleted file mode 100644
index eabc9a630daedf66322a38bfbac7f871ba040f9f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud3/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,392 +0,0 @@
-{
- "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"
deleted file mode 100644
index 90e73c4f76e2f6b46a4cad2daf06cf059b12d22a..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud4/aarstider.ipynb"
+++ /dev/null
@@ -1,142 +0,0 @@
-{
- "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"
deleted file mode 100644
index 9a144dec39d591e2b5f0f9e3e6647c9b012ca3f5..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud4/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,351 +0,0 @@
-{
- "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"
deleted file mode 100644
index 55f2597b640090be7f8482515b58f50f15ea5c68..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud4/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,487 +0,0 @@
-{
- "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"
deleted file mode 100644
index 51219f9de32f5c11b5afae84f4eb32f20ebfd504..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud4/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,404 +0,0 @@
-{
- "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"
deleted file mode 100644
index b8b3c0410e4356e0ea98a17e2699d514024e038c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud5/aarstider.ipynb"
+++ /dev/null
@@ -1,157 +0,0 @@
-{
- "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"
deleted file mode 100644
index 73645bc6666a8e7df96ce153485ebc59bc6c3ee6..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud5/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,361 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud5/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 2c89086cd9e010ccb70254527d84bc725419d6d0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud5/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,481 +0,0 @@
-{
- "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"
deleted file mode 100644
index 278f4ffaf824ea6259a0a078a1b318ea418d29f0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud5/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,401 +0,0 @@
-{
- "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"
deleted file mode 100644
index 835896b899b3bde5f6d61729e6c08cea47c110cf..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud6/aarstider.ipynb"
+++ /dev/null
@@ -1,137 +0,0 @@
-{
- "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"
deleted file mode 100644
index b4bfbecf1ec636a43f5c7caa39d954f70674d958..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud6/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,644 +0,0 @@
-{
- "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"
deleted file mode 100644
index 066555f67a3fd459ab05210abd884a4dddaacba0..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud6/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,652 +0,0 @@
-{
- "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"
deleted file mode 100644
index adc700d1bf886c3f5e6a4933ba3261835e3385dd..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud6/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,1416 +0,0 @@
-{
- "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"
deleted file mode 100644
index 457f44d9ba0d04288418152f9802440edf2abb20..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/.vscode/settings.json"
+++ /dev/null
@@ -1,3 +0,0 @@
-{
- "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"
deleted file mode 100644
index ae5c1036d01fae223ea32f19cbb7762b9107f5f8..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/aarstider.ipynb"
+++ /dev/null
@@ -1,155 +0,0 @@
-{
- "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"
deleted file mode 100644
index 74638960c693b3b440a19f72d204b46a95c0c9f4..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,363 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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/stud7/lab-2.zip" "b/\303\270vinger/\303\270ving_2/stud7/lab-2.zip"
deleted file mode 100644
index 458923d4a2b7e958d6acd28d7325c5295a598d47..0000000000000000000000000000000000000000
Binary files "a/\303\270vinger/\303\270ving_2/stud7/lab-2.zip" and /dev/null differ
diff --git "a/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb" "b/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb"
deleted file mode 100644
index 531619ab231b0274720368d6170e4ce7ea452bba..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,465 +0,0 @@
-{
- "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"
deleted file mode 100644
index 1f118e511a7490e276445330fcd481686043bd34..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/oving2.py"
+++ /dev/null
@@ -1,92 +0,0 @@
-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"
deleted file mode 100644
index 818759fb776f5a3b5f5443099cc35a819f547053..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud7/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,396 +0,0 @@
-{
- "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"
deleted file mode 100644
index 5497b7fed2b3bb6490397005d001eb03030e445f..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud8/aarstider.ipynb"
+++ /dev/null
@@ -1,233 +0,0 @@
-{
- "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"
deleted file mode 100644
index f754e87cb4aebc190ece0f3e4a573802162231b9..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud8/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,362 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud8/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index a069c0f3bc32f298edb6c1b6535987c705f6acb7..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud8/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,616 +0,0 @@
-{
- "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"
deleted file mode 100644
index c190075070ba344e64ae6950124b9ba21232225d..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud8/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,433 +0,0 @@
-{
- "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"
deleted file mode 100644
index 44d8e24d73b65b8ca95182247ad00bf8fa7de2ec..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud9/aarstider.ipynb"
+++ /dev/null
@@ -1,155 +0,0 @@
-{
- "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"
deleted file mode 100644
index c35ffe9fd71a0c2d5efb0a39990438dcfbe279e6..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud9/funksjoner_og_kalkulasjoner.ipynb"
+++ /dev/null
@@ -1,371 +0,0 @@
-{
- "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"
deleted file mode 100644
index d26f4eb099ea3e4e01a308312351dc0e0b4e126c..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud9/lab-2.md"
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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"
deleted file mode 100644
index 9dda0e71b0dbf2afedaa68906b79a7fe6303ffc9..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud9/logiske_operatorer_uttrykk.ipynb"
+++ /dev/null
@@ -1,488 +0,0 @@
-{
- "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"
deleted file mode 100644
index 4ef1e8b18fc50e167044ec12b23b1e67da6854a3..0000000000000000000000000000000000000000
--- "a/\303\270vinger/\303\270ving_2/stud9/ulike_typer_if_setninger.ipynb"
+++ /dev/null
@@ -1,383 +0,0 @@
-{
- "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
-}