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:

2.1.3: For- og while-løkke

1.
Skriv et program som regner ut summen av tallene fra og med 1 til og med 449 ved hjelp av en for-løkke, og til slutt printer ut resultatet.

2.
a) Skriv et nytt program med en variabel a med verdien 1 og en while-løkke.For hver iterasjon i while-løkken skal variabelen a ganges med 3.Løkken skal være ferdig når verdien av a er større enn 100. Skriv så ut verdien av a.

b) Hvorfor lønner det seg å bruke en while-løkke, og ikke en for-løkke?

c) Hvor mange ganger kjøres koden inne i løkken?

d) Hvilken verdi blir skrevet ut?

Vis løsningsforslag

Oppgave 1
I denne oppgaven skal vi summere alle tall mellom 0 og 499. Vi gjør dette på følgende måte:

totale_sum = 0

#i går fra 0 til og med 499
for i in range(500):
    totale_sum = totale_sum + i

print(totale_sum)

Det er viktig å huske at indeksering i python starter på 0 og går til, men tar ikke med 500 (i denne oppgaven).

Oppgave 2

a)
Vi skal nå skrive et program som bruker en while-løkke til å gange enn variabel med 3. Når variabelen er større enn 100, skal løkken stoppe. Dette gjør vi på følgende måte:

a = 1    #definerer a

#løkken kjører så lenge a er mindre enn 100
while a<100: 
    a = a*3        #ganger variabelen a med 3

print(a)        #printer variabelen a

while-løkken vil nå gange a med 3 så lenge a er mindre enn 100.

b)
Det lønner seg å bruke en while-løkke fordi while-løkken sjekker om noe er sant. Siden vi ikke vet nøyaktig hvor mange ganger vi må gange med 3 for at a skal bli større enn 100, hadde det vært vanskelig å sette grensene for for-løkka.

c)
For å finne ut hvor mange ganger koden inne i løkken kjøres, legger vi til en variabel iterasjoner i koden som adderes med 1, for hver iterasjon i løkken. Vi printer deretter ut variabelen iterasjoner og ser at koden inne i programmet kjøres fem ganger.

a = 1    #definerer a
iterasjoner = 0 

#løkken kjører så lenge a er mindre enn 100
while a<100: 
    a = a*3        #ganger variabelen a med 3
    iterasjoner = iterasjoner+1 #Legger til tall til variabel

print(iterasjoner)

d)
Verien som ble skrevet ut fra programmet var:

a=243

2.1.4: Aritmetiske følger

Aritmetiske følger er følger der differansen mellom et tall og neste er en konstant. I følgene rekke øker hvert ledd med 4:

1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65 69…

Lag et program som finner summen av de 100 første tallene i rekka.

Vis løsningsforslag

Her er det hensiktsmessig å bruke en for-løkke. Vi definerer først to variabler, tall og sum. Begge tallene defineres som 1, det er fordi rekken starter på 1, så da kan vi tenke oss at første tall er lagt til i summen, så den er også 1. Så kjører vi løkken 99 ganger. Dette er fordi vi allerede har lagt til det første tallet. I løkken blir det først laget et nytt tall, og så legges tallet inn i summen.

tall = 1    #definerer tall som 1 fordi rekken starter på 1
sum = 1     #definerer sum som 1 fordi første tall er gitt

for i in range(99):     #kjører 99 ganger
    tall = tall + 4           #legger til 4 på forrige tall-verdi
    sum = sum + tall         #legger til tall-verdi på forrige sum-verdi

print(sum)

2.1.5: Summering av tall

  1. Skriv et program som regner ut summen av tallene fra og med 1 til og med 999 ved hjelp av en for-løkke, og til slutt printer ut resultatet.alt text

  2. Test ut programmet i oppgave 1 med summene alt text og alt text. Ser du et mønster? Programmering gir en ny mulighet til å utforske tall og tallenes egenskaper.

Vis løsningsforslag

Oppgave 1
Her må vi definere variabelen sum over for-løkken. Dette er fordi vi må bruke sum til å legge til hver i-verdi når løkka kjører.

sum = 0                 #definerer variabelen sum
for i in range(1,1000): #kjører 999 ganger, med i fra 1-999 
    sum = sum + i       #legger i til i summen

print(sum)              #skriver ut summen

Oppgave 2
Vi bruker programmet i oppgave 1, men bruker i in range(1,100) for summen av 1 til 99, og i in range(1,10000) for summen av 1 til 9999. Da får vi utskrift henholdsvis 4950 og 49995000. Vi ser at den siste summen har to ekstra 9-ere og to ekstra 0-er, men at begge summene begynner med 4, og har 5 mellom 9-erene og 0-ene.

