diff --git a/uke40/Python/geografi.py b/uke40/Python/geografi.py
index 9b81e07749b565d18fad3f70333611b5141ca6a9..da9ea8a304668c3e3a9209be5601b4d46b77a8af 100644
--- a/uke40/Python/geografi.py
+++ b/uke40/Python/geografi.py
@@ -33,6 +33,15 @@ def spm(land, hovedsteder):
     else:
         print("nah")
 
-spm(land, hovedsteder)
+def spm2(land, hovedsteder):
+    l,h = random.choice(list(zip(land, hovedsteder)))
+    svar = input(f'Hva er hovedstaden i {l}')
+    if svar == h:
+        print("jippi")
+    else:
+        print("nah")
+
+
+spm2(land, hovedsteder)
 
 
diff --git a/uke41/Python/liste_gjennomgang_uke41.py b/uke41/Python/liste_gjennomgang_uke41.py
index 20ed741216d56b25476971dcad95f6483426807d..873852f9c7c2071e3fcea1c36c15baee47326974 100644
--- a/uke41/Python/liste_gjennomgang_uke41.py
+++ b/uke41/Python/liste_gjennomgang_uke41.py
@@ -137,7 +137,7 @@ liste = [0,12,2,3,122,12]
 
 # man kan søke i delstrenger med
 # index(hva, start, slutt)
-# print(liste.index(12, liste.index(12)+1,len(liste)))
+print(liste.index(12, liste.index(12)+1,len(liste)))
 
 # En mengde ulike funksjoner som kan brukes på lister
 
@@ -160,14 +160,14 @@ liste = [0,12,2,3,122,12]
 # 
 # # kopiering av lister - en lager bare en peker!
 liste1 = [0,1,2,3]
-liste2 = liste1
-liste1[3] = 'heisann!'
-print(liste2)
+# liste2 = liste1
+# liste1[3] = 'heisann!'
+# print(liste2)
 # # For å lage en kopi må du kopiere hvert element i listen
 # liste2 = [] + liste1
 # 
 # # eller
