Du er ikke logget inn. Så lenge du ikke er logget inn går du glipp av muligheten for å holde styr på din egen progresjon.

Logg inn

Valgte tags:

Filtrering:

Skriv ut:

3.1.8: Vekstfaktor

  1. Lag et program som regner ut hvor mye penger du har i banken etter ei viss tid med en gitt (fast) rente. Velg startbeløp selv.

  2. I en populasjon avhenger antallet individer av en art naturlig nok med antall individer av den samme arten ved foregående tidspunkt. La oss si at ingen andre faktorer spiller inn. Da vil antallet individer Nt ved tida t være lik antallet individer ved forrige tidspunkt, Nt-1, multiplisert med en vekstfaktor k. Eksempelet nedenfor angir antall harer etter ei gitt tid:
    alt text
    La k = 1.10 og regn ut med ei løkke hvor mange harer det er i populasjonen etter 10 år. Diskuter hvilke biologiske forutsetninger vi har lagt til grunn for modellen.

Vis løsningsforslag

Oppgave 1
Vi regner ut hvor mye penger vi har etter 20 år, når vi starter med 100 000, og har en rente på 3%.

rente = 0.03                #3%
vekst = 1 + rente           #vekstfaktor
tid   = 20                  #år
start = 100000              #penger i banken til å begynne med
slutt = start*vekst**tid    #penger i banken etter 20 år

print(slutt)

Oppgave 2
Denne oppgaven er ganske lik oppgave 1, men her ser vi på hvordan vi kan løse oppgaven med en løkke istedenfor en formel.

k = 1.1                     #vekstrate
Nt = 100                    #populasjon til å begynne med
for i in range(10):         #kjører løkken 10 ganger
    Nt = Nt*k               #ny populasjon regnes ut

print(Nt)                   #printer populasjonen

3.1.9: Sparing og lån

Kari har 100 000 kroner på sparekontoen, som hun har tjent på sommerjobber de siste årene. Hun planlegger å spare disse pengene i banken for å få råd til leielighet en dag. For å få råd til leielighet trenger hun 300 000 kroner i egenkapital.

  1. Med en rente på 3 %, virker dette som en god plan?

  2. Løs denne oppgaven med programmering, hvor mange år tar det før Kari har nok penger?

  3. Kari bestemmer seg for å spare 15000 kroner til per år. Modifiser programmet, hvor mange år tar det nå?

  4. Kari er 18 år, og vil gjerne ha råd til bolig når hun er ferdig med å studere, altså når hun er 24 år. Hvor mye må hun spare per år for å rekke dette?

Vis løsningsforslag

Oppgave 1
Det vil ta ganske lang tid før hun får rå til å kjøpe leilighet hvis hun kun venter på rentene, så dette er nok ikke den beste planen.

Oppgave 2
Først legger vi inn alle variablene våre, og bruker en while-løkke som kjører frem til vi når sparemålet.

rente = 0.03                    #3%
vekstfaktor = 1 + rente
sparemål = 300000
saldo = 100000                  #startbeløp
tid = 0
while saldo < sparemål:         #kjører frem til saldo >= sparemål
    saldo = saldo * vekstfaktor #regner ut ny saldo
    tid = tid + 1               #øker tid med ett år per runde

print("Det er nok penger etter", tid, "år.")
print("Da er det", round(saldo, 2), "kroner på konto")

Oppgave 3
For å ta hensyn til at hun sparer 15000kr ekstra i året, lager vi en variabel sparerate, som vi adderer til saldoen i løkken. Programmet ser da slik ut:

rente = 0.03            
vekstfaktor = 1 + rente
sparemål = 300000
sparerate = 15000       #sparing per år
saldo = 100000          
tid = 0
while saldo < sparemål: 
    saldo = saldo * vekstfaktor + sparerate
    tid = tid + 1      

print("Det er nok penger etter", tid, "år.")
print("Da er det", round(saldo, 2), "kroner på konto")

Oppgave 4
For å finne ut hvor mye Kari på spare i året for å ha 300000kr på konto om 6 år, må vi gjøre noen endringer i programmet fra oppgave 3. Vi må legge til en for-løkke inni while-løkken, som regner ut saldo etter 6 år for hver sparerate som sjekkes. Fra oppgave 3 vet vi at det tar 10 år å spare 300000kr, hvis spareraten er 15000kr. Vi starter derfor på 15000kr, og sjekker ved hjelp av for-løkken om det er nok. Hvis vi ikke når sparemålet vil while-løkken kjøre en ny runde, øke spareraten med 1, og for-løkken vil sjekke på nytt. Slik fortsetter programmet frem til saldoen etter 6 år er større eller lik sparemålet.