2.1.6: While- og for-løkker

  1. Lag ei løkke som skriver ut alle partall fra og med 0 til og med 100. Gjør dette gjerne med både while- og for-løkker.

  2. Skriv et program som skriver ut alle tallene fra og med 1 til og med 449 ved hjelp av en for-løkke.

Vis løsningsforslag

Oppgave 1
Her er det mange kreative måter man kan løse oppgaven på. Her er et eksempel med while-løkke og et med for-løkke.

Når vi her bruker while-løkke må vi først definere to variabler, det er en "telle"-variabel, i, og en "utskrift"-variabel, x. Disse må defineres slik at vi kan bruke dem i løkken. Så lar vi løkken kjøre så lenge x er mindre en 100. Når x=98, vil da løkken kjøre en siste gang for å skrive ut x=100.

i=0                 #tellevariabel
x=0                 #utskriftvariabel
while x < 100:      #kjører så lenge x < 100
    i = i+1         #i er definert som 0, øker med 1 hver runde
    x = i*2         #formel for partall
    print(x)        #skriver ut x

Når vi her bruker for-løkke, trenger vi ikke å definere noen variabler først. I denne oppgaven kan vi for hver i sjekke om det er et partall, og dersom det er partall, skrives det ut.

for i in range(101):    #kjører 101 ganger, med i fra 0-100
    if i%2 ==0:         #sjekker om i er et partall    
        print(i)        #skriver ut i dersom det er partall

Oppgave 2
Her holder det med en ganske enkel for-løkke. Siden vi skal skrive ut tallene fra 1 til 449, må vi ha i in range(1,450). Merk at i da går fra og med 1 til men ikke med 450.

for i in range(1,450):
    print(i)

2.1.7: Fyrstikkeskene

Du står ute en natt og beundrer fullmånen. Du begynner å undre på hvor mange fyrstikkesker du egentlig må stable for å nå helt til månen. Du finner ut at månen er omtrent 384 400 km fra jorda, og at høyden til èn fyrstikkeske er 1,8 cm.

1.
Lag en while-løkke som legger på 10 000 fyrstikkesker av gangen helt til høyden av alle fyrstikkeskene er lengre enn avstanden til månen.

2.
Du slurver ikke, og vil vite nøyaktig hvor mange fyrstikkesker du trenger. Lag en ny while-løkke som trekker fra én og én fyrstikkeske, til høyden av alle fyrstikkeskene er mindre enn avstanden til månen.

3.
Skriv ut hvor mange fyrstikkesker du får plass til mellom jorda og månen. Skriv også ut hvor lang avstand det er fra toppen av stabelen med fyrstikkesker, til overflaten av månen.

4.
Hvorfor tror du at du ble bedt om å lage to løkker, i stedet for å kun bruke én løkke som legger til én og én eske?

Vis løsningsforslag

Oppgave 1
Vi starter med å lagre konstantene. Vi lager så en while-løkke som kjører helt til høyden til stabelen med esker er større enn avstanden til månen. Vi skriver:

#Definerer konstanter

avstand_maane = 384400*1000
hoyde_eske = 0.018

#Definerer startverdier
antall_esker = 0
stabel_hoyde = 0

#Legger på esker til høyere enn månen

while stabel_hoyde< avstand_maane:
    stabel_hoyde = stabel_hoyde + hoyde_eske*10000
    antall_esker = antall_esker + 10000

Inne i while-løkken skal vi legge på 10 000 esker om gangen. Høyden øker da med 10 000 ganger høyden til én eske. Vi adderer også antall_esker med 10 000 slik at vi vet hvor mange esker vi har lagt på.

Oppgave 2
Vi gjør akkurat det sammen som i oppgave 1, men vi snur ulikheten og trekker fra én og én eske, i stedet for å legge til 1000. Da skriver vi:

#Trekker fra til lavere enn månen

while stabel_hoyde> avstand_maane:
    stabel_hoyde = stabel_hoyde - hoyde_eske
    antall_esker = antall_esker - 1

Oppgave 3
Den resterende avstanden er lengden til månen minus høyden av stabelen. Vi regner ut den resterende avstanden og printer den ut, samt den totale høyden til stabelen.

#Regner ut resterende avstand i cm

avstand = (avstand_maane - stabel_hoyde)*100

#Skriver ut
print("Når vi stabler",antall_esker,"fyrsikkesker")
print("er vi",avstand,"cm fra månen")

