<jupyter_start><jupyter_text>Programmering  Hvorfor skal elevene lære programmering? Generelle grunner* Grunnleggende forståelse for IKT (almenndannelse)* Viktig nasjonal interesse med økt rekruttering til IKT  Pedagogiske og didaktiske grunner* Lettere å arbeide med realistiske problemstillinger* Utfordrer elevene til å tenke systematisk* Utvikler logisk forståelse og tankegang  Vanlig faglig problemstilling i grunnskolen:* Vei fart tid* Lineære funksjonerLitt kjedelig     ![figur 1][./bilder/vei_fart_tid_linear.png] * Ikke veldig spennende* Hva skjer når farta ikke er konstant?* Svar med klassisk matematikk krever gjerne integrasjon / differensiallikninger* Programmering kan gjøre problemet tilgjengelig for (flinke) elever tidlig.* Veldig plagsomt at klassisk matematikk ikke gjør problemet mer tilgjengelig Vi skal se på en løsning med konstant akselerasjon senere - fra dette kan man også byggemodeller der akselerasjonen varierer!  Andre aktuelle anvendelser* Programmere og kalibrere måleinstrumenter i naturfag og kunst og håndtverk (arduino, raspberry pi)* Programmere og kalibrere aktuatorer i naturfag og kunst og håndtverk      (arduino, raspberry pi)* Jobbe med store datasett                  (eksempler på datasett: https://www.kaggle.com/datasets)* Muligheter for å kombinere naturfag, matematikk, kunst og håndtverk i større grad* Mer tverrfaglig arbeid!* Programmering som verktøy i alle fag  Et enkelt programÅ se på dette programmet har to hovedmål* Vite hvordan du kan kjøre python-programmer* Vite hvordan du skriver ut data (tall, tekst etc) fra python ut til skjermen* Bli kjent med datatypen for tekst: *strenger*<jupyter_code>print('Hello, world!')<jupyter_output>Hello, world!<jupyter_text>* Funksjonen `print` skriver teksten `'Hello, world!'` ut til skjermen. * Hermetegnene forteller Python at innholdet er tekst (en streng). * I programmering kaller vi data som skal være tekst for **strenger**.  Et program som behandler tall<jupyter_code># Regn ut arealet av et pararellogram med lengde l og bredde h
l = 8
h = 3.5

A = l*h
print(A)<jupyter_output>28.0<jupyter_text>Programmet regner ut arealet av et pararellogram - vi kan tenke på programmet som en oppskrift for dette.* Den øverste linjen er en kommentar. Den blir ignorert av datamaskinen og skal gjøre programmet lettere å lese for mennesker* `l` og `h` er *variabler* av typen `int` (heltall) og `float` (et "desimaltall").En variabel kan du tenke på som en boks som inneholder data, og navnet på variabelen gir oss en måte å få tak i dataene* Til slutt regner vi ut produktet `l*h`, lagrer det i variabelen A og skriver det ut til skjermen Gode variabelnavn og gode kommentarer er viktig for lesbar kode.Les mer om gode variabelnavn og kommentarer her: http://lstor.me/kommentarer/.      Forbedring av programmetProgrammet har en svakhet: hver gang du vil endre dimensjonene på pararellogrammet, må koden endres.Bedre løsning: les inn tallene fra brukeren<jupyter_code># Regn ut arealet av et pararellogram med lengde l og bredde h
l = input('Skriv inn lengden på pararellogrammet: ')
h = input('Skriv inn høyden til pararellogrammet: ')

# Gjør strengene `l` og `h` om til desimaltall
l = float(l)
h = float(h)

A = l*h
print(A)<jupyter_output>Skriv inn lengden på pararellogrammet: 4.0
Skriv inn høyden til pararellogrammet: 5,0<jupyter_text>Oppgaver for å komme i gang med python  Oppgave 1Skriv et program `hei_verden.py` som skriver teksten `Hei, Verden!` ut til skjermen.  Oppgave 2Skriv et program som regner ut arealet til en trekant med lengde $h$ og grunnlinje $g$.Du kan velge verdier for $h$ og $g$ selv.  Oppgave 3Gjør om programmet over slik at det leser inn lengden $h$ og grunnlinja $g$,regner ut arealet til trekanten og skriver det ut til skjermen.  Oppgave 4: Lag et didaktisk verktøyDu skal introdusere elevene dine for funksjoner for første gang, og ønsker å lekeden (for lærere) kjente leken "gjett regelen" der elevene sier noen tall, du beregner en tilhørende verdimed en lineær funksjon, og elevene skal prøve å formulere hva funksjonen gjør med tallene.Bruk en lineær funksjon $y = ax + b$ der du selv bestemmer tallene $a$ og $b$ som holdes hemmelig for elevene.Programmet skal lese inn en verdi for $x$ og gi ut verdien for $y$.  Oppgave 5En båt seiler med konstant hastighet $v= 43.2 \text{km/t}$. Fra havn $A$ til havn $B$.Ved tiden $t=0$ var båten $180 \text{ km}$ unna havn $A$. Skriv et program som regner ut strekningen $s_A(t)$ fra havn $A$ etter tiden $t$.  Oppgave 6Modifiser programmet ditt i oppgave 3 slik at det leser inn farten $v$, strekningen $s_0$ ved tiden $t=0$ og tiden $t_0$.Programmet skal regne ut strekningen $s$ etter tiden $t$ og skrive det ut til skjermen.  Oppgave 7: Bruk en komplisert formelProgrammer kan gjøre det lettere å beregne verdien til kompliserte utrykk.Et objekt som beveger seg gjennom en væske eller en gass med tetthet $\rho$ målt i $\text{kg/m}^3$  og dynamisk viskositet $\mu$ målt i $\text{kg/ms}$, opplever en drag-kraft$$ F_d = \frac{1}{2}C_dA\rho v^2, $$der $C_d$ er *drag-koeffisienten* som avhenger av objektets form, overflate osv., og $A$ er arealet av objektets tverrsnitt målt i kvadratmeter.Du skal beregne $F_d$ når du har fått oppgitt følgende data:\begin{align*}\mu & = 1.802\cdot10^{-5} & \\\rho & = 1.225 & \\C_d & = 0.8 & \\A & = 0.8 & \\\end{align*}**a)** Lag et program `drag_koeffisient.py` som beregner drag-koeffisienten $F_d$.**b)** Gjør samme beregningen i et ipython-shell.  Noen konkrete anvendelser Vi kan begynne med å se på hvordan man kan gjøre beregninger knyttet til bevegelse under konstant akselerasjon $a$.Det finnes en formel programmet kan testes mot:$$ s(t) = s_0 + v_0t + \frac{1}{2}at^2 $$      Eksempel på algoritmisk tenkningFår å beregne strekningen $s$, må vi bryte problemet opp i mange delproblemer der vi beregner hastigheten $v$ fra akselerasjonen $a$ i mange små tidssteg, og i hvert tidssteg oppdaterer vi $s$ med formlene\begin{align*}v(t_n) = 10 - at_n \\[1.2em]s_{n+1} = s_{n} + \Delta t \cdot v(t_n)\end{align*}<jupyter_code>def modell_strekning(T, s_0, v):
    """
    modell-problem med kjent fart

    idé: Hvis man kjenner s(t) og v(t), kan s(t + dt) tilnærmes slik:
    s(t + dt) = s(t) + dt*v(t)
    Jo mindre tidssteg dt, jo mer nøyaktig blir tilnærmingen.
    """

    dt = 0.1   # tidssteg
    t = [0]    # første tidspunkt
    s = [s_0]  # start-strekning
    k = 0      # telle-variabel

    while t[k] < T:
        s_next = s[k] + dt*v( t[k] )
        t_next = t[k] + dt

        s.append(s_next)
        t.append(t_next)
        k = k + 1

    return t, s<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08164805312405675, 'fraction_numerical': 0.009809840024147299, 'mean_word_length': 4.383428107229895, 'pattern_counts': {'":': 0, '<': 15, '<?xml version=': 0, '>': 14, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '477284', 'license': 'MIT', 'n_tokens_mistral': 2622, 'n_tokens_neox': 2506, 'n_words': 909, 'path': 'dokumenter/hvorfor_programmere.ipynb', 'repo_name': 'eika123/programmering_uskole', 'size': '6626'}