"- hvordan skrive og utføre noen enkle programmer i Python, \n",
"- se på to forskjellige måter å gjøre det på\n",
" - JupyterLab / Jupyter Notebook\n",
" - Thonny, en såkalt IDE (integrert utviklingsmiljø)\n"
]
},
{
"cell_type": "markdown",
"id": "08b0b43c",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Det vi skal lære om Python er\n",
"- Noen datatyper\n",
" - tall\n",
" - strenger (tekst)\n",
" - tupler (flere data samlet)\n",
"- Input, output\n",
"- Vanlige regneoperasjoner med Python\n",
"- Lagre resultater i variabler med *tilordningsoperatoren* =\n",
"- Dele opp et program i ved hjelp av funksjoner som vi kan så *kalle* (utføre)\n",
"- Veldig kort og numpy og matplotlib"
]
},
{
"cell_type": "markdown",
"id": "900b35c9-be98-4996-96de-b2564242863f",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Først: Hva er Python?"
]
},
{
"cell_type": "markdown",
"id": "1e78cebb-faa5-4b7a-b44b-034b960d7b17",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"- Python er et programmeringsspråk:\n",
"- Ligner litt på \"vanlige\" språk, skal gjøre det lettere for oss å lage programmer\n",
"- Mye mer firkantet, dvs vi må følge skrivereglene (gramatikken) nøye\n"
]
},
{
"cell_type": "markdown",
"id": "cfe59edb-3b98-40bd-873e-58f1e3617bb5",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Hvordan programmerer vi, rent praktisk, i Python?"
]
},
{
"cell_type": "markdown",
"id": "494b6b22-882d-412d-90b6-cbe137820bf2",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"- Vi skriver programmet som ren tekstfil, kalt *kildekode*\n",
"- Vi får Python-tolkeren (et program) til å lese kildekoden og utføre den:\n",
" - linje for linje\n",
" - gjør det om til *maskinkode* som datamaskinen utfører (litt forenklet forklart) \n",
"\n",
"For å gjøre dette skal vi se på to dataprogrammer som er laget for dette:\n",
"- JupyterLab / Jupyter Notebook\n",
"- Thonny, en såkal IDE"
]
},
{
"cell_type": "markdown",
"id": "19fa7619-19c8-4b38-aa7a-ed99da814e49",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Hvordan ser et program ut?\n",
"En vanlig struktur på et program er\n",
"- input\n",
"- prosessering/beregning\n",
"- output\n",
"\n",
"### Eksempel: Andregradsformelen, også kjent som \"abc-formelen\"\n",
"VI kjører programmet ved å klikke i cellen, og trykke Ctrl-Enter"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c9da3b94-2639-4f94-b196-735ab537de74",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"# Input, her er de hardkodet\n",
"a = 1\n",
"b = -2\n",
"c = -3\n",
"\n",
"# Utregninger med mellomlagring\n",
"D = b**2 - 4 * a * c\n",
"d = D**0.5\n",
"\n",
"x1 = (-b + d)/(2*a)\n",
"x2 = (-b - d)/(2*a)\n",
"\n",
"# Output\n",
"print(x1)\n",
"print(x2)\n"
]
},
{
"cell_type": "markdown",
"id": "c12cfa8e-75ad-47f3-a5d7-6ac0a2950ad2",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"I koden over, kan du se hvor vi har\n",
"- input?\n",
"- utregninger?\n",
"- lagring av verdier i variabler?\n",
"- output?\n",
"- kommentarer i koden?\n"
]
},
{
"cell_type": "markdown",
"id": "be663932-0cae-455b-9c02-459330a3efed",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Litt mer strukturering av koden over\n",
"### Dårlig praksis:\n",
"Hvis jeg ønsker å regne ut løsningene til flere andregradsligninger, så kan\n",
"jeg bare endre på tilordningen av variablene, og kjøre programmet på nytt.\n",
"\n",
"**Det er dumt å måtte endre på selve koden, når det bare er input som endres**\n",
"\n",
"### GOD PRAKSIS:\n",
"**Input som varierer leses inn av programmet**\n",
"\n",
"Under skal vi endre koden over, slik at vi henter verdiene ved kjøring, og ikke trenger endre koden\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b52d5266-5fce-4c96-ab93-60612e555641",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"# Modifisert kode, med bruk av input\n"
]
},
{
"cell_type": "markdown",
"id": "645005e8",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Datatyper: Tall\n",
"- Heltall: Skrives rett frem uten komma. Det er ingen begrensning på antall siffer (sort of...)\n",
"- Flyttall, desimaltall. Kan ikke være vilkårlig store"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0a5dac0",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"heltall = 42\n",
"print(heltall ** 100)\n",
"\n",
"x = 4.37\n",
"print(x**100)\n",
"\n",
"y = 1.23e-3\n",
"print(y)"
]
},
{
"cell_type": "markdown",
"id": "635fb594",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Datatype: Tekst\n",
"Kanskje vi tenker mest på at data er tall? Men tekst er også data.\n",
"\n",
"For å angi tekst som data, så bruker vi *fnutter* for å angi at noe er tekst, og ikke kommandoer som Python skal tolke:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5a34108-3797-4f50-98a3-45f0a3e8c889",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"navn = 'Dag Olav Kjellemo'\n",
"\n",
"# Vi kan også bruke dobbel-fnutter, som fungerer akkurat som enkle fnutter:\n",
"emne = \"ITGK TDT4110\"\n",
"\n",
"# Eller triple-dobbelfnutter. Denne er mer \"special\". Den kan skrives over flere linjer\n",
"enLitenTekst = \"\"\"25. august 2023\n",
"Jeg foreleser ITGK.\n",
"\n",
"Hilsen Dag Olav\"\"\"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "012e1f23-4bb6-49f3-ba26-ffd23af4b3f1",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Litt om funksjoner\n",
"- input og print er navn på *funksjoner* i Python, som utfører gitte oppgaver (som navnet tilsier)\n",
"- Vi kan *gjenbruke* funksjoner uten å måtte skrive koden på nytt\n",
"- Funksjoner gjør det også lettere å se hva koden gjør\n",
"- Vi *kaller* (utfører) funksjoner ved å skrive navnet, etterfulgt av paranteser.\n",
"- Vi \"mater\" funksjonene ved å angi inputverdier inne i parantesene. \n",
" - dette kalles for *argumentene* til funksjonen\n",
"\n",
"Det finnes en masse forskjellige ferdige funksjoner i Python, men de fleste er ikke tilgjengelig uten at vi *ber om det*. Vi laster inn disse med nøkkelordet **import**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7c1ab5ea-b890-4679-8a08-564f444627ce",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"import math # Standard matte-ting\n",
"\n",
"# math inneholder f.eks. en del trigonometriske funksjoner og en (tilnærmet) verdi for pi\n",
"print(math.pi) # NB! pi er ikke en funksjone, men et tall\n",
"print(math.sin(math.pi/2))"
]
},
{
"cell_type": "markdown",
"id": "455b5594-5d98-4cf2-8670-76f5cef45503",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Definere egne funksjoner\n",
"La oss lage en litt unyttig funksjon, som skriver ut en slags overskrift.\n",
"\n",
"Funksjoner definerer vi ved å begynne å skrive \"def\" i koden:"
"- *nøkkelordet* **def** signaliserer at vi skal definere en *funksjon*\n",
"- Funksjonsnavnet er **banner**\n",
"- Funksjonsnavnet etterfølges alltid av et parantespar ( )\n",
"- Inne i parantesen står det hva som skal være *input* til funksjonen. Her er det ingen input ennå.\n",
"- Python bruker kolon (:) og innrykk av kodenlinjene etterpå for å skille ut en *kodeblokk*\n",
"- Funksjonsdefinisjonen slutter der hvor det ikke lenger er innrykk i koden.\n"
]
},
{
"cell_type": "markdown",
"id": "e665b2ef-6d75-4c66-94c6-c39e882a2ee3",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Kall av funksjoner\n",
"- **Når vi definerer en funksjon, så blir den ikke utført, bare lagret for bruk\n",
"- Vi *kaller* en funksjon ved å bruke funksjonsnavnet med parantes:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "07ee629c-8da2-4e82-91d0-459ab685acc8",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"banner()"
]
},
{
"cell_type": "markdown",
"id": "863f52cc-cb76-415a-a378-3b16bf87c21c",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"La oss gjøre funksjonen litt mer nyttig. Vi vil kunne sende den teksten den\n",
"skal skrive. Da må den ha en *parameter*. Parameteren er et variabelnavn som gjelder bare inne i funksjonen, som lagrer argumentet som sendes til funksjonen når vi kaller den."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "75b32642-7f4c-4af9-a2ec-ba84ca1f6286",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def banner_med_input(tekst):\n",
" tekst_lengde = len(tekst) # en funksjon som gir antall tegn i tekst.\n",
" banner_lengde = tekst_lengde + 2*10\n",
" print(\"*\" * banner_lengde)\n",
" print(\"*\" * 10 + tekst + \"*\" * 10)\n",
" print(\"*\" * banner_lengde)\n",
" \n",
"# La oss kalle funksjonen \n",
"banner_med_input(\"ITGK - TDT4110\")"
]
},
{
"cell_type": "markdown",
"id": "6b76c47b-0159-42d1-87a6-13894273f1e0",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Et eksempel til på bruk av funksjoner\n",
"La oss skille ut utregningen for abc-formelen i en egen *funksjon*. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b7c8646-246e-426a-8704-1c5bd710a849",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def abc_formel(a,b,c): # ikke abc-formel. Bindestrek tolkes som minus.\n",
" D = b**2 - 4 * a * c\n",
" d = D**0.5\n",
"\n",
" x1 = (-b + d)/(2*a)\n",
" x2 = (-b - d)/(2*a)\n",
" return x1, x2 # Returnerer begge verdiene som et 2-tuppel\n",
"\n",
"# La oss kalle funksjonen over:\n",
"print(abc_formel(1,4,4)) \n",
"\n",
"# Samme som over, men vi lagrer løsningene i to variabler:\n",
"løsning1, løsning2 = abc_formel(1,4,4)\n",
"\n",
"print(løsning1, løsning2)"
]
},
{
"cell_type": "markdown",
"id": "bf213854-a3f7-4677-a283-50c5d0056b73",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Viktige ting å legge merke til,\n",
"- *nøkkelordet* **def** signaliserer at vi skal definere en *funksjon*\n",
"- Funksjonsnavnet er **abc_formel**\n",
"- Funksjonsnavnet etterfølges alltid av et parantespar ( )\n",
"- Inne i parantesen står det hva som skal være *input* til funksjonen,\n",
"- Python bruker kolon (:) og innrykk av kodenlinjene etterpå for å skille ut en *kodeblokk*\n",
"- *nøkkelordet* **return** gjør at funksjonen avsluttes, og to verdier *returneres* til der hvor funksjonen ble kalt\n"
]
},
{
"cell_type": "markdown",
"id": "52e7b012-bb0e-4e39-8730-b00345b1872c",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Numpy og Matplotlib\n",
"To *bibliotek* av funksjoner som vi skal bruke mye i emnet. Disse må importeres før bruk.\n",
"Num\n",
"\n",
"- Numpy er laget for å jobbe matematisk/numerisk med data. Sentralt er *arrays* (vektorer, matriser).\n",
"\n",
"- Matplotlib brukes til å visualisere data (forskjellige typer grafer og figurer)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "63bae919-66d7-468c-a509-168b979ba562",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"import numpy as np # np blir et alias, for få litt kortere skrivemåte\n",
"\n",
"from matplotlib import pyplot as plt # Vi importerer funksjonen pyplot fra biblioteket matplotlib, og slik at vi IKKE trenger å skrive\n",
" # matplotlib.pyplot, kun plt\n",
"\n",
"def f(x): # En egendefinert funksjon som heter f, med en input parameter x\n",
" return x*x - 2*x - 3 # Den regner ut verdien til et andregradsuttrykk, og returnerer det \"på direkten\"\n",
"\n",
"xs = np.linspace(-3, 5, 20) # genererer en array med 20 tall jevnt fordelt fra -3 til 5\n",
"ys = f(xs) # regner ut funksjonsverdien til alle de 20 verdiene, og lagrer resultatet i en ny array\n",
" # som lagres i variabelen ys\n",
"print(\"x-verdiene:\", xs) \n",
"print(\"y-verdiene:\", ys)\n",
"\n",
"plt.plot(xs,ys) # Den aller enkelste måten å lage et plot på i matplotlib\n",
"plt.show()\n"
]
},
{
"cell_type": "markdown",
"id": "ffa9cdc9-4547-42f8-b519-127507a6eb99",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Tilgang til hjelp i Python\n",
"I tillegg til ressursene vi har i Blackboard, finnes det uttallige nettressurser, f.eks. w3schools.\n",
"\n",
"Legg også merke til hjelp som finnes i verktøyene vi bruker for å skrive kode. Det er mer hjelp i f.eks. Thonny (og enda mer i f.eks. Visual Studio Code, PyCharm etc).\n",
"\n",
"NB! På eksamen er ikke disse hjelpemidlene tilgjengelige. Det kan også være en fordel for læringen at en må øve seg på å huske ting, og ikke få alt foreslått før man har rukket å tenke selv. \n",
"\n",
"Hvis kan bruke help-funksjonen i Python til å få en beskrivelse av funksjoner"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "473fd5a2-8a64-4bcd-9656-0b95de998232",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"help(print)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c917cb33-3785-4782-8a80-fc8510a3e216",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"help(math.sin)"
]
},
{
"cell_type": "markdown",
"id": "5c1323bd-d05d-4c32-87e8-17fa741b1129",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Hva skal dere gjøre kommende uke:\n",
"- Se videoer og gå gjennom tilhørende notatbøker\n",
"- Begynn å jobbe med Øving 1 som kommer ganske snart.\n",
"\n",
"# Hva du bør kunne om en uke: \n",
"Det du bør beherske etter at du har jobbet deg gjennom uke 34-stoffet, er\n",
"- Aritmetiske uttrykk med regnerekkefølge i Python (se FP_00)\n",
- input og print er navn på *funksjoner* i Python, som utfører gitte oppgaver (som navnet tilsier)
- Vi kan *gjenbruke* funksjoner uten å måtte skrive koden på nytt
- Funksjoner gjør det også lettere å se hva koden gjør
- Vi *kaller* (utfører) funksjoner ved å skrive navnet, etterfulgt av paranteser.
- Vi "mater" funksjonene ved å angi inputverdier inne i parantesene.
- dette kalles for *argumentene* til funksjonen
Det finnes en masse forskjellige ferdige funksjoner i Python, men de fleste er ikke tilgjengelig uten at vi *ber om det*. Vi laster inn disse med nøkkelordet **import**
La oss gjøre funksjonen litt mer nyttig. Vi vil kunne sende den teksten den
skal skrive. Da må den ha en *parameter*. Parameteren er et variabelnavn som gjelder bare inne i funksjonen, som lagrer argumentet som sendes til funksjonen når vi kaller den.
I tillegg til ressursene vi har i Blackboard, finnes det uttallige nettressurser, f.eks. w3schools.
Legg også merke til hjelp som finnes i verktøyene vi bruker for å skrive kode. Det er mer hjelp i f.eks. Thonny (og enda mer i f.eks. Visual Studio Code, PyCharm etc).
NB! På eksamen er ikke disse hjelpemidlene tilgjengelige. Det kan også være en fordel for læringen at en må øve seg på å huske ting, og ikke få alt foreslått før man har rukket å tenke selv.
Hvis kan bruke help-funksjonen i Python til å få en beskrivelse av funksjoner