-# liste2 = []
-# for elem in liste1:
-#     liste2.append(elem)
-# print(liste2)
\ No newline at end of file
+liste2 = []
+for elem in liste1:
+    liste2.append(elem)
+print(liste2)
\ No newline at end of file
diff --git a/uke41/Python/sjekk_streng.py b/uke41/Python/sjekk_streng.py
index e8a04cb903ed7bbfd134b10710edac8f8075b861..0807e86ae57ad7c4883cc020c90998adbf16058d 100644
--- a/uke41/Python/sjekk_streng.py
+++ b/uke41/Python/sjekk_streng.py
@@ -67,6 +67,6 @@ Spiral out, keep going
 """
 
 
-tegn = input("Hvilket tegn vil du telle i diktet To be or not...? ")
+tegn = input("Hvilket tegn vil du telle i eposet Lateralus...? ")
 antall = telle_tegn(dikt,tegn)
 print("Diktet inneholder",antall,"av tegnet",tegn)
diff --git a/uke41/Python/skriv_tegn_indeks.py b/uke41/Python/skriv_tegn_indeks.py
index 2c6c18f69d7e8f16f86ca0b59da0a06da0903f93..b328599a478b4204374519c60a796827862aef5e 100644
--- a/uke41/Python/skriv_tegn_indeks.py
+++ b/uke41/Python/skriv_tegn_indeks.py
@@ -6,7 +6,7 @@ def skriv_tegn_indeks(tekst, tegn):
 
 
 tekst="Jeg gikk en tur på stien og hørte skogens ro."
-tekst+="Da hørte jeg fra lien en fugls som sa ko-ko."
+tekst+="Da hørte jeg fra lien en fugl som sa ko-ko."
 tekst+="Ko-ko, ko-ko, ko-ko-ko-ro-ko-ko."
 tekst+="Ko-ko, ko-ko, ko-ko-ko-ro-ko-ko."
 
diff --git a/uke41/Python/tid.py b/uke41/Python/tid.py
index d795fcfded2bdfea18541c5aa3cf6bb053525ffa..54e4679c13cd305f859f3ff3df7277814d7d7514 100644
--- a/uke41/Python/tid.py
+++ b/uke41/Python/tid.py
@@ -6,10 +6,10 @@ start = time.time()
 
 mem1 = psutil.Process().memory_info().rss
 # Følgende kode lager bare en range - som gir ut tall når du ber om det
-#x = range(10000000)
+x = range(50000000)
 
 # Når en lager en liste så lager den alle elementene med én gang
-x = list(range(50000000))
+# x = list(range(50000000))
 mem2 = psutil.Process().memory_info().rss
 
 print("tid:",time.time() - start)
diff --git a/uke42/Python/Fuskelapp.txt b/uke42/Python/Fuskelapp.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/uke42/Python/ITGK - Useful functions and methods.pdf b/uke42/Python/ITGK - Useful functions and methods.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..f30703d0577f925533fbf4d0a9dc397253f2094f
Binary files /dev/null and b/uke42/Python/ITGK - Useful functions and methods.pdf differ
diff --git a/uke42/Python/dictionaries_forklart.py b/uke42/Python/dictionaries_forklart.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bc7d27ed3a4bd13fddc32854e776a6a39d537ae
--- /dev/null
+++ b/uke42/Python/dictionaries_forklart.py
@@ -0,0 +1,103 @@
+# Ta en kikk paa passordliste.py, denne viser
+# hvordan man kan bruke en todimensjonal liste.
+
+
+# Dictionaries
+'''
+En dictionary kan sees på som en kommode med mange
+skuffer. Utenpå hver skuffe står det en nøkkel (key).
+Nøkkelen kan være hva som helst som er ikke-muterbart,
+det vil si at man for eksempel ikke kan bruke en liste
+som en nøkkel.
+
+Denne
+må være unik (akkurat som sett). Hver skuffe har også en
+verdi (value). Alt mulig kan ligge inni skuffen. En boolean,
+et talln en todimensjonal liste, en annen dictionary...
+Mulighetene er uendelige!
+
+Dette er for øvrig ikke en fullstendig beskrivelse av
+dictionaries, men det viser de mest brukte tingene ved dem.
+'''
+
+# Lage en tom dictionary:
+ordbok = {}
+
+# Legge inn en verdi 12 til nøkkelen 'svaret'
+ordbok['svaret'] = 12
+print('svaret: ',ordbok)
+# Den samme ordbokn kan ha ulike typer på nøkler og verdier
+ordbok[12] = 'tre ganger fire'
+ordbok['liste'] = [[1,2],[3,4]]
+print('tre elementer: ',ordbok)
+# Bare én nøkkel av hver type. Setter du den igjen overskriver du
+ordbok[12] = 'tolv ganger én'
+print('Ny tolver: ',ordbok)
+
+# For å hente ut en verdi gitt en nøkkel:
+print(f'Inni skuffen med "liste" utenpå ligger {ordbok["liste"]}')
+
+# Man kan hente ut alle nøkler (skuffefronter) slik:
+for key in ordbok.keys():
+    print('nøkkel:',key)
+    # Men man kan også hente ut verdiene, gitt key
+    print('nøkkel:',key,'har verdi:',ordbok[key])
+    
+# Man kan hente ut alle verdier (inni skuffene) slik:
+for value in ordbok.values():
+    print('verdi:',value)
+
+# Man kan hente begge slik:
+for key, value in ordbok.items():
+    print('verdi:',value)
+
+# Hvis en forsøker å hente ut en verdi på denne måten, og
+# nøkkelen ikke finnes, da utløses et unntak:
+# print(ordbok['finnesikke'])
+# Dette kan man unngå ved å bruke get(<nøkkel>):
+print('bruke get:',ordbok.get(12))
+
+# Hvis nøkkelen ikke finnes, da returnerer get None:
+print('bruke get på ikkeeksisterende nøkkel:',ordbok.get('finnesikke'))
+
+# Man kan i stedet la den returnere noe en selv spesifiserer hvis
+# nøkkelen ikke finnes, med get(<nøkkel>,<retur_hvis_ikke_eksisterer>)
+print('bruke get med bestemt retur:',ordbok.get('finnesikke',[]))
+
+
+# Eksempel med bruk av dictionary og analyse av en lenger streng:
+# Lag en ordbok som teller antall forekomster av alle ord.
+# ordet selv er nøkkelen, antall ganger er verdien knyttet
+# til denne.
+
+
+ordbok.clear() # Nå er den tom
+
+import lyric
+# I filen lyric.py ligger en strengvariabel TEKST
+for ord in lyric.TEKST.split(): # Sjekk bruken av modulen
+#    print(f'"{ord}"')
+    # Nå må vi finne ut hvor mange ganger ordet har vært
+    # talt opp før. Hvis det er første gang ber vi get
+    # returnere 0. Smart, ikke sant?
+
+    # Fjerne noen punktum og slikt.
+    ord = ord.replace('.','')
+    ord = ord.replace(')','')
+    ord = ord.replace('(','')
+    ord = ord.replace(',','')
+    
+    ganger = ordbok.get(ord,0)
+    
+    # Så oppdaterer vi den med 1
+    ordbok[ord] = ganger + 1
+    # kunne gjort det på en linje:
+#    ordbok[ord] = ordbok.get(ord,0) + 1
+
+# Skriv ut alle ordene og antall treff, i alfabetisk rekkefølge:
+print('Ord:\t\tGanger:')
+# sorted kan brukes på keys, values, under velger den automatisk keys:
+# Se sånn for øvrig hvordan jeg fyller ut riktig mengde mellomrom etter hvert ord.
+# Én av masse mulige løsninger for å 
+for ord in sorted(ordbok): # Merk sortering via sorted på nøklene
+    print(ord+" "*(15-len(ord)),ordbok[ord])
diff --git a/uke42/Python/dictionary_metoder.py b/uke42/Python/dictionary_metoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ad3d0b076cb02ccd2105b2696dd5380bef8ec70
--- /dev/null
+++ b/uke42/Python/dictionary_metoder.py
@@ -0,0 +1,24 @@
+# Opprette en dictionary
+d = {} # Mac SHIFT+ALT+ 8 9
+
+print('Skriv inn key og verdi. Avslutt med tom streng.')
+
+key = input('Key: ')
+
+while(key!=''):
+    value = input('Value: ')
+    d[key] = value
+
+    key = input('Key: ')
+
+# Litt variasjon på bruk av f strings og ikke, for å minne dere på...
+print(f'len(d): {len(d)}')
+print('d.items():',d.items())
+print('d.keys():',d.keys())
+print('d.values():',d.values())
+print('d.get(\'ost\',-999):',d.get('ost',-999))
+print('Merk at alt er strenger. Hvordan kan vi lagre det som andre typer variable?')
+
+# uskrift av alt:
+for key, value in d.items():
+    print(f'Inni skuffen {key} ligger {value}.')
\ No newline at end of file
diff --git a/uke42/Python/lyric.py b/uke42/Python/lyric.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa9d537548c4ee0e859b821c32f03ead6bcb268b
--- /dev/null
+++ b/uke42/Python/lyric.py
@@ -0,0 +1,139 @@
+TEKST = '''
+Seiya sessesse seiya.
+Seiya sessesse seiya.
+Soiya sossosso soiya.
+Soiya sossosso soiya.
+
+(Ossu.) Namida koborete mo
+(Ossu.) tachimukatte yukooze!
+
+Hitasura seiya soiya tatakau-nda
+kobushi o motto kokoro o motto
+zenbu zenbu togisumashite.
+(Wo'oo wo'oo wo'oo.)
+
+Mada mada seiya soiya tatakau-nda
+kanashiku natte tachiagare-naku natte mo.
+(Aa ossu ossu.)
+
+Seiya sessesse seiya.
+Seiya sessesse seiya.
+Soiya sossosso soiya.
+Soiya soso soiya.
+
+(Ossu.) Kokoro orarete mo
+(Ossu.) tachimukatte yukooze!
+
+Hitasura seiya soiya tatakau-nda
+kobushi o motto kokoro o motto
+zenbu zenbu togisumashite.
+(Wo'oo wo'oo wo'oo.)
+
+Mada mada seiya soiya tatakau-nda
+kanashiku natte tachiagare-naku natte mo.
+
+(Wo'oo wo'oo wo'oo.)
+(Wo'oo wo'oo wo'oo.)
+
+Seiya soiya tatakau-nda
+(Wo'oo wo'oo wo'oo.)
+zenbu zenbu togisumashite.
+(Wo'oo wo'oo wo'oo.)
+
+Seiya soiya tatakau-nda
+(Wo'oo wo'oo wo'oo.)
+zenbu zenbu togisumashite.
+(Wo'oo wo'oo wo'oo.)
+
+Hitasura seiya soiya tatakau-nda
+kobushi o motto kokoro o motto
+zenbu zenbu togisumashite.
+(Wo'oo wo'oo wo'oo.)
+
+Mada mada seiya soiya tatakau-nda
+kanashiku natte tachiagare-naku natte mo.
+
+Hashire!
+(Seiya soiya tatakau-nda)
+(zenbu zenbu togisumashite.)
+(Wo'oo wo'oo wo'oo.)
+
+Hashire!
+(Seiya soiya tatakau-nda)
+(zenbu zenbu togisumashite.)
+
+(Wo'oo wo'oo wo'oo.)
+(Wo'oo wo'oo wo'oo.)
+(Wo'oo wo'oo wo'oo.)
+(Wo'oo wo'oo wo'oo.)
+
+[English:]
+
+Seiya sessesse seiya.
+Seiya sessesse seiya.
+Soiya sossosso soiya.
+Soiya sossosso soiya.
+
+(Ossu.) Even if tears spill from our eyes,
+(Ossu.) let's confront it!
+
+Single-mindedly, seiya soiya, let's fight on
+with our fists more... with our spirits more...
+with making all sharper.
+(Wo'oh wo'oh wo'oh.)
+
+Still more, seiya soiya, let's fight on
+even if we get sad and unable to stand up.
+(Ah ossu ossu.)
+
+Seiya sessesse seiya.
+Seiya sessesse seiya.
+Soiya sossosso soiya.
+Soiya soso soiya.
+
+(Ossu.) Even if our spirits are broken,
+(Ossu.) let's confront it!
+
+Single-mindedly, seiya soiya, let's fight on
+with our fists more... with our spirits more...
+with making all sharper.
+(Wo'oh wo'oh wo'oh.)
+
+Still more, seiya soiya, let's fight on
+even if we get sad and unable to stand up.
+
+(Wo'oh wo'oh wo'oh.)
+(Wo'oh wo'oh wo'oh.)
+
+Seiya soiya, let's fight on
+(Wo'oh wo'oh wo'oh.)
+with making all sharper.
+(Wo'oh wo'oh wo'oh.)
+
+Seiya soiya, let's fight on
+(Wo'oh wo'oh wo'oh.)
+with making all sharper.
+(Wo'oh wo'oh wo'oh.)
+
+Single-mindedly, seiya soiya, let's fight on
+with our fists more... with our spirits more...
+with making all sharper.
+(Wo'oh wo'oh wo'oh.)
+
+Still more, seiya soiya, let's fight on
+even if we get sad and unable to stand up.
+
+Run!
+(Seiya soiya, let's fight on)
+(with making all sharper.)
+(Wo'oh wo'oh wo'oh.)
+
+Run!
+(Seiya soiya, let's fight on)
+(with making all sharper.)
+
+(Wo'oh wo'oh wo'oh.)
+(Wo'oh wo'oh wo'oh.)
+(Wo'oh wo'oh wo'oh.)
+(Wo'oh wo'oh wo'oh.)
+'''
\ No newline at end of file
diff --git a/uke42/Python/oppgave_count_words.py b/uke42/Python/oppgave_count_words.py
new file mode 100644
index 0000000000000000000000000000000000000000..686f2c1fd1005c7c6eb23914f1a2cb4d9b7bf36e
--- /dev/null
+++ b/uke42/Python/oppgave_count_words.py
@@ -0,0 +1,29 @@
+import random
+
+'''
+Opprette tom dictionary/ordbok
+Gjøre om strengen til liste av ord
+Gå igjennom hvert ord og:
+ - Er ordet i dict fra før? Legg på 1 på verdien som er der
+ - Hva skal du gjøre hvis ordet ikke er det fra før? Se på d.get igjen.
+Returner dictionary
+'''
+
+def count_words(streng):
+    return # Ja, _hva_ skal den returnere tro!
+    
+import random
+
+# Jeg lager bare kjapt en streng med en drøss tilfeldige tall mellom 0 og 10:
+streng = " ".join([str(random.randint(1, 15)) for i in range(100)])
+print(streng)
+d = count_words(streng)
+
+pass
+# skriver dem ut:
+for key in sorted(d):
+    print(f'{key} var der {d[key]} ganger.')
+
+# Hvis dere har veldig lyst:
+#import lyric
+#print(count_words(lyric.TEKST))
diff --git a/uke42/Python/oppgave_count_words_fasit.py b/uke42/Python/oppgave_count_words_fasit.py
new file mode 100644
index 0000000000000000000000000000000000000000..ede183365d5ffad4f5b1cca5feac0a092cd159b7
--- /dev/null
+++ b/uke42/Python/oppgave_count_words_fasit.py
@@ -0,0 +1,33 @@
+import random
+
+'''
+Opprette tom dictionary/ordbok
+Gjøre om strengen til liste av ord
+Gå igjennom hvert ord og:
+ - Er ordet i dict fra før? Legg på 1 på verdien som er der
+ - Hva skal du gjøre hvis ordet ikke er det fra før? Se på d.get igjen.
+Returner dictionary
+'''
+
+def count_words(streng):
+    d = {}
+    liste = streng.split()
+    for tall in liste:
+        pre = d.get(tall, 0)
+        d[tall] = pre + 1
+#        print(tall, pre, d) # her kan du se hva hver av dem er.
+    return d
+    
+import random
+# Jeg lager bare kjapt en streng med en drøss tilfeldige tall mellom 0 og 10:
+streng = " ".join([str(random.randint(1, 15)) for i in range(100)])
+print(streng)
+d = count_words(streng)
+
+# skriver dem ut:
+for key in sorted(d):
+    print(f'{key} var der {d[key]} ganger.')
+
+# Hvis dere har veldig lyst:
+#import lyric
+#print(count_words(lyric.TEKST))
diff --git a/uke42/Python/oppgave_set.py b/uke42/Python/oppgave_set.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ba3c9f6c3e26b488d861a20cf628bd58237bcc5
--- /dev/null
+++ b/uke42/Python/oppgave_set.py
@@ -0,0 +1,33 @@
+import random
+'''
+
+Funksjonen beskriv_set tar inn to LISTER a og b
+Den skal gjøre om listene til set, og så
+skrive ut ulike ting:
+- alle unike verdier som er i begge listene til sammen
+- alle verdier som KUN er i begge listene
+- alle verdier som er i begge listene, men ikke i begge
+- elementene som er i a, men ikke i b
+
+'''
+
+def beskriv_sett(a, b):
+    
+    # Gjøre om til sett
+
+    print(f'Unike element i hele a og b tilsammen: {None}')
+    print(f'Unike element som er i både a og b: {None}')
+    print(f'Unike element i som ikke er i begge lister: {None}')
+    print(f'Elementer i a som ikke også er i b: {None}')
+    
+a = [random.randrange(10) for i in range (0, 10)]
+b = [random.randrange(10) for i in range (5, 15)]
+print(f"a: {a}\nb: {b}")
+
+beskriv_sett(a,b)
+
+def foo():
+    print(1)
+    
+print(12)
+
diff --git a/uke42/Python/oppgave_set_fasit.py b/uke42/Python/oppgave_set_fasit.py
new file mode 100644
index 0000000000000000000000000000000000000000..57aa6d2039b6708bfa29be19c0e0cac602e62028
--- /dev/null
+++ b/uke42/Python/oppgave_set_fasit.py
@@ -0,0 +1,33 @@
+import random
+'''
+
+Funksjonen beskriv_set tar inn to LISTER a og b
+Den skal gjøre om listene til set, og så
+skrive ut ulike ting:
+- alle unike verdier som er i begge listene til sammen
+- alle verdier som KUN er i begge listene
+- alle verdier som er i begge listene, men ikke i begge
+- elementene som er i a, men ikke i b
+
+'''
+
+def beskriv_sett(a, b):
+    
+    set_a = set(a)
+    set_b = set(b)
+    print(f'Unike element i hele a og b tilsammen: {set_a.union(set_b)}')
+    print(f'Unike element som er i både a og b: {set_a.intersection(set_b)}')
+    print(f'Unike element i som ikke er i begge lister: {set_a.symmetric_difference(set_b)}')
+    print(f'Elementer i a som ikke også er i b: {set_a.difference(set_b)}')
+    
+a = [random.randrange(10) for i in range (0, 10)]
+b = [random.randrange(10) for i in range (5, 15)]
+print(a,b)
+
+beskriv_sett(a,b)
+
+def foo():
+    print(1)
+    
+print(12)
+
diff --git a/uke42/Python/passordliste.py b/uke42/Python/passordliste.py
new file mode 100644
index 0000000000000000000000000000000000000000..689a0c8d8fcf0f0613cda4e34371283cc9bb121f
--- /dev/null
+++ b/uke42/Python/passordliste.py
@@ -0,0 +1,33 @@
+'''
+Dette er en veldig enkel greie å vise hvordan en kan
+bruke todimensjonale lister for å holde rede på kobling
+mellom to dataverdier. 
+'''
+
+# Leter igjennom passordliste, etter treff
+def finn_passord(passordliste):
+    nettsted = input('Nettsted du vil ha passord til: ')
+    for sted in passordliste:
+        print(sted)
+        if sted[0] == nettsted:
+            return sted[1] # Dette er jo passordet
+    return None # Default
+
+
+liste = [['reddit', '''¯\_(ツ)_/¯'''], ['youtube', 'passordYT!'], \
+         ['ute.no', 'O$teSkrakkeleringsGnøffe_Gnøff'], \
+         ['filateli.no', 'Frimerker4ever']]
+
+
+d = {}
+for sted in liste:
+    d[sted[0]] = sted[1]
+print(sted)
+
+
+for k, v in d.items():
+    
+#    print(f'passordet til {key} er {d[key]}.')
+    print(key, value)
+
+# print('finn_passord: ' + finn_passord(liste))
\ No newline at end of file
diff --git a/uke42/Python/set.py b/uke42/Python/set.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0e51e1bf47a62602edd86721815c485d36eb686
--- /dev/null
+++ b/uke42/Python/set.py
@@ -0,0 +1,14 @@
+import random
+
+# 100 tilfeldige tall 0 - 100 inn i en liste:
+tall = [random.randint(0,100) for i in range(100)]
+
+print("Antall tall:",len(tall))
+tall.sort()
+print("Sorterte tall:", tall)
+
+# Kjører du dette mange ganger, ser du at ulike tall trekkes.
+# Og noen flere ganger. Men det finnes en måte å bare få unike
+# verdier.
+print("Set:", set(tall))
+print("Antall elementer:", len(set(tall)))
diff --git a/uke42/TDT4109_h22_uke34_dicts_n_sets.pdf b/uke42/TDT4109_h22_uke34_dicts_n_sets.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..50ac2ec5bc47197e4300cf1d82f77d926b75181e
Binary files /dev/null and b/uke42/TDT4109_h22_uke34_dicts_n_sets.pdf differ