rente = 0.03                    #3%
vekstfaktor = 1 + rente
sparemål = 300000
sparerate = 15000               #sparing per år
saldo = 100000                  #startbeløp
while saldo < sparemål:         #kjører frem til saldo >= sparemål
    saldo = 100000              #nullstiller saldo før ny sjekk
    tid = 0                     #nullstiller tid før ny sjekk
    sparerate = sparerate + 1   #øker sparerate med 1
    for i in range(6):          #kjører 6 runder
        saldo = saldo * vekstfaktor + sparerate
        tid = tid + 1           #øker tid med ett år per runde
print("Tid:", tid, "år, saldo:", saldo, "sparerate: ", sparerate)

3.2.1: Lister

I denne oppgaven skal vi utføre forskjellige operasjoner på en liste. Vi har listen dyr:

dyr = ["ape","elefant","giraff","kenguru", "sebra"]

Etter hver oppgave, skriv ut listen du opererte på, for å se hva som skjer.
1. Lag en ny tom liste rovdyr, og deretter legg inn to dyr i den nye listen.
2. Legg hele rovdyr listen til i dyr.
3. Slett det tredje dyret i dyr.
4. Vi vil kun ha firebente dyr i listen, slett resten.
5. Sorter dyrene i alfabetisk rekkefølge.

Vis løsningsforslag
dyr = ["ape","elefant","giraff","kenguru", "sebra"] #liste fra oppgave

rovdyr = []                 #tom liste
rovdyr.append("ulv")        #legger til "ulv" i rovdyr
rovdyr.append("bjørn")      #legger til "bjørn" i rovdyr
print(rovdyr)               #skriver ut rovdyr

dyr.extend(rovdyr)          #legger til rovdyr i listen over dyr
print(dyr)                  #skriver ut dyr

dyr.pop(2)                  #sletter det tredje dyret i listen
print(dyr)                  #skriver ut dyr

dyr.remove("ape")           #fjerner "ape" fra dyr
dyr.remove("kenguru")       #fjerner "kenguru" fra dyr
print(dyr)                  #skriver ut dyr

dyr.sort()                  #sorterer alfabetisk (tall ville blitt 
                                    sortert i stigende rekkefølge)
print(dyr)                  #skriver ut dyr

3.2.2: Karakterer

Fra en prøve i matematikk, har vi følgende karakterer:

karakterer = [3,2,5,4,3,6,5,4,3,1,5,4,6,5,4]
  1. Sorter karakterene i synkende rekkefølge, skriv ut listen.
  2. Sjekk hvor mange som fikk sekser, og skriv ut.
  3. Bruk en løkke til å regne ut summen av karakterene.
  4. Bruk summen til å regne ut, og skrive ut snittet.
Vis løsningsforslag
karakterer = [3,2,5,4,3,6,5,4,3,1,5,4,6,5,4]
karakterer.sort()       #bruker først sort, som sorterer stigende
karakterer.reverse()    #reverserer listen for å få synkende
print(karakterer)       #skriver ut 

seksere = karakterer.count(6)   #teller antall 6'ere
print("Antall seksere er ", seksere)                  #skriver ut

sum = 0                         #definerer tom variabel
for element in karakterer:      #for hvert element i listen
    sum = sum + element         #legger til elementet i summen

snitt = sum/len(karakterer)     #regner ut snitt
print("Snittet er ",snitt)                    #skriver ut

Legg merke til at kommandoen len(liste) gir antall elementer i listen

3.2.3: Liste med oddetall

Lag ei løkke som skriver ut alle oddetall fra og med 0 til og med 99 og lagrer dem i ei liste. Programmet skal skrive ut lista til slutt.

Vis løsningsforslag

Når du skal drive med lister i python er det viktig å definere listen til å begynne med, selv om den er tom, akkurat som at vi definerer en variabel (setter den til 0) når vi bruker for-løkker til å regne ut en sum. Setter i in range(100) for å ha i-verdier fra 0-99, og bruker en if-statement for å sjekke om i er et oddetall før vi leger det til i listen.

oddetall = []               #definerer tom liste
for i in range(100):        #kjører med i fra 0-99
    if i%2 != 0:     #sjekker om i//2 er ulik i/2
        oddetall.append(i)  #legger i inn i listen hvis oddetall