Oppgave 4
Fra utskriften i oppgave 3 ser vi at vi trenger 21355555555 fyrstikkesker for å nå til månen. Hvis vi kun hadde brukt én løkke, måtte altså løkken ha kjørt mer enn 21 milliarder ganger! Dette tar veldig lang tid, og kan til og med få programmet til å kræsje. Siden vi har brukt to løkker, der den ene legger til 10 000 om gangen, og deretter trekker den andre fra 1 og 1, vil løkkene til sammen bare kjøre rett over 2 millioner ganger. Sammenlignet med 21 milliarder, har vi betraktelig redusert antall utregninger datamaskinen må gjøre. Programmet kan nå kjøres relativt raskt.

2.1.8: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)

2.1.9: Totallssystemet

Det går an å vise at 0.1=1/16+1/32+1/256+1/512+1/4096+1/8192+⋯ Dette er representasjonen av 0.1 i totall-systemet, den såkalte binære representasjonen av tallet. Vi skriver det som regel kortere som 0.1=0.000110011001100110011⋯(i totallsystemet). Bruk uttrykket over til å regne ut seks tilnærminger til 0.1 med økende nøyaktighet.
Hint: se seksjon 2.1 i ProMod boka om totallsystemet

Vis løsningsforslag

Vi ser at tallet gjentar seg systematisk i totallsystemet. Ved å se hvordan man konverterer fra totallsystemet til titallsystemet(ProMod 2.1.) kan vi se hvordan vi finner brøkene i titallsystemet. Hvis vi ser bort ifra alle ledd som blir 0 regner vi som nedenfor:
alt text

For å løse denne oppgaven er det best å bruke en for-løkke som lar oss lage summer. Vi må også se på potensene til to-tallene som ikke blir 0. Dette gir oss altså en rekkefølge med potenser som er: -4,-5,-8,-9,-12,-13...

Siden vi bare skal tilnærme dette ene tallet velger vi å bruke en if-statement for å bestemme neste potens. Vi vil at hvis potensen er et oddetall skal neste potens være den gamle potensen -3. Ellers(else) skal neste potens være gamle potens -1.

For å gjøre dette skriver vi følgende kode:

ant = input("hvor mange ledd skal med?")
ant = int(ant) #gjør om til heltall

tilnarming = 0.0#tilnærming
potens = -4.0#første potens
for i in range(ant):#går ant ganger
    tilnarming += 2**potens#Legger til på tilnærming

    #avgjør neste ledd i summen
    if (int(potens)/2)!=int(potens/2):
        potens = potens - 3.0
    else:
        potens = potens - 1.0

print(tilnarming)#printer tilnærming

Vi lar brukeren bestemme hvor mange ledd som skal med(nøyaktigheten). Vi kjører altså programmet 6 ganger med ulike input. Husk at tallet som står inne i range må være et heltall. Betingelsen != betyr ikke lik. -= og += trekker fra og legger til verdi på en variabel, så

a = a+5

kan skrives som

a +=5

kommentar:
Dette kan også løses ved å bruke en for løkke inni en forløkke på følgende måte:

for ant in range(1,7):  #kjører koden nedenfor med ant=1 til 6
    tilnarming = 0.0    #tilnærming
    potens = -4.0       #første potens

    for i in range(ant):        #går ant ganger
        tilnarming += 2**potens #Legger til på tilnærming

        #avgjør neste ledd i summen
        if (int(potens)/2)!=int(potens/2):
            potens = potens - 3.0
        else:
            potens = potens - 1.0

    print(tilnarming)#printer tilnærming

Vi kjører det første programmet med økende antall ledd og får:

hvor mange ledd skal med?1
0.0625

hvor mange ledd skal med?2
0.09375

hvor mange ledd skal med?5
0.099853515625

hvor mange ledd skal med?10
0.09999990463256836

hvor mange ledd skal med?11
0.09999996423721313

hvor mange ledd skal med?100
0.1

Ovenfor ser vi at summen nærmer seg raskt mot 0.1. Med 100 ledd så har vi overkommet maskin-nøyaktighet og programmet sier at summen er 0.1

2.2.1: Listebehandling

  1. Lag fem heltallsvariabler som inneholer verdiene 0,1,2,3,4. Skriv deretter ut verdiene av variablene.

  2. Lag en tom liste som heter tall. Legg tallene 0 til 4 inn i listen ved hjelp av en løkke. Skriv deretter ut variablene i listen ved hjelp av en løkke.

  3. Hvis du skulle skrevet ut alle tall mellom 0 og 100, hvilket av programmene ville du brukt?

Vis løsningsforslag

oppgave 1
Vi lager fem forskjellige variable med verdiene som er oppgitt i oppgaven. Vi printer deretter ut variablene.

var_a = 0
var_b = 1
var_c = 2
var_d = 3
var_e = 4

print(var_a)
print(var_b)
print(var_c)
print(var_d)
print(var_e)

oppgave 2
Vi definerer først en tom liste som heter tall. Vi bruker deretter er for-løkke for å legge inn tallene i listen. Vi bruker deretter en ny for-løkke som printer ut tallene i lista.

tall = [] #definerer tom liste

for i in range(0,5):
    tall.append(i)    #legger til i i lista 

for i in range(len(tall)):
    print(tall[i])    #printer tallet på plass i

Husk at første plassen i lista er 0, og at range går alltid fra 0 til, men ikke med n(eller 5 i dette tilfellet).len() kommandoen gir lengden på lista.

Siste for-løkken kan alternativt erstattes med:

for i in tall:
    print(i)    #printer alle elementene i listen tall.

oppgave 3
Hvis vi skulle skrevet ut alle tallene mellom 0 og 100, ville du bare trengt å bytte ut 5-tallet i løkken med 101, i det siste programmet. I det første programmet måtte vi deimot ha laget 101 forskjellige variable. Dette er grunnen til at et program med lister ville egnet seg mye bedre i dette tilfellet. Altså ville programmet fra oppgave 2 egnet seg best.

2.2.2: Løkke og liste

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 tom variabel 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 int(i/2) != i/2:     #sjekker om int(i/2) er ulik i/2
        oddetall.append(i)  #legger i inn i listen hvis oddetall

print(oddetall)             #printer listen

2.2.3: Lister og dyr

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

2.2.4: Min- og maksverdier

Definer en liste som inneholder følgende verdier: 6, -4, 7, -2, 8, -3, 9, -11.

Bruk en for-løkke til å iterere igjennom alle verdiene i listen og finn den minste og største verdien.(uten å bruke Python sin innebygde min- og max-funksjon) Skriv deretter ut begge verdiene.

Vis løsningsforslag

Vi starter med å lage listen som er definert i oppgaven. Etter dette må vi lage to variable for å lagre min- og max-verdiene av listen. Vi bruker en for-løkke for å itterere over listen:

liste_a = [6,-4,7,-2,8,-3,9,-11] #definerer listen

#definerer min og max verdi
min_verdi = liste_a[0]
max_verdi = liste_a[0]

#går gjennom listen
for i in liste_a:

    if i<min_verdi:
        min_verdi=i     #ny min_verdi

    if i>max_verdi:
        max_verdi=i     #nu max_verdi

#printer verdiene
print("minste verdien er:", min_verdi)
print("største verdien er:", max_verdi)

kommentarer:
Det er viktig at vi starter med å definerer min- og max-variablene fra listen vi jobber med. Hvis vi f.eks. hadde satt min_verdi=-50 ville programmet sagt at minsteverdien er -50 til tross for at dette ikke er et element i listen.

Når vi skriver:

for i in liste_a:

vil vi gå gjennom alle elementene i liste_a, og i vil ha verdiene til elementene i liste_a.

Inne i print() konverterer vi verdien om til tekststrenger slik at vi kan print det med ordene. Dette er ikke nødvendig, men gjør det litt lettere å se hva som er min- og max-verdi.

Alternativ løsning

liste_a = [6,-4,7,-2,8,-3,9,-11] #definerer listen

#definerer min og max verdi
min_verdi = liste_a[0]
max_verdi = liste_a[0]

#går gjennom listen
for i in range(len(liste_a)):

    if liste_a[i]<min_verdi:
        min_verdi=liste_a[i]#ny min_verdi

    if liste_a[i]>max_verdi:
        max_verdi=liste_a[i]#nu max_verdi

#printer verdiene
print(min_verdi)
print(max_verdi)

Funksjonen len() gir kun lengden av listen, så en annen akseptabel løsning her ville vært å i stedet skrive:

for i in range(8):

Men da vil programmet kun funke med lister som har akkuart åtte elementer

2.2.5: Mer Listebehandling

1.Lag et program med en while-løkke som ber bruker taste inn fem heltall og lagrer disse i en liste som heter tall (husk: int(…)).

2.Sum av liste: Utvid programmet slik at det regner ut summen av tallene ved hjelp av en løkke, og skriver ut resultatet.

3.Lave verdier: Legg til programkode som skriver ut alle verdiene i lista som er mindre enn 10.

4.Søk: Legg til programkode som skriver ut en beskjed om verdien 5 finnes eller ikke finnes i listen.

Vis løsningsforslag

Oppgave 1

I denne oppgaven må vi starte med å definere listen. Vi kan deretter lage en while løkke som lar brukeren skrive inn tall til listen, så lenge det er mindre enn fem elementer i listen. Vi gjør dette på følgende måte:

tall = []   #definerer listen tall

#Ittererer så lenge det er mindre enn 5 tall i listen
while len(tall)<5:
    bruker_tall = input("Skriv inn ett heltall: ")
    bruker_tall = int(bruker_tall)    #konverterer til heltall
    tall.append(bruker_tall)         #Legger heltallet inn i listen

Programmet over vil legge inn fem heltall i lista. Hvis et desimaltall skrives inn av brukeren vil det ikke være nok med bare int(). Hvis du ønsker å løse dette må du først konvertere inputen til flyttall med float() og deretter bruke int(). For å være sikker på at programmet funker som det skal, kan det være lurt å prøve å printe ut lista før neste oppgave.

oppgave 2

I denne oppgaven skal vi summere alle tallene i lista: tall. Letteste måten å gjøre dette på er å bruke en for-løkke som ittererer over alle elementene i lista og legger dem til i en variabel. Dette gjør vi på følgende måte:

tall = [] #definerer listen tall

#Ittererer så lenge det er mindre enn 5 tall i listen
while len(tall)<5:
    bruker_tall = input("Skriv inn ett heltall: ")
    bruker_tall = int(bruker_tall)    #konverterer til heltall
    tall.append(bruker_tall)         #Legger heltallet inn i listen

totale_sum = 0 #Definerer den totale summen

for i in tall:
    totale_sum = totale_sum + i     #adderer i til totale sum

print(totale_sum)

Dette vil gi den totale summen av tallene i lista. Inne i for løkken vil variabelen i, i første itterasjon, ha verdien til det første elemente i lista. I neste itterasjon vil i ha verdien til andre element osv..

kommentar:
Det går an å erstatte:

totale_sum = totale_sum + i

med:

totale_sum += i

Oprasjonen += adderer det som står på høyre siden på det som står på vesntre side.

Oppgave 3
For å kunne bestemme hvilke tall i lista som er lavere enn 10 må vi bruke en if-statement. For å få litt oversikt over hva vi printer ut legger vi inn litt forklarende tekststrenger i print()-funksjonen også. Vi kan for eksempel løse problemet på følgende måte:

tall = [] #definerer listen tall

#Ittererer så lenge det er mindre enn 5 tall i listen
while len(tall)<5:
    bruker_tall = input("Skriv inn ett heltall: ")
    bruker_tall = int(bruker_tall)    #konverterer til heltall
    tall.append(bruker_tall)         #Legger heltallet inn i listen

totale_sum = 0 #Definerer den totale summen

for i in tall:
    totale_sum = totale_sum + i     #adderer i til totale sum

print("Den totale summen av lista er:",totale_sum)

#printer en melding hvis et tall i lista er mindre enn 10
for i in tall:
    if i <10: 
        print(i,"er lavere enn 10")

Vi kan alternativ løse denne oppgaven ved å legge tallene som er mindre enn 0 inn i en liste og printe ut lista, slik at vi bare får en utskift. Dette kan vi gjøre på denne måten:

lave_verdier = [] #definerer en tom liste
for i in tall:
    if i <10: 
        lave_verdier.append(i) #Legger til i i lave_verdier
print(lave_verdier, "er lavere enn 10")

Oppgave 4
I denne oppgaven skal vi undersøke om 5 er et element i lista. Det eneste vi trenger for å gjøre dette er en if-statement. Vi utvider altså programmet til:

tall = [] #definerer listen tall

#Ittererer så lenge det er mindre enn 5 tall i listen
while len(tall)<5:
    bruker_tall = input("Skriv inn ett heltall: ")
    bruker_tall = int(bruker_tall)    #konverterer til heltall
    tall.append(bruker_tall)         #Legger heltallet inn i listen

totale_sum = 0 #Definerer den totale summen

for i in tall:
    totale_sum = totale_sum + i     #adderer i til totale sum

print("Den totale summen av lista er:",totale_sum)

#printer en melding hvis et tall i lista er mindre enn 10
for i in tall:
    if i <10: 
        print(i,"er lavere enn 10")


#sjekker om 5 er et element i lista
if 5 in tall: 
    print("5 er et element i lista.")
else:
    print("5 er ikke et element i lista")

Nå vil altså programmet skrive ut en melding hvis 5 er et element i lista eller ikke. Hvis du ønsker, kan du utvide programmet til å si noe om hvor mange av dette elementet det er. Da bruker vi .count() funksjonen på følgende måte:

#sjekker om 5 er element i lista
if 5 in tall:
    print("Det er", tall.count(5),"elementer som er 5")
else:
    print("5 er ikke et element i lista")

Programmet vil nå også si noe om hvor mange elementer som har verdien 5.

2.2.6: 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(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(snitt)                    #skriver ut

2.2.7: Fibonacci med liste

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 Fibonacci 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 står på plass n-1 i lista

2.3.1: Gjette tall

Lag et program hvor brukeren blir bedt om å gjette et tall mellom 1 og 20.
Programmet skal kjøre frem til brukeren gjetter riktig tall.
Det riktige tallet skal være et tilfeldig tall som blir generert når programmet starter.
Gjør det slik at brukeren får en melding om de gjettet for høyt, for lavt eller riktig.

Vis løsningsforslag

Oppgave 3

from pylab import *         #for å bruke randint()

gjett = 0                   #gjettevariabel
fasit = randint(1,21)       #tilfeldig heltalltall mellom 1 og 20
while gjett != fasit:       #Kjører så lenge gjett er ulik fasit
    gjett = input("Gjett et tall mellom 1 og 20: ")
    gjett = float(gjett)    #Endrer gjett til tallet fra input
    if gjett < fasit:       #sjekker om gjett er mindre enn fasit
        print("For lavt")
    elif gjett > fasit:     #sjekker om gjett er større enn fasit
        print("Før høyt")
    else:                   #ellers
        print("Riktig!")

2.3.2: Navneliste og desimaltall

Du trenger en elev til å vise på tavla hvordan man runder av desimaltall til to desimaler. Du spør om noen i klassen vil, men ingen melder seg, så du må velge. Du ønsker å trekke en tilfeldig elev for å løse oppgaven på tavla. Du har klasselisten med navn:

navn = ["Maria","Thomas","Isak","Ingrid", "Axel","Fridtjof","Karoline"]
  1. Skriv et program som trekker ut et tilfeldig navn fra lista, og printer det ut.
  2. Du glemte å finne et desimaltall eleven kan runde av! Skriv et program som skriver ut et tilfeldig desimaltall mellom null og ti.
  3. Du har selv glemt hvordan man skal runde av tall og kan ikke kontrollere svaret til eleven. Utvid programmet til også å printe ut svaret. (hint:round()).
Vis løsningsforslag

Oppgave 1
For å trekke et tilfeldig navn må vi ha en tilfeldig indeks, som må være heltall. Vi skal altså ha et tilfeldig heltall mellom 0 og antall navn i lista. Vi skriver da:

from pylab import *

            #Definerer en liste med navn

navn = ["Maria","Thomas","Isak","Ingrid","Axel","Fridtjof","Karoline"]

heltall = randint(len(navn)) #Finner tilfeldig heltall < 7

print(navn[heltall], "skal gjøre oppgaven.") #printer navn fra liste

randint(a,b)-funksjon vil gi et tilfeldig tall fra og med a, til men ikke med b. Altså vil den høyeste verien kunne være b-1.

Oppgave 2
Siden du har glemt å gjøre klart et desimaltall må vi generere et tilfeldig desimaltall(flyttall) mellom 0 og 10. Da skriver vi:

desimaltall = uniform(0,10) #Finner et tilfeldig desimaltall

print("Rund av",desimaltall,"til to desimaler") #printer desimaltallet

uniform(a,b)-funksjonen genrerer et desimaltall mellom a og b. Den eksakte verdien b er ikke inkludert, men dette trenger vi sjeldent å ta høyde for. Den høyeste verdien uniform(a,b) kan ha, vil være nesten eksakt b

Oppgave 3
For å sjekke at eleven har skrevet riktig svar, utvider vi programmet til å runde av og printe ut svaret:

desimaltall = uniform(0,10)
print("Rund av", desimaltall, "til to desimaler")

avrundet = round(desimaltall,2) #Runder av svaret til to desimaler

print("svaret er:",avrundet)    #printer det avrundete tallet

round(tall,b)-funksjonen vil runde av et tall til b antall desimaler.

kommentar:
Hvis du skal bruke randint()- eller uniform()-funksjonene må du huske å importere * fra pylab.

2.3.3: Yahtzee

Vi er på hytta og det er full stemning for Yatzy, men desverre har vi glemt terningene hjemme.

  1. Skriv et program som lar brukeren skrive en input n. Bruk deretter en for-løkke til å fylle opp en liste med n antall tilfeldige tall mellom 1 og 6. Skriv deretter ut lista.
  2. Utvid programmet slik at brukeren kan velge å kaste terninger igjen.

Idèer til utvidelser:
- La brukeren holde på de terningene de ønsker.
- Innfør betingelser og tester slik at brukeren får poeng utifra terningkastene.
- La brukeren spille et helt Yahtzee spill med en eller flere personer.

Vis løsningsforslag

Oppgave 1
Vi starter med å hente inn en input n fra brukeren, som vi gjør om til et heltall. Vi definerer deretter en tom liste. Vi lar en for-løkke kjøre n ganger og legge til ett tilfeldig tall mellom 1 og 6 for hver itterasjon. Vi printer så ut lista:

from pylab import*

n = input("Hvor mange terninger vil du kaste?") #Henter unput
n = int(n)                                      #Konverterer til heltall

terninger = []                          #Definerer tom liste

for i in range(n):                      #Løkke kjører n ganger
    terninger.append(randint(1,7))      #Legger til tilfeldig tall i lista "terninger"

print(terninger)

Vi må konvertere n til heltall fordi vi skal bruke den som argument i en for løkke. randint(1,7) vi kun gi verdier opp til 6, ikke inkludert 7.

Oppgave 2
Vi utvider programmet fra forrige oppgave til å spørre brukeren om de vil kaste terninger igjen. Vi setter alt fra forrige oppgave inn i en while-løkke og skriver da:

from pylab import*

fornoyd= 0              #Definerer en variabel fornoyd
while fornoyd != "n":   #Kjører så lenge fornoyd ikke er lik n

    n = input("Hvor mange terninger vil du kaste?")
    n = int(n)

    terninger = []

    for i in range(n):
        terninger.append(randint(1,7))

    print(terninger)

    fornoyd = input("Vil du kaste på nytt? (j/n)")  #Hvis brukeren skriver n,
                                                    #så stopper løkken

Vi definerer fornoyd utenfor løkken som noe annet enn "n", slik at løkken kjører første gangen. Vi må ha terninger-listen inne i løkken så den blir "tømt", for hvert nye kast. Vi spør til slutt brukeren om det ønsker å kaste terningen en gang til. Hvis brukeren skriver "n", vi løkken stoppe, hvis brukeren skriver noe annet kjører løkken igjen.

2.3.4: Informasjon om tilfeldige tall

  1. Lag et program som lar brukeren velge maksimal og minimalverdi for et tilfeldig tall, samt hvordan talltype det skal være(flyttall eller heltall). Programmet skal deretter generere et tilfeldig tall utifra det brukeren har sagt. Programmet skal kjøre i alle tilfeller.
  2. Innfør en rekke med beslutninger som avgjør om det tilfeldige genererte tallet x er et partall eller oddetall, eller ingen av delene, og skriver det ut.
  3. Innfør en ny rekke med beslutninger som avgjør om x er et desimaltall eller et heltall og deretter skriver dette ut.
  4. Lag en siste rekke med beslutninger som avgjør om tallet er positivt eller negativt. Print x ut til slutt, kjør programmet og sjekk at det funker.
Vis løsningsforslag

Kommentar:
Hvis du ikke får til en oppgave, prøv å skriv ut x i starten av koden, slik at du ser hvor det går galt.

Oppgave 1

Vi starter med å ta inn variable fra brukeren. Hvis brukeren vil ha flyttall bruker vi uniform()-funksjonen, hvs brukeren vil ha heltall bruker vi randint() funksjonen. For å bruke riktig funksjon innfører vi beslutninger på følgende måte:

from pylab import *
#Henter input og konverterer til flyttall

laveste = input("Hva er den laveste verdien x kan ha?")
hoyeste = input("Hva er den høyeste verdien x kan ha?")
laveste = float(laveste)
hoyeste = float(hoyeste)

#Spør om talltype

tall_type = input("Hva hvordan type skal tallet være?")

#Genererer tilfeldig tall utifra brukerens argumenter
#Skriver eventuelt ut feilmelding

if tall_type =="flyttall":
    x = uniform(laveste, hoyeste)

elif tall_type =="heltall":
    x = randint(laveste, hoyeste+1)
else:
    print("Du har en ugyldig talltype")

Vi sktiver hoyeste+1 fordi randint() ikke inkluderer det siste argumentet. Siden randint() returnerer ett desimaltall, går det fint at det ikke inkluderer det eksakt siste argumentet. randint(0,5) vil altså ikke kunne returnere 5.0, men vil kunne skrive 4.999999.... Dette er tilstrekkelig nøyaktig.

Oppgave 2
Vi bruker heltallsdivisjon for å sjekke om tallet er et heltall eller ikke. Vi printer deretter ut det vi finner. Vi kan få at tallet ikke er noen av delene hvis det er et desimaltall, vi inkluderer derfor en else-statement.

if (x//2) == (x/2):
    print("Tallet er et partall")
elif ((x+1)//2) == (x+1/2):
    print("Tallet er et oddetall")
else:
    print("Tallet er verken et oddetall eller partall")

for x=3 ville vi for eksempel fått:

3//2 = 1 som ikke er likt 3/2 = 1.5

(3+1)//2 = 2 som er lik 4/2 =2

Altså er tallet et oddetall.

Oppgave 3
Vi skal undersøke om tallet er er et desimaltall. Vi finne desimalene ved å ta x og trekke fra heltallet til x. Vi skriver da:

desimaler_til_x = x-int(x)

if desimaler_til_x == 0:
    print("Tallet er et heltall")
else:
    print("Tallet er et desimaltall")

Hvis verdien til desimalene til x er null, er da x et heltall. Hvis det ikke er null så må det være et desimaltall.

Oppgave 4
Hvis x er større en null er det positivt, hvis det er mindre enn null er det negativt. Hvis det verken er positivt eller negativt må det være lik null.

if x<0:
    print("Tallet er negativt")
elif x>0:
    print("Tallet er positivt")
else:
    print("Tallet er 0")

print(x)

2.3.5: Liste med tilfeldige tall

  1. Definer to tomme lister. Bruk en for-løkke til å fylle opp den ene listen med ti tilfeldige heltall med og mellom -100 og 100. Fyll den andre listen opp med ti tilfeldige flyttall mellom -100 og 100.
  2. Lag en for-løkke som finner den høyeste og den laveste verdien i lista med flyttall.
  3. Lag en ny for-løkke som finner den høyeste og den laveste verdien i lista med heltall.
  4. Print ut begge listene, samt min- og maksverdiene til begge listene, og sjekk at du får riktig svar.
Vis løsningsforslag

Oppgave 1
Vi starter med å definere to tomme lister, deretter lager vi en løkke som ittererer ti ganger. Inne i løkken genererer vi ett tilfeldig flyttall og en tilfeldig heltall. Vi legger deretter disse tallene inn i hver sin liste. Vi skriver:

from pylab import *

#Definerer to tomme lister

flyttall = []
heltall = []

#Fyller listene med tilfeldige tall

for i in range(10):
    tilfeldig_flyttall = uniform(-100,100)
    tilfeldig_heltall = randint(-100,101)

    flyttall.append(tilfeldig_flyttall)
    heltall.append(tilfeldig_heltall)

Legg merke til at vi må la randint()-funksjonen gå opp til 101, slik at vi inkluderer 100.

Oppgave 2
Vi definerer to startverdier laveste_flyttall og hoyeste_flyttall. Disse to variablene defineres som et hvilket som helst tall fra lista med flyttall. Vi lager så en for-løkke som sammenligner hvert tall i lista med variablene laveste_flyttall og hoyeste_flyttall, ved hjelp av betingelser. For eksempel: Hvis tallet i lista er høyere enn hoyeste_flyttall, blir hoyeste_flyttall definert som dette tallet. Vi skriver da:

#start-verdier

laveste_flyttall = flyttall[0]
hoyeste_flyttall = flyttall[0]

#Finner høyeste og laveste flyttall

for tall in flyttall:            #Hvert tall i lista
    if tall>hoyeste_flyttall:    #Hvis tallet er høyere
        hoyeste_flyttall = tall #Nytt høyeste tall

    if tall < laveste_flyttall:    #Hvis tallet er mindre
        laveste_flyttall = tall #Nytt laveste tall

Når løkken har gått gjennom hele lista vil vi sitte igjen med høyeste og laveste tallet i lista.

Oppgave 3
Vi gjør akkurat det samme som vi gjorde i forrige oppgave, men denne ganger gjør det med heltalls-listen. Vi skriver:

#start-verdier

laveste_heltall = heltall[0]
hoyeste_heltall = heltall[0]

#Finner høyeste og laveste heltall

for tall in heltall:            #Hvert tall i lista
    if tall > hoyeste_heltall:    #Hvis tall er høyere
        hoyeste_heltall = tall     #Nytt høyeste tall

    if tall < laveste_heltall:    #Hvis tall er lavere
        laveste_heltall = tall     #Nytt laveste tall

Oppgave 4
Vi skriver ut listene på følgende måte:

#Skriver ut listen med flyttal og max-/min- verdier

print("Listen med flyttall:")        
print(flyttall)
print()
print("Laveste=",laveste_flyttall," Høyeste=",hoyeste_flyttall)
print()

#Skriver ut listen med heltall og max-/min- verdier
print("Listen med letall:")
print(heltall)
print("Laveste=",laveste_heltall," Høyeste=",hoyeste_heltall)

Vi skriver en tom print slik at vi får linjeskift, slik at urskriften blir mer ryddig. Vi ser at vi får riktig maks- og min- verdier når vi kjører programmet.

3.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.