print(oddetall)             #printer listen

3.2.4: Fibonacci

Fibonacci-tallene er en kjent tallfølge som starter slik:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Følgen kan beskrives ved at neste tall er summen av de to foregående:

Lag et program som finner tall nummer n i følgen.

Vis løsningsforslag

Husk at indeksering av lister begynner på 0, og at for-løkker går fra og med første tall, til men ikke med siste tall. Derfor setter vi i in range(2,n) slik at listen får n tall til slutt, så printer vi fib[n-1] for å få ut tall n.

n = int(input("Hvilket element i fibonaccirekken vil du vite? "))
fib = [1,1]                         #legger de to første tallene i liste
for i in range(2,n):                
    nestetall = fib[i-1]+fib[i-2]   #regner ut neste tall
    fib.append(nestetall)           #legger neste tall inn i listen

print(fib[n-1])                     #tall n har indeks n-1 i lista

4.1.1: Funksjoner

  1. Lag en funksjon som tar et navn som parameter og som skriver ut: Hei, «navn»!

  2. Lag en funksjon som tar radius som parameter og som regner ut arealet av en sirkel. Bruk deretter funksjonen til å skrive ut arealet til en sirkel, du velger radiusen selv.

  3. Lag en funksjon som regner ut radius, gitt omkretsen til en sirkel. Bruk deretter funksjonen til å skrive ut radiusen til en sirkel, du velger omkretsen selv.

  4. Hva er forskjellene på og likhetene mellom funksjoner i programmering og i matematikk?

Vis løsningsforslag

Oppgave 1

def hei(navn):           #definerer funksjon
    print("Hei,", navn)  #bruker navn parameter til å printe hilsen

hei("Leo")               #kaller på funksjon med "Leo" som parameter

Oppgave 2

from pylab import *      #importerer pylab for å bruke pi

def areal(radius):       #definerer funksjon
    areal = radius*pi**2 #regner ut areal
    return areal         #returnerer utregnet areal

areal = areal(2)         #kaller på funksjonen med radius=2
print(areal)             #printer resultatet

Oppgave 3

from pylab import *       #importerer pylab for å bruke pi

def radius(omkrets):      #definerer funksjon
    radius = omkrets/pi/2 #regner ut radius
    return radius         #returnerer utregnet radius

radius = radius(12)       #kaller på funksjonen med omkrets=12
print(radius)             #printer resultatet

Oppgave 4
I matematikk er en funksjon definert som at vi sender inn tall, og får ut tall. Vi kan bruke en funksjon i programmering på samme måte, men vi kan også bruke den mer fleksibelt. En funksjon i programmering er en måte å samle kode. I tillegg til å bruke den som en matematisk funksjon, hvor vi sender inn tall og får ut tall, kan vi for eksempel sende inn tekst eller lister, og gjøre mange utregninger på en gang. Vi kan også ha funksjoner uten input, som da er en samling av kode, gjerne noe vi vil gjøre flere ganger i et program, men istedenfor å skrive all koden hver gang lager vi en funksjon og kaller på den.

4.1.2: Funksjon og løkke

  1. Lag en funksjon i Python av den matematiske funksjonen 𝑓(𝑥)=2𝑥²−𝑥+1. Skriv ut funksjonsverdiene 𝑓(1), 𝑓(2) og 𝑓(3).

  2. Lag ei løkke som bruker funksjonen i oppgave 1 og skriver ut alle funksjonsverdiene fra x = 0 til x = 20.

  3. Hva er forskjellen på å definere og kalle en funksjon? Bør du definere eller kalle funksjonen inni løkka i oppgave 2?

Vis løsningsforslag

Oppgave 1

def f(x):               #definerer funksjonen
    f = 2*x**2 - x + 1  #regner ut
    return f            #returnerer utregnet verdi

f1 = f(1)       #kaller på funksjonen med x=1 og lagrer i f1
f2 = f(2)
f3 = f(3)
print("f(1)=", f1, ", f(2)=", f2, ", f(3)=", f3) 

Oppgave 2

for i in range(21): #range(21) gir i fra 0-20
    fx = f(i)       #kaller på funksjonen fra oppgave 1 med x = i
    print("Med x =", i, "får vi f(x) = ", fx)

Oppgave 3
Når vi definerer en funksjon så bestemmer vi hvilke operasjoner den skal gjøre når vi gir den en parameter, og hvilken parameter den skal ta inn. Når vi kaller på en funksjon gir vi den en parameter, så utfører funksjonen de operasjonene den er laget for.

I oppgave 2 trenger vi bare å kalle på funksjonen i løkken. Vi har allerede definert den og hvilke operasjoner den skal utføre, så skal vi bare kalle på funksjonen i for løkken, slik at den gjør operasjonene for hver x-verdi vi gir den.

4.2.1: Nytten av funksjoner (linspace)

1. Lag en tom liste, og bruk en for-løkke til å legge inn alle heltall fra -5 til 5, og skriv ut listen. Konverter så listen til en array, og skriv ut på nytt. Sammenlign utskriftene, hva er den synlige forskjellen?

2. Lag en funksjon som inneholder koden fra oppgave 1, men gjør det slik at når du kaller på funksjonen så kan du velge hvilken verdi arrayen skal starte og slutte på.

3. Bruk funksjonen i oppgave 2 til å opprette en array som inneholder alle heltall fra -10 til 10. Skriv ut arrayen.

Vi har ofte oppgaver hvor vi blir bedt om å opprette arrays fra en verdi til en annen. Hvis vi skal lage en ny array med andre start- og slutt-verdier, er det greit å ha en funksjon vi kan kalle på, i stedet for å lage en ny løkke hver gang.

4. Python (pylab), har en innebygd funksjon, linspace(), som fungerer ganske likt den vi nå lagde. Bruk linspace() til å lage en ny array med 21 tall fra -10 til 10, (linspace(-10,10,21)). Sammelign arrayen du får nå, med arrayen du fikk i oppgave 3, hva er den synlige forskjellen?

5. Endre det tredje argumentet i oppgave 4 til 41 (linspace(-10,10,41)), og skriv ut arrayen. Kan vi lage en slik array ved å bruke funksjonen vi lagde i oppgave 2? Hvilke begrensninger har funksjonen vi lagde i oppgave to, sammenliknet med linspace().

Vis løsningsforslag

Oppgave 1

from pylab import *     #for å bruke array() og senere linspace()

liste = []              #oppretter en tom liste
for i in range(-5,6):   #kjører med i=-5,-4,-3,-2,-1,0,1,2,3,4,5
    liste.append(i)     #legger i inn i listen
print(liste)            #printer listen
liste = array(liste)    #konverterer listen til array
print(liste)            #skriver ut arrayen

Begge utskriftene har samme tall, men listen har komma mellom tallene, arrayen har bare mellomrom.

Oppgave 2

def list(start,slutt):      #definerer funksjon
    liste = []              #oppretter tom liste 
    for i in range(start,slutt+1):  #kjører med i fra start til slutt
        liste.append(i)     #legger i inn i listen
    liste = array(liste)    #konverter liste til array
    return liste            #returnerer liste, som nå er en array

Legg merke til at vi må ha slutt+1 i for-løkken, dette er for at vi skal få i, med verdier fra og med start til og med slutt.

Oppgave 3

array = list(-10,10)    #kaller på funksjonen med start=-10 og slutt=10
print(array)            #skriver ut

Oppgave 4

nyarray = linspace(-10,10,21) #oppretter array fra -10 til 10 med 21 tall
print(nyarray)                #skriver ut arrayen

Hvis vi sammenlikner denne arrayen med arrayen fra oppgave 3, så ser vi at begge arrayene har de samme tallene, men det står punktum bak alle tallene fra linspace()-funksjonen. Det er fordi linspace() oppretter en array med flyttall, selv om det er hele tall.

Oppgave 5

lin_array = linspace(-10,10,41) #endrer til 41
print(lin_array)                #skriver ut arrayen

Når vi skriver ut denne arrayen ser vi at vi får 41 tall fra og med -10 til og med 10, altså får vi ut hvert halve tall fra og med -10 til og med 10. Dette kunne vi ikke gjort med vår funksjon, fordi den er begrenset til å lage array med heltall.

4.2.2: Linspace med mer

Nå skal vi utforske linspace()-kommandoen i Python.

en = linspace(10)
to = linspace(-10,10)
tre = linspace(-10,10,21)

Over står det tre linjer med kode, som bruker linspace med en, to og tre argumenter. Vi skal nå se litt på hva disse gjør.
1. Opprett og skriv ut array en. Hva skjer? Hvorfor?
2. Opprett og skriv ut array to. Hva skjer?
3. Opprett og skriv ut array tre. Sammenlign med array to, hva er forskjellen?
4. Kan du etter å ha gjort oppgave 1 til 3 forklare hvordan linspace fungerer, og hva de forskjellige argumentene står for?
5. Prøv nå koden under. Hva gjør disse funksjonene?

nuller = zeros(10)
print(nuller)
enere = ones(10)
print(enere)
Vis løsningsforslag

Oppgave 1
Vi får en feilmelding:

TypeError: linspace() missing 1 required positional argument: 'stop'

Fra denne kan vi se at vi mangler et argument i linspace, vi kan altså ikke opprette en array kun ved å oppgi ett argument.

Oppgave 2
Vi får ut en liste med 50 jevnt fordelte verdier fra og med -10 til og med 10.

Oppgave 3
Vi får ut en liste med 21 jevnt fordelte verdier fra og med -10 til og med 10. Vi har samme start- og sluttverdi som i oppgave 2, men i oppgave 2 fikk vi 50 verdier.

Oppgave 4
Hvis vi ser tilbake på oppgave 1 til 3, kan vi se at vi trenger to argumenter, som er start- og sluttverdi for arrayen. Hvis vi ikke skriver inn et tredje argument vil vi få en array med 50 tall. Hvis vi vil ha et bestemt antall verdier må vi legge til det tredje argumentet. Vi ser også at for å få heltall fra og med -10 til 10 må det tredje argumentet være 21, dette er fordi vi får 10 negative tall, 10 positive tall, og 0 i midten.

Oppgave 5
Funksjonen zeros(10) lager en tom array med 10 plasser, altså en array med 10 nuller. Du kan bytte ut 10 med et annet tall for å få ønsket antall nuller i arrayen. Funksjonen ones() fungerer på samme måte som zeros, men gir arrays med 1-tall.

4.2.3: Bruk av array

Vi kjører en racerbil med konstant fart v = 50m/s, i 30 sekunder.

  1. Vi vil vite hvor langt bilen har kjørt hvert femte sekund. Lag en passende array med tid-verdier.

  2. Bruk arrayen fra oppgave 1 og formel for strekning, til å lage en ny array som inneholder verdier for hvor langt vi har kjørt hvert femte sekund. Skriv ut begge arrayene

Vis løsningsforslag

Oppgave 1

from pylab import *     #importerer for å bruke linspace

t = linspace(0, 30, 7)  #oppretter array fra 0 til 30 med 7 tall

Arrayen vi får nå vil se slik ut: [ 0. 5. 10. 15. 20. 25. 30.]

Oppgave 2

s = 50*t    #bruker t og formel for strekning til å lage ny array

print(t)    #skriver ut t
print(s)    #skriver ut s

Her ser vi hvor lett det er å regne ut verdier når vi bruker arrays, istedenfor å bruke en løkke.

4.3.1: Andregradslikning

Vi betrakter andregradslikningen y = x² + 2x + 1.

  1. Opprett en array med x-verdier fra -10 til 10 med 21 plasser. Bruk arrayen og likningen til å opprette en ny array med tilhørende y-verdier.

  2. Bruk verdiene i arrayene til å plotte en graf over y.

  3. Endre antall plasser i x-arrayen fra 21 til 5. Hva skjer med plottet nå? Kan du se hva som egentlig skjer når vi bruker plot()-funksjonen? Er det lurt å ha mange eller få y-verdier når vi skal plotte?

Vis løsningsforslag

Oppgave 1

from pylab import *     #for å bruke linspace

x = linspace(-10,10,5)  #oppretter array med x-verdier
y = x**2 + 2*x + 1      #bruker x og likning til å opprette y-array

Oppgave 2

plot(x,y)   #plotter x_liste langs x-aksen og y_verdier langs y-aksen
grid()      #får frem rutenett
show()      #husk å skrive show() for å få opp plottet

Oppgave 3
Når vi endrer antall plasser i x-arrayen fra 21 til 5, får vi også kun 5 verdier for y. Når vi da skal plotte får vi et hakkete plott, og vi kan se at plot funksjonen ikke tekner en jevn bue, men trekker linjer mellom punktene. Derfor er det lurt å ha mange verdier, slik at linjene blir korte, og grafen ser jevnere ut.

4.3.2: Lese fra fil

Du skal på langtur med noen venner. Når dere begynner å kjøre, leser du av farten på speedometeret hvert minutt de første 15 minuttene og får følgende tekstfil som heter fart_data.txt:

tid:     fart:
 0       0
 1       48.3
 2       51.9
 3       50.2
 4       52.0
 5       51.3
 6       71.1
 7       69.0
 8       71.3
 9       72.2
 10      70.0 

Du bruker deretter følgende program:

from pylab import *
data = loadtxt("fart_data.txt", float, skiprows=1)
tid = data[:,0]           
posisjon = data[:,1]

Lag en fil på maskinen din med fart_data.txt og bruk så programmet ovenfor til å lese filen.

  1. Forklar hva programmet gjør ved å legge til kommentarer. Hva kommer til å ligge i variablen tid og hva vil ligge i posisjon?
  2. Skriv ut variablene tid og posisjon. Stemmer utskriften med det du trodde i oppgave 1?
  3. Er tid og posisjon lister eller arrayer?
  4. Bruk de innleste dataene dine til å plotte fart mot tid. Sett navn på aksene og få frem et rutenett for å lettere lese dataene.
Vis løsningsforslag

Oppgave 1

from pylab import * #må ha med denne for å bruke funksjonen loadtxt()

data = loadtxt("fart_data.txt", float, skiprows=1) #Laster inn filen                                #fart_data.txt, men hopper over første linje

tid = data[:,0]         #Legger inn det første tallet på hver rad      
posisjon = data[:,1]    #Legger inn det andre tallet på hver rad

Den første indeksen vil bestemme hvilken linje vi er på, mens den andre indeksen vil bestemme hvilket tall vi velger. Det andre tallet på første linje vil altså være data[0,1](Husk at indeksering starter på 0). Når vi skriver ":" betyr dette "alle". Så data[:,0] vil tilsvare det første tallet på alle radene. data[:,1] vil da være det andre tallet på alle radene.

Oppgave 2
Vi skriver ut variablene ved å skrive:

print("tid=", tid)
print("posisjonen=", posisjon)

Vi får da:

tid= [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
posisjonen= [ 0.  48.3 51.9 50.2 52.  51.3 71.1 69.  71.3 72.2 70. ]

Vi får det vi forventet fra forrige oppgave. Vi ser at alle tallene fra fart_data.txt blir printet ut, og at tid er venstre kolonne og posisjon er høyre.

Oppgave 3
Fra oppgave 2 kan vi se at det ikke er komma mellom tallene. Det er altså arrays med flyttall.

Oppgave 4

plot(tid,posisjon)  #plotter
xlabel("Tid")       #navn på x-akse
ylabel("Fart")      #navn på y-akse
grid()              #får frem rutenett
show()              #får frem hele plottet

4.3.3: Blodsukker

I et forsøk målte vi blodsukkeret til tre personer, en kontrollperson som ikke hadde spist noe, en som spiste en skive med ost, og en som spiste et eple. Vi målte ved tid 0, og etter 10, 25, 45, 60 og 90 min. Vi fikk disse resultatene:

kontroll = 5.0, 5.3, 4.9, 4.0, 3.8, 6.0 mmol/L

brødskive med ost = 4.0, 5.0, 5.9, 6.5, 6.9, 6.8 mmol/L

et eple = 4.3, 5.6, 7.8, 8.0, 5.6, 4.2 mmol/L

Lag et program som kan hente dataene fra en fil (som du må lage) og fremstill dataene grafisk. Forklar og diskuter resultatene.

Vis løsningsforslag

Det første vi må gjøre er å lage en tekstfil med alle målingene. For å gjøre dette så enkelt som mulig, og for å gjøre det lettere for oss å programmere, har vi lagt verdiene i kollonner istedenfor rader. Filen vi har laget heter målinger.txt og ser slik ut:

tid  kontroll   ost     eple
0       5.0     4.0     4.3
10      5.3     5.0     5.6
25      4.9     5.9     7.8
45      4.0     6.5     8.0
60      3.8     6.9     5.6
90      6.0     6.8     4.2

For å gjøre tekstfilen mer oversiktlig har vi valgt å sette verdiene i kolonner. Da kan vi også bruke kommandoen skiprows i loadtxt for å hoppe over ønsket antall linjer, i vårt tilfelle er det bare første linje som beskriver hvilke tall som hører til hva. Når vi skal hente verdier inn i listene må vi hente verdiene med en bestemt indeks, fra alle radene. For eksempel tid = fil[:,0]. : er for å gå gjennom alle radene, og 0 er for å hente ut elementet med indeks 0. Koden ser slik ut:

from pylab import *               #importerer pylab for å plotte

fil = loadtxt("målinger.txt", float, skiprows=1) #åpner og leser
print(fil)
tid = fil[:,0]                    #henter tid verdier
kontroll = fil[:,1]               #henter kontrollverdier
ost = fil[:,2]                    #henter brødskive med ost verdier
eple = fil[:,3]                   #henter epleverdier

plot(tid,kontroll,label="Kontroll")     #plotter verdier fra kontroll
plot(tid,ost,label="Brødskive med ost") #plotter verdier fra ost
plot(tid,eple,label="Et eple")          #plotter verdier fra eple
legend()                          #for å få frem labels
show()                            #for å få frem plottet

5.1.1: Turtle

La skilpadden gå 30 bortover, vende 90 grader og gå 40 oppover. Vend den så 143,13 grader. Hvor langt må den gå nedover for å komme tilbake til utgangspunktet og danne en rettvinkla trekant? Du kan skrive ut posisjonen i koordinatsystemet ved å skrive print(pos())

Vis løsningsforslag
from turtle import *  #importerer turtlebiblioteket
from pylab import *   #importerer pylab for å bruke sqrt()

shape("turtle")
forward(30)         #tegner en strek
left(90)            #snur 90 grader mot høyre
forward(40)
left(143.13)
dist = sqrt(40**2 + 30**2)  #pytagoras for å regne ut avstand til start
forward(dist)
print(pos())
exitonclick()  #for å lukke vinduet med figuren når du klikker i vinduet

5.1.2: Trekant

  1. Tegn en trekant med vinkler 30, 60 og 90 grader. Den lengste sida skal være 500 lang.

  2. Tegn en rettvinkla trekant ABC med vinkler ???? og der hypotenusen skal være 282,84 lang.

Vis løsningsforslag
from turtle import *  #importerer turtlebiblioteket
from pylab import *

forward(250)  #tegner en strek
left(120)     #120 grader til venstre, for å lage 60 grader vinkel
forward(500)
left(150)     #150 grader til venstre, for å lage 30 grader vinkel
dist = sqrt(500**2 - 250**2)    #pytagoras
forward(dist)
print(pos())  #printer ut posisjonen for å se om vi er tilbake til start
exitonclick() #for å lukke vinduet med figuren når du klikker i vinduet

5.1.3: Kjærlighetshistorie

To skilpadder, Shelly og Raphael, er glad i hverandre. De bor sammen i origo. Men en dag blir de uvenner, og Shelly løper 300 skritt mot venstre, mens Raphael går 300 skritt mot høyre. Men så ser de et tre der de pleide å være da de var unge og nyforelskede. Treet er 300 skritt rett opp fra huset deres i origo. Hvordan må de gå for å møte hverandre der igjen og oppleve kjærlighet nok en gang?

Vis løsningsforslag
from turtle import *  #importerer turtlebiblioteket
from pylab import *   #importerer pylab for å bruke sqrt()

Raphael = Turtle()          #navngir første objekt
Raphael.shape("turtle")     #gir det skilpaddeform
Shelly = Turtle()           #navngir andre objekt
Shelly.shape("turtle")      #gir det skilpaddeform

Raphael.forward(300)  #frem 300
Raphael.left(135)     #venstre 135
Shelly.left(180)      #snur først 180 for å stå motsatt vei av Raphael
Shelly.forward(300)   #frem 300
Shelly.right(135)     #venstre 135
distance_to_love = sqrt(300**2 + 300**2)  #pytagoras
Shelly.forward(distance_to_love)    #frem til mål
Raphael.forward(distance_to_love)   #frem til mål
exitonclick()  #for å lukke vinduet med figuren når du klikker i vinduet

Her er det viktig å huske på at både Shelly og Raphael står mot høyre til å begynne med, så derfor må vi snu Shelly 180 grader før hun begynner å gå. Alternativt kan du bruke backward(), men da må vi passe på hvordan vinkelen skal være.

Etter de har gått hver sin vei er det like langt fra origo til Shelly og Raphael, som det er fra origo og opp til treet. Vinklene mellom linjen fra origo til treet, og linjene fra origo til Shelly og Raphael er 90 grader. Vi vet da at vi har likebeinte trekanter, med 90, 45 og 45 grader. Altså må både Shelly og Raphael snu 135 grader, mot henholdsvis høyre og venstre, for å lage 45 graders vinkler og møtes.

5.1.4: Hus

  1. Lag en funksjon som tar ett tall som argument. I funksjonen skal vi ha en løkke, som ved hjelp av turtle lager en firkant. Lengden på sidene i firkanten skal bestemmes av argumentet som gis til funksjonen.

  2. Lag en liknende funksjon, men som lager en trekant istedenfor.

  3. Bruk de to funksjonene du har laget til å tegne et hus.

Vis løsningsforslag

Oppgave 1

from turtle import *

def firkant(lengde=100):  #standard lengde er 100 men vi kan angi annet
    for i in range(4):    #kjører fire ganger
        forward(lengde)   #lager en linje
        right(90)         #snur 90 grader

Oppgave 2

def trekant(lengde=100):  #standard lengde er 100 men vi kan angi annet
    for i in range(3):    #kjører tre ganger
        forward(lengde)   #lager en linje
        right(120)        #snur 120 grader

Oppgave 3

firkant() #kaller på funksjon for å lage firkant
left(60)  #siden firkant funksjonen snur 90 grader til venstre før den 
          #avslutter, må vi snu tilbake 60 grader før vi tegner trekant
trekant() #kaller på funksjon for å lage trekant

exitonclick()   #for å lukke vinduet ved å klikke i det

5.1.5: Circle og mønster

from turtle import *

circle(100,360)

exitonclick()
  1. Prøv å kjøre koden som står over. Hva skjer?
  2. Prøv å endre de to argumentene i circle(). Hva gjør de?
  3. Utdiv programmet med en løkke, slik at du kan lage et mønster ved å bruke circle(), og snu den litt for hver runde i løkka.
  4. Tilleggsoppgave: Lek deg litt med løkken og argumentene og få ulike mønstre. Du kan også prøve deg på en dobbel løkke, for å få mer kompliserte mønstre!
Vis løsningsforslag

Oppgave 1
Det tegnes en sirkel.

Oppgave 2
Hvis vi endrer første argumentet blir sirkelen større eller mindre, det bestemmer altså radiusen til sirkelen. Hvis vi endrer andre argumentet til mindre enn 360, vil vi ikke få en full sirkel, det bestemmer altså hvor mange grader av en sirkel som blir tegnet.

Oppgave 3

from turtle import *    #importerer for å bruke circle()

speed(0)                #setter hastighet til maks
for i in range(36):     #kjører 36 ganger
    circle(100,360)     #tegner full sirkel med radius 100
    right(10)           #snur 10 grader hver runde

exitonclick()           #for å lukke vindu ved å klikke i det

Siden vi lar løkken kjøre 36 ganger, og snur 10 grader hver runde, vil vi få et ganske fint mønster her. Gjerne eksperimenter med tallene!

5.1.6: Tegne fibonacci-mønster

Fibonacci-tallene er en kjent tallfølge som starter slik:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Følgen kan beskrives ved at neste tall er summen av de to foregående. Fibonacci-mønsteret ser slik ut:
alt text

Mønsteret er laget ved at det for hvert tall i rekken tegnes en kvart sirkel, der tallet er radiusen. Altså først to kvarte sirkler med radius 1, så en kvart sirkel med radius 2, så radius 3 osv.

  1. Lag en funksjon, som tar et heltall n som argument, og regner ut de n første tallene i rekken (hint: oppgave om fibonacci-rekken fra dag 3). Funksjonen skal returnere rekken.
  2. Bruk funksjonen fra oppgave 1 til å hente de 13 første tallene i rekken.
  3. Lag nå en løkke, som går gjennom rekken fra oppgave 2, og tegner fibonacci-mønsteret ved hjelp av circle-funksjonen i turtle.
Vis løsningsforslag

Oppgave 1
Husk at indeksering av lister begynner på 0, og at for-løkker går fra og med første tall, til men ikke med siste tall. Derfor setter vi i in range(2,n)

from turtle import * #importerer turtlebiblioteket til bruk i oppgave 2

def fib_rekke(n):       #definerer funksjon
    fib = [1,1]         #oppretter liste med de to første tallene
    for i in range(2,n):    #kjører med i fra og med 2 til og med n-1
        nestetall = fib[i-1]+fib[i-2]   #regner ut neste tall
        fib.append(nestetall)           #legger neste tall i listen
    return fib          #returnerer listen

Oppgave 2

fib_tall = fib_rekke(13)

Oppgave 3

for i in fib_tall:  #kjører for hvert tall i listen
    circle(i,90)    #lager en kvart sirkel for hvert tall i listen, der
                    #tallet fra listen er radiusen

exitonclick()  #for å lukke vinduet med figuren når du klikker i vinduet