1
00:01:00,000 --> 00:01:29,000
Nå er det klart å ta dere gjennom hele 1900P, som er i ganske høy hastighet.

2
00:01:31,000 --> 00:01:41,000
Etter åtte meter er vi her i dag for Ole Kristian og Nån.

3
00:01:42,000 --> 00:01:50,000
Dette blir et fokus på pensjonsforskning fra et litt annet perspektiv.

4
00:01:50,000 --> 00:01:55,000
Jeg kan si litt kort om meg selv. Jeg er førstelektor på IFI, Institutt for hypnotikk.

5
00:01:55,000 --> 00:02:03,000
Jeg har en doktorgrad i forskning på undervisning i matematikk og programmering.

6
00:02:07,000 --> 00:02:10,000
Jeg skal ikke si så mye mer om meg selv enn det.

7
00:02:11,000 --> 00:02:14,000
Jeg skal si litt om hva jeg skal snakke om i dag.

8
00:02:16,000 --> 00:02:23,000
Det er mye å snakke om, så jeg skal prøve å dekke det så mye som jeg kan.

9
00:02:24,000 --> 00:02:27,000
Det kommer til å gå noe raskt.

10
00:02:28,000 --> 00:02:33,000
Det går an å se over lyserkenene jeg har legget ut etterpå i råmak og få med seg detaljer.

11
00:02:34,000 --> 00:02:37,000
Det tror jeg vi skal klare greit.

12
00:02:38,000 --> 00:02:42,000
Det er ikke en fullstendig oversikt. Det er ikke noe jeg ikke snakker om i dag.

13
00:02:43,000 --> 00:02:45,000
Det er helt irrelevant for eksamen, sånn er det ikke.

14
00:02:46,000 --> 00:02:50,000
Jeg garanterer ikke at alt dere trenger kommer til å være her i denne repetisjonsforeløsningen.

15
00:02:50,000 --> 00:02:53,000
Jeg skal prøve å få med så mye som mulig.

16
00:03:00,000 --> 00:03:04,000
Jeg kan ikke bruke en hel tid på basics.

17
00:03:05,000 --> 00:03:08,000
For alt andre bygger videre på det.

18
00:03:09,000 --> 00:03:14,000
Det dere har gjort de siste ukene med å lage klasser og jobbe med ODE-solver og den type ting.

19
00:03:15,000 --> 00:03:21,000
Det er mye bruk og anvendelse av det dere har lært tidligere.

20
00:03:24,000 --> 00:03:29,000
Jeg kommer ikke til å gå så fryktelig mye inn på det, men jeg kommer til å bruke en god del tid på det grunnleggende.

21
00:03:30,000 --> 00:03:33,000
Og forståelse av det som alt andre bygger videre på.

22
00:03:33,000 --> 00:03:34,000
Så det er takt.

23
00:03:38,000 --> 00:03:42,000
Det mest elementære er at programmet består av kodlinjer.

24
00:03:43,000 --> 00:03:46,000
I utgangspunktet kjører vi en av en kodlinje gangen opp og ned.

25
00:03:47,000 --> 00:03:48,000
Det finnes unntak.

26
00:03:49,000 --> 00:03:52,000
Du kan hoppe over noen linjer med en ifells.

27
00:03:53,000 --> 00:03:58,000
Hvis du kjører en løkke, kan du gå tilbake og repetere kodlinjen.

28
00:03:59,000 --> 00:04:03,000
Du kan midlertidig gå til et helt annet sted i programmet hvis du har definert en funksjon.

29
00:04:04,000 --> 00:04:06,000
Og så returnerer du tilbake til senere.

30
00:04:08,000 --> 00:04:10,000
Hvorfor snakke om det?

31
00:04:11,000 --> 00:04:16,000
En del av det dere blir testet i på eksamen er om dere klarer å lese programkodene og forstå hva som skjer.

32
00:04:17,000 --> 00:04:23,000
Det å kunne vite hvilke kodlinjer som kjøres når, er nyttig ikke bare for å forstå et program,

33
00:04:23,000 --> 00:04:28,000
men også for å finne feil i koden som også kan være i eksamen selv.

34
00:04:29,000 --> 00:04:35,000
Dere har sikkert sett på noen av eksamenne på tidligere semester, så jeg har noen eksempler på det.

35
00:04:37,000 --> 00:04:41,000
En annen grunnleggende nytting er dette vi kaller for tilordningen.

36
00:04:42,000 --> 00:04:44,000
At en variabel får en verdi.

37
00:04:45,000 --> 00:04:55,000
Det er ganske kjekt, for hvis vi lager en verdi i en variabel, kan vi gjenbruke en verdi senere i programmet.

38
00:04:57,000 --> 00:05:00,000
Hva vi kaller en variabel er ikke så viktig for datamaskinen.

39
00:05:01,000 --> 00:05:06,000
Vi kan kalle det nesten hva som helst, men for mennesker som skal lese og forstå koden og skjønne hva det handler om,

40
00:05:07,000 --> 00:05:09,000
er det stor betydning at vi kaller variablene det.

41
00:05:10,000 --> 00:05:14,000
Det er nesten sånn at i 1900 søndet vi litt mot best practice,

42
00:05:15,000 --> 00:05:21,000
for vi bruker ofte veldig matematiske variabler som x og y, s og t og u.

43
00:05:22,000 --> 00:05:25,000
Det kan være litt vanskelig å forstå for noen uinvidde,

44
00:05:26,000 --> 00:05:29,000
så i den virkelige verden må vi gjerne bruke bedre beskrivende variabler enn det.

45
00:05:31,000 --> 00:05:33,000
Det finnes noen unntak.

46
00:05:34,000 --> 00:05:36,000
Vi kan ikke kalle variabler for while, for or if og den type ting,

47
00:05:36,000 --> 00:05:41,000
for det er reservert for spesielle ting.

48
00:05:42,000 --> 00:05:48,000
Det er dermed at hvis du, uten å menende gjenbruke et variabel,

49
00:05:49,000 --> 00:05:53,000
du overskriver en variabel du hadde fra før, uten at du eklever meningen,

50
00:05:54,000 --> 00:05:55,000
så kan du få ganske interessante bugs.

51
00:05:56,000 --> 00:06:00,000
Jeg hadde et eksempel hvor jeg brukte variabelen c i ABC-formelen for å løse en angradsligning,

52
00:06:01,000 --> 00:06:03,000
og senere i samme program skulle c være lyshastigheten,

53
00:06:03,000 --> 00:06:05,000
og den ble da litt null.

54
00:06:06,000 --> 00:06:09,000
Det førte til litt merkelige resultater.

55
00:06:13,000 --> 00:06:15,000
Sånn sett har det betydning.

56
00:06:16,000 --> 00:06:20,000
Etter at en variabel har blitt gitt en verdi etter en tillåning,

57
00:06:21,000 --> 00:06:25,000
så vet Python hvor i minnet på maskinen denne verdien befinner seg,

58
00:06:26,000 --> 00:06:27,000
eller det her objektet befinner seg.

59
00:06:28,000 --> 00:06:30,000
Nå har vi snakket litt om klasser og objekter de siste uka,

60
00:06:30,000 --> 00:06:34,000
og når jeg sier verdi i Python, så mener jeg egentlig et objekt.

61
00:06:35,000 --> 00:06:36,000
Alt er objekter.

62
00:06:37,000 --> 00:06:41,000
Int, string, float, alt det der er objekter faktisk.

63
00:06:44,000 --> 00:06:49,000
Så variabelen sier bare at på denne adressen i minnet ligger verdien min,

64
00:06:50,000 --> 00:06:54,000
og når du kommer dit finner du et eller annet objekt som jeg da kaller for en verdi.

65
00:06:55,000 --> 00:06:58,000
Det som er litt kjekt nå å ta en sånn oppsummering på slutten av semesteret,

66
00:06:58,000 --> 00:07:00,000
selv om vi går gjennom de mest grunnleggende tingene,

67
00:07:01,000 --> 00:07:03,000
så kan vi nå se tilbake på det med det vi vet i dag.

68
00:07:04,000 --> 00:07:05,000
Vi vet litt om objektet, ikke sant?

69
00:07:06,000 --> 00:07:09,000
Så det blir en litt annen tilåning enn det dere fikk helt innledningsvis.

70
00:07:12,000 --> 00:07:14,000
Ja, evaluering av uttrykk er en viktig ting.

71
00:07:16,000 --> 00:07:19,000
Altså, den verdien vi gitt en variabel kan også være resultatet av en utregning.

72
00:07:23,000 --> 00:07:26,000
Og regnvekkfølgen er stort sett som forventet fra matematikken.

73
00:07:28,000 --> 00:07:31,000
Ser dere noe gærent i den tilåningen her øverst?

74
00:07:37,000 --> 00:07:38,000
Det mangler noen parenteser der.

75
00:07:40,000 --> 00:07:42,000
Så det er viktig å huske at når du har en brukstrek på papir,

76
00:07:43,000 --> 00:07:46,000
så impliserer det at det er en parentes i telleren når du nevner den alltid.

77
00:07:47,000 --> 00:07:48,000
Vi bare skriver den ikke.

78
00:07:49,000 --> 00:07:52,000
Det er liksom en matematisk tradisjon over flere ev.

79
00:07:53,000 --> 00:07:56,000
I programmering så kommer alt på samme linje, så der må vi faktisk gjøre det.

80
00:07:57,000 --> 00:08:00,000
Verdiaverna har type, og disse oppfører seg forskjellig.

81
00:08:01,000 --> 00:08:06,000
Selv om i Python du kan bare lage en variabel og si at denne kan få hva som helst verdi,

82
00:08:07,000 --> 00:08:12,000
så er det en type der som den verdien har, eller det objektet har.

83
00:08:14,000 --> 00:08:16,000
Og vi kan se at de oppfører seg litt forskjellig.

84
00:08:17,000 --> 00:08:22,000
Hvis vi plusserer plusstegn mellom to heltal, så legges de sammen.

85
00:08:23,000 --> 00:08:27,000
Det samme kan skje med to decimaltal, men her kan vi plutselig få en avrundingsfeil.

86
00:08:31,000 --> 00:08:32,000
Det er en liten forskjell.

87
00:08:33,000 --> 00:08:36,000
Gjør vi det mellom to strenger, så får vi plutselig de satt etter hverandre.

88
00:08:37,000 --> 00:08:38,000
Det er en litt annen oppførsel igjen.

89
00:08:39,000 --> 00:08:43,000
Gjør vi det med to lister, så vil de slå sammen til en stor liste.

90
00:08:45,000 --> 00:08:47,000
Med elementene i den første og i den siste.

91
00:08:48,000 --> 00:08:51,000
Sprenga og lister er eksempel på samlinger med flere element.

92
00:08:52,000 --> 00:08:57,000
Du har ikke bare ett objekt der.

93
00:08:58,000 --> 00:09:02,000
Du har en samling som inneholder referanser til flere andre objekt inni seg.

94
00:09:03,000 --> 00:09:07,000
Det er en veldig nyttig ting.

95
00:09:09,000 --> 00:09:13,000
Det vi kaller for operatorer, pluss, minus, gange, dele, potens,

96
00:09:13,000 --> 00:09:18,000
og alle disse lik, ulik, større, mindre, som sammenligner verdiene.

97
00:09:19,000 --> 00:09:22,000
De vil ofte gjøre forskjellige ting med forskjellige typer av objekt.

98
00:09:23,000 --> 00:09:29,000
Det er viktig å ha et bilde av hva slags typeverdi denne variabelen har.

99
00:09:30,000 --> 00:09:33,000
En del andre programmeringsplanser må si at dette skal være et heltal,

100
00:09:34,000 --> 00:09:36,000
og dette skal være en float.

101
00:09:37,000 --> 00:09:39,000
I Python er det veldig fleksibelt.

102
00:09:39,000 --> 00:09:43,000
En variabel kan bytte type plutselig underveis i programmet.

103
00:09:44,000 --> 00:09:47,000
Det er mye frihet, og derfor er det også mye som kan gjøres.

104
00:09:48,000 --> 00:09:54,000
Vi kan sjekke hvilken type eller hvilken klasse et objekt er.

105
00:09:55,000 --> 00:09:58,000
Jeg bruker funksjon type, og så putter jeg inn variabelen her,

106
00:09:59,000 --> 00:10:03,000
så ser vi hva slags typeverdi denne variabelen har.

107
00:10:03,000 --> 00:10:11,000
Vi kan også konvertere mellom typer, gjøre noe fra en type til en annen.

108
00:10:12,000 --> 00:10:20,000
Et eksempel er hvis jeg bruker int-funksjonen på en float-verdi,

109
00:10:21,000 --> 00:10:24,000
så får vi et heltalsobjekt ut av det.

110
00:10:25,000 --> 00:10:32,000
Int er faktisk også konstruktøren til interflaten, som kalles det.

111
00:10:33,000 --> 00:10:34,000
Det er en implicit.

112
00:10:35,000 --> 00:10:36,000
Vi går tilbake til den.

113
00:10:37,000 --> 00:10:44,000
Man kan bruke for eksempel round til å gjøre det samme.

114
00:10:45,000 --> 00:10:50,000
Der int bare kapper av alt etter decimaltenene,

115
00:10:51,000 --> 00:10:53,000
og bare beholder heltals-telen, så tar jeg round og runder av til nærmeste,

116
00:10:54,000 --> 00:10:55,000
og gjør det på en litt annen måte.

117
00:10:56,000 --> 00:11:02,000
I tillegg kan du også ta et decimaltall og gjøre det til et decimaltall med ferre.

118
00:11:03,000 --> 00:11:07,000
Siffer etter decimaltenene, så det er ikke bare til heltall.

119
00:11:08,000 --> 00:11:11,000
Hvis du bruker konstruktøren til string,

120
00:11:12,000 --> 00:11:18,000
kaller du denne funksjonen, så får du en streng med tekst ut av et tall.

121
00:11:19,000 --> 00:11:24,000
Vi kan be peisene om å gjøre denne typen til en annen type.

122
00:11:25,000 --> 00:11:30,000
Men det kan hende at det er implicit, uten at vi har bedt om at det skal skje.

123
00:11:30,000 --> 00:11:33,000
Det skjer automatisk, og det er greit å være klar over.

124
00:11:34,000 --> 00:11:39,000
Hvis vi tar to ...

125
00:11:43,000 --> 00:11:47,000
Skal vi se ... Jeg roter alltid med peisen to og tre.

126
00:11:51,000 --> 00:11:55,000
Hvis vi tar og deler to heltall på hverandre,

127
00:11:56,000 --> 00:12:02,000
vil det ofte gjøres til det er flyttball, og så har det regnet seg ut.

128
00:12:03,000 --> 00:12:06,000
Så du får svaret som en flote.

129
00:12:07,000 --> 00:12:10,000
Men du bruker i minst heltallstilvisjonen, som du også kan gjøre.

130
00:12:11,000 --> 00:12:15,000
Hvis vi tar to bolskeverdier, som er enten true eller false,

131
00:12:16,000 --> 00:12:20,000
tar true pluss true, så gjøres det til heltall, altså en,

132
00:12:21,000 --> 00:12:22,000
og så får du svaret to.

133
00:12:22,000 --> 00:12:27,000
Der skjer det en konvertering i en regnapperasjon under panslet.

134
00:12:28,000 --> 00:12:30,000
Det er nyttig å være klar over når de forekommer.

135
00:12:33,000 --> 00:12:36,000
For at et program skal kunne skrive ut noe fornuftig til skjermen,

136
00:12:37,000 --> 00:12:41,000
så er det greit å kunne skrive ut ting, og det er mange måter å gjøre det på.

137
00:12:42,000 --> 00:12:45,000
Hvis vi skal skrive ut en setning med verdiene av en variabel,

138
00:12:46,000 --> 00:12:52,000
så vil alle disse tre måtene, her er linje 2 til 4, gjøre det på akkurat samme måte.

139
00:12:53,000 --> 00:12:56,000
Det er flere måter å gjøre det på, det er greit å kjenne til dem.

140
00:12:57,000 --> 00:13:02,000
Den siste måten med formateringssyntaks har den ekstra fordelen

141
00:13:03,000 --> 00:13:05,000
at du kan kontrollere hvor mange decimaler du får i svaret,

142
00:13:06,000 --> 00:13:07,000
uten at du trenger å endre selve verdien.

143
00:13:08,000 --> 00:13:09,000
Du kan få selv utskrifter til å notere det,

144
00:13:10,000 --> 00:13:13,000
mens verdien til variabelen blir urørt, og det er ganske nice.

145
00:13:15,000 --> 00:13:25,000
Det å kunne importere funksjoner og klasser fra pakker,

146
00:13:26,000 --> 00:13:27,000
så å bruke koder som andre har laget før deg,

147
00:13:28,000 --> 00:13:31,000
eller kanskje din egen kode til og med, er nyttig å kjenne til.

148
00:13:32,000 --> 00:13:35,000
Der er det noen ting som er greit å være klare ved.

149
00:13:36,000 --> 00:13:40,000
Hvis jeg skal importere fra pakken, eller fra biblioteket Math,

150
00:13:41,000 --> 00:13:43,000
gjøre det på denne måten,

151
00:13:43,000 --> 00:13:47,000
må jeg skrive Math foran alt jeg henter fra den pakken.

152
00:13:48,000 --> 00:13:50,000
For eksempel Math.scrote.

153
00:13:51,000 --> 00:13:56,000
Jeg kan ikke bare bruke scrote, for da kjenner man ikke igjen det navnet.

154
00:13:57,000 --> 00:13:59,000
Alternativt kan jeg skrive for Math.importscrote,

155
00:14:00,000 --> 00:14:02,000
og da kan jeg bruke det direkte med scrote,

156
00:14:03,000 --> 00:14:05,000
men da kan jeg ikke bruke det med Math foran.

157
00:14:06,000 --> 00:14:07,000
Det er litt mentinelle.

158
00:14:08,000 --> 00:14:10,000
Det er en sånn veldig greit å være klar av.

159
00:14:10,000 --> 00:14:13,000
Ikke lurt å importere absolutt alt fra en pakke.

160
00:14:14,000 --> 00:14:16,000
Du får masse ting du ikke trenger, det er noen ene ting.

161
00:14:17,000 --> 00:14:22,000
Men det finnes mange klasser og funksjoner som oppfører seg helt forskjellige,

162
00:14:23,000 --> 00:14:24,000
men som har samme navn,

163
00:14:25,000 --> 00:14:28,000
så som både Math og Numpy har Squared, for eksempel.

164
00:14:29,000 --> 00:14:32,000
Forskjellige blant annet at en Numpy-versjon fungerer på Airbrakes.

165
00:14:35,000 --> 00:14:37,000
Det er kanskje det Mathen gjør da, da jeg ikke tester.

166
00:14:37,000 --> 00:14:39,000
Men det kan være andre forskjellige ting som er viktige.

167
00:14:40,000 --> 00:14:43,000
Du bør vite hva det er du har importert, og hvor det kommer fra.

168
00:14:44,000 --> 00:14:46,000
At du ikke har masse ting som kan hete det samme.

169
00:14:47,000 --> 00:14:49,000
Det blir jo sånn at det siste du importerer,

170
00:14:50,000 --> 00:14:52,000
vil overskride det første hvis ting har akkurat samme navn.

171
00:14:53,000 --> 00:14:55,000
Så det er greit å være påpasset med sånt.

172
00:15:00,000 --> 00:15:01,000
Vi bruker...

173
00:15:02,000 --> 00:15:03,000
Jeg skal teste.

174
00:15:04,000 --> 00:15:07,000
Jeg skal snakke litt om if-else og sånne forgreninger av valg,

175
00:15:08,000 --> 00:15:10,000
og jeg skal snakke litt om while-løkka og andre løkka.

176
00:15:11,000 --> 00:15:15,000
Men det while- og if- og erlig-svar tilfellet er at du gjør en liten test på om noe er sant eller ikke.

177
00:15:17,000 --> 00:15:20,000
Og da vil det enten alltid lykkes, eller mislykkes.

178
00:15:21,000 --> 00:15:23,000
Du får aldri kanskje sånn svar.

179
00:15:25,000 --> 00:15:28,000
Til disse testerne bruker vi ofte å prate som sammenhengende.

180
00:15:28,000 --> 00:15:32,000
Vi prater om om de er like ulike, om en er større eller mindre enn andre, og så videre.

181
00:15:34,000 --> 00:15:38,000
Vi kan ta og slå sammen flere tester til en større test.

182
00:15:39,000 --> 00:15:41,000
Nå bruker jeg And eller Or.

183
00:15:42,000 --> 00:15:45,000
Og de bør du ikke vite hvordan fungerer.

184
00:15:46,000 --> 00:15:48,000
Vi kan også gjøre motsatte tester.

185
00:15:49,000 --> 00:15:52,000
Man kan teste om noe ikke fungerer, sånn at du får True hvis det fungerer.

186
00:15:53,000 --> 00:15:55,000
Men det er ikke så viktig å gjøre det.

187
00:15:55,000 --> 00:15:59,000
Vi kan også gjøre en liten test, og teste om noe ikke fungerer, sånn at du får True hvis det lykkes.

188
00:16:00,000 --> 00:16:04,000
Og Folk hvis det lykkes, hvis vi bruker en Not-operator.

189
00:16:09,000 --> 00:16:11,000
Så litt mer spesifikt.

190
00:16:12,000 --> 00:16:16,000
Det er gøy å vite hvordan disse if- eller erlig-blokkene med kode fungerer.

191
00:16:20,000 --> 00:16:23,000
Så vi tar og skriver if, og så gjør vi en annen test.

192
00:16:24,000 --> 00:16:31,000
Det som da hamner under den koden som hører til den if-testen, kjører hvis og bare hvis testen lykkes.

193
00:16:34,000 --> 00:16:45,000
Og hvis den misslykkes, den if-testen, test 1, da kan vi kjøre en eller if-test 2.

194
00:16:46,000 --> 00:16:51,000
Det som er viktig å vite er at test 2 kjøres bare hvis test 1 feiler.

195
00:16:52,000 --> 00:16:58,000
Hvis test 1 blir True, så gjør vi det som stod under if, og så er vi ferdig med hele blokket og bare går videre.

196
00:16:59,000 --> 00:17:04,000
Test 2 kjøres aldri. Det er ikke noe vits i, fordi vi har allerede hatt en suksess lenger opp.

197
00:17:07,000 --> 00:17:13,000
Og en else-statement nederst i en if- eller if-blokk vil bare kjøre hvis alle testeren,

198
00:17:13,000 --> 00:17:18,000
altså en if-test og en el-if-test og kanskje to-tre el-if-tester opptil,

199
00:17:18,000 --> 00:17:22,000
hvis alle de misslykkes, kun da føres den koden som står under else.

200
00:17:23,000 --> 00:17:24,000
Ikke så hoppes det bare over.

201
00:17:25,000 --> 00:17:29,000
Er dere litt usikre på dette, så ta gjerne en sånn lang if- eller if-else,

202
00:17:29,000 --> 00:17:33,000
og så gå gjennom i Python Tutor og se noen eksempler på det,

203
00:17:33,000 --> 00:17:37,000
så vil dere få en følelse av hvordan det fungerer.

204
00:17:38,000 --> 00:17:45,000
Lukka er veldig kjekke, og de la oss repetere ting.

205
00:17:45,000 --> 00:17:48,000
Da får vi kortere og mer oversiktlige program.

206
00:17:49,000 --> 00:17:52,000
Ikke bare det, det er også lettere å endre ting et sted i en lukke,

207
00:17:52,000 --> 00:17:57,000
enn å gå gjennom hundre forskjellige steder og skulle endre noe som var gærent.

208
00:17:57,000 --> 00:17:59,000
Det gjør det jo mye lettere å likeholde.

209
00:17:59,000 --> 00:18:04,000
Vi kan repetere helt identisk kode mange ganger etter hverandre,

210
00:18:04,000 --> 00:18:08,000
etter behov, eller vi kan ha litt variasjon hver gang.

211
00:18:08,000 --> 00:18:10,000
Noe blir forskjellig hver gang vi repeterer ting.

212
00:18:12,000 --> 00:18:14,000
Hvor mange lukker kan vi bruke?

213
00:18:14,000 --> 00:18:17,000
Alltid, når vi skal repetere noe.

214
00:18:18,000 --> 00:18:21,000
De mest generelle lukka fungerer bestående.

215
00:18:22,000 --> 00:18:26,000
Forlukka er litt lettere å skrive i, de er litt mer spesialisert,

216
00:18:26,000 --> 00:18:30,000
de kan ikke alltid brukes, det finnes situasjoner der forlukket ikke fungerer.

217
00:18:31,000 --> 00:18:33,000
Men de er ofte noe enklere.

218
00:18:34,000 --> 00:18:40,000
Ofte er det også sånn at den ene type lukka er mest naturlig å bruke i et program.

219
00:18:41,000 --> 00:18:44,000
Vi kommer tilbake til de nå straks.

220
00:18:45,000 --> 00:18:51,000
Men det å innholde en lukka, det som vi repeterer, kan også være alt mulig.

221
00:18:51,000 --> 00:18:54,000
Det kan være nye lukka inne i der, det kan være nye lukka.

222
00:18:54,000 --> 00:18:56,000
Det kan være nye lukka inne i der, kan det være.

223
00:18:57,000 --> 00:19:01,000
Det kalles en nøsta lukke, en lukke inne i en lukke, rett og slett.

224
00:19:09,000 --> 00:19:14,000
Disse varelukka, vi kan tenke på det som en if-test som bare kjører om og om igjen.

225
00:19:14,000 --> 00:19:17,000
Helt tendelig, endelig, går galt.

226
00:19:18,000 --> 00:19:22,000
Så lenge den får vært igjen true, så vil det bare fortsette.

227
00:19:22,000 --> 00:19:26,000
Jeg liker å tenke på det som en liten barn som bare maser og er vi fremme nå da?

228
00:19:26,000 --> 00:19:28,000
Er vi fremme nå da?

229
00:19:29,000 --> 00:19:32,000
Som bare sitter og maser i baksetet og bare har lyst til å være fremme.

230
00:19:34,000 --> 00:19:36,000
Det er en ganske godt bilde på et varelukke, synes jeg.

231
00:19:37,000 --> 00:19:40,000
Da trenger vi ikke vite på fordelen med mange repetisjoner når lukka skal gå.

232
00:19:41,000 --> 00:19:44,000
En varelukke kan bare teste noe helt til det ikke går lenger.

233
00:19:45,000 --> 00:19:49,000
Så er det litt sånn, kommer det her til å gå 20 eller 1000 ganger, vi vet ikke.

234
00:19:49,000 --> 00:19:51,000
Vi bare fortsetter så lenge tidet tar.

235
00:19:52,000 --> 00:19:57,000
Problemet er at du kan lage en uendelig varelukke hvis du lager en test som aldri feiler av en annen grunn.

236
00:20:02,000 --> 00:20:07,000
For å unngå det, hvis du bruker en variabel og tester verdien på den i en varelukke,

237
00:20:07,000 --> 00:20:11,000
sørg for at verdien aldri endrer seg på noen tidspunkt.

238
00:20:11,000 --> 00:20:16,000
Hvis du tester en verdi og den aldri endrer seg, så vil du enten aldri kjøre innholdet i lukka,

239
00:20:16,000 --> 00:20:18,000
eller kjøre det til evig tid.

240
00:20:18,000 --> 00:20:21,000
Det er greit da. Pass på.

241
00:20:23,000 --> 00:20:25,000
Fordelukke.

242
00:20:27,000 --> 00:20:31,000
De er de spesialiserte. De kan ikke gjøre alt.

243
00:20:31,000 --> 00:20:35,000
De kan egentlig bare gjøre en eneste ting, men den tingen er de god på.

244
00:20:35,000 --> 00:20:39,000
De tar en samling med element, sånn som en liste eller en string,

245
00:20:39,000 --> 00:20:42,000
og så bare går de gjennom fra start til slutt.

246
00:20:46,000 --> 00:20:49,000
Liste, ordbøker, strings, range.

247
00:20:50,000 --> 00:20:53,000
Alt mulig å stoppe automatisk når vi går gjennom hele.

248
00:20:53,000 --> 00:20:57,000
I utgangspunktet med en fordelukke må vi vite hvor mange repetisjoner vi skal gjøre,

249
00:20:57,000 --> 00:21:01,000
for vi har en samling element, og vet vi hvor mange som er inne der,

250
00:21:01,000 --> 00:21:03,000
så vet vi hvor mange repetisjoner det blir.

251
00:21:04,000 --> 00:21:07,000
Unntaket, altså eneste måte å lage noe endelig i fordelukke på,

252
00:21:07,000 --> 00:21:11,000
er at du hele tiden legger til noe i lista mens du går gjennom.

253
00:21:11,000 --> 00:21:17,000
Hver gang du går ett skritt gjennom lista, så har du plutselig dukket opp to nye element på slutten.

254
00:21:17,000 --> 00:21:20,000
Da klarer du å lage noe endelig i fordelukke, men det skal godt gjøres,

255
00:21:20,000 --> 00:21:22,000
da du nesten gjør det med vilje.

256
00:21:22,000 --> 00:21:24,000
Det er ikke særlig lurt, tror jeg.

257
00:21:25,000 --> 00:21:28,000
Hvis du skal gjøre det, så bør du vite hva du gjør.

258
00:21:29,000 --> 00:21:31,000
Så vil ikke anbefale det.

259
00:21:34,000 --> 00:21:37,000
Stort sett vil jo ikke det skje.

260
00:21:38,000 --> 00:21:42,000
Ulempe med en fordelukke er at du ikke kan håndtere alle tilfellene som vardelukker kan.

261
00:21:42,000 --> 00:21:44,000
For vardelukker kan bare teste hva som helst.

262
00:21:44,000 --> 00:21:47,000
En fordelukke må forholde seg til en samling med element.

263
00:21:48,000 --> 00:21:51,000
Så det å repetere et eller annet til brukeren skriver en ny linnputt, for eksempel,

264
00:21:51,000 --> 00:21:54,000
er vanskeligere enn en fordelukke.

265
00:21:54,000 --> 00:21:58,000
Eller hvis du skal bare kjøre koden inn til klokka blir fire, så stopper programmet.

266
00:21:59,000 --> 00:22:02,000
Det er også vanskelig for en fordelukke, fordi du vet ikke hvor mange repetisjoner det blir.

267
00:22:02,000 --> 00:22:04,000
Det kan komme han på hvor rask maskinen er, for eksempel.

268
00:22:05,000 --> 00:22:07,000
Så vardelukker kan brukes til mer.

269
00:22:10,000 --> 00:22:13,000
Nå har jeg snakket litt om lista, så skal jeg si litt mer om dem.

270
00:22:15,000 --> 00:22:21,000
Liste er en samling med element som kan ha hvilken som helst type.

271
00:22:21,000 --> 00:22:25,000
Du kan ha flere typer av samlinger, og det er ganske fleksibelt.

272
00:22:25,000 --> 00:22:28,000
Du kan til og med ha en ny liste inn i en liste.

273
00:22:30,000 --> 00:22:33,000
Disse elementene i en liste vil alltid være en bestemt vekkfølgering.

274
00:22:33,000 --> 00:22:37,000
Altså posisjonen i en liste er ananismetall, som vi kaller for en indeks.

275
00:22:37,000 --> 00:22:41,000
Første element for indeks 0, andre element for indeks 1.

276
00:22:42,000 --> 00:22:45,000
Så kan vi eventuelt telle bakover i stedet.

277
00:22:46,000 --> 00:22:48,000
Siste element er indeks minus 1.

278
00:22:49,000 --> 00:22:53,000
Nest siste element er indeks minus 2, og så videre.

279
00:22:53,000 --> 00:22:56,000
Så det er to forskjellige tellemåter.

280
00:22:59,000 --> 00:23:06,000
Hvis vi vet at det er tre element i en liste, så vil indeks 2 være det siste elementet.

281
00:23:06,000 --> 00:23:08,000
Men man kan også bruke minus 1.

282
00:23:08,000 --> 00:23:13,000
Det er litt avhengig av hvilken side av lista man vil telle frem, men det er i hvert fall et valg.

283
00:23:15,000 --> 00:23:18,000
Lister kan gjøre mange ting.

284
00:23:18,000 --> 00:23:21,000
En av de tingene vi kan, som vi bruker ofte, er en pend.

285
00:23:22,000 --> 00:23:27,000
Det tar et land av element og legger til sist bakover til liste.

286
00:23:29,000 --> 00:23:35,000
Hvis vi skal bruke en liste til for eksempel plotting, så vil vi ofte starte med en pom-liste, og så helt til appendet bakover.

287
00:23:36,000 --> 00:23:39,000
Det er bedre å bruke arrays, for de er ofte raskere.

288
00:23:40,000 --> 00:23:44,000
Nå må vi vel enten gjøre det om til en array, eller så blir det gjort for oss.

289
00:23:52,000 --> 00:23:54,000
Hva skjer når vi kombinerer løkene av lister?

290
00:23:56,000 --> 00:24:02,000
Hvis vi bruker en forløk til dette, så skal vi få elementet inn i liste.

291
00:24:02,000 --> 00:24:06,000
Her har jeg valgt variablerne min, så det er veldig beskrivende det som skjer.

292
00:24:08,000 --> 00:24:19,000
Første gang innholdet i løk og kjøret, så vil elementet få verdien som ligger i index 0 på liste.

293
00:24:20,000 --> 00:24:23,000
Andre gang vil elementet få verdien som ligger på index 1.

294
00:24:24,000 --> 00:24:28,000
Sånn fortsetter det helt til vi er på det siste elementet, ferdig etter det.

295
00:24:29,000 --> 00:24:42,000
Alternativt, hvis vi ikke har lyst til å jobbe med elementene i liste direkte, så kan vi, som et spesialt tilfelle, lage oss en liste med indekser.

296
00:24:43,000 --> 00:24:47,000
Først tar vi lengden av liste, for å finne ut hvor mange elementer det er.

297
00:24:48,000 --> 00:24:55,000
Så bruker vi en range til å lage en liste med indekser som har den lengden.

298
00:24:55,000 --> 00:25:00,000
Hvis vi har range 3, så vil rangen inneholde 0, 1 og 2.

299
00:25:01,000 --> 00:25:04,000
Da lager vi en liste med indekser som denne liste har.

300
00:25:07,000 --> 00:25:12,000
Historiske grunner er vanlig å bruke i for index.

301
00:25:13,000 --> 00:25:17,000
Første gang løket går, så vil i få verdien 0, andre gang vil i få verdien 1.

302
00:25:18,000 --> 00:25:23,000
Sånn kan vi gå gjennom indexene til en liste, i stedet for å gå gjennom elementene direkte.

303
00:25:24,000 --> 00:25:26,000
Vi kan også hente ut elementene etterpå.

304
00:25:27,000 --> 00:25:33,000
Inni løkket, hvis vi skriver elementer, eller gikk liste, så får vi hente ut de elementene vi er på akkurat nå.

305
00:25:37,000 --> 00:25:39,000
Nå skal vi bruke det siste.

306
00:25:40,000 --> 00:25:43,000
Det kan være at vi skal gjøre noe med fordi-element samtidig.

307
00:25:44,000 --> 00:25:47,000
Vi skal begynne med fibonacci, og legge sammen i-1 og i-2.

308
00:25:48,000 --> 00:25:52,000
Da må du holde styr på hvor mye i liste du har. Du må holde styr på mer enn et element.

309
00:25:53,000 --> 00:25:57,000
Det kan virke unødig komplisert, men det er noen fordeler med det også.

310
00:26:01,000 --> 00:26:06,000
Noe som nesten alle synes er mystisk, med god grunn. Det er ikke trivielt.

311
00:26:08,000 --> 00:26:13,000
Hvis jeg har hentet ut et element fra en liste, og lagret det i en variabel som heter element.

312
00:26:15,000 --> 00:26:19,000
Så tar jeg og skriver at element er like element pluss 2.

313
00:26:20,000 --> 00:26:23,000
Da har variablene element for å endre verdien sin.

314
00:26:26,000 --> 00:26:30,000
Men lista ser akkurat ut som før. Det har ikke skjedd noen verdens ting.

315
00:26:31,000 --> 00:26:34,000
Det synes mange er sært, og det er forståelig.

316
00:26:35,000 --> 00:26:39,000
Det har litt å gjøre med at disse variablene innholder ikke verdien direkte.

317
00:26:40,000 --> 00:26:45,000
De inneholder en referanse til et eller annet sted i minnet på datamaskinen, der det objektet ligger.

318
00:26:50,000 --> 00:26:53,000
Et banalt eksempel er en liste med fire tal.

319
00:26:56,000 --> 00:27:00,000
Så sier vi at element skal være liste hvis vi går på index 2.

320
00:27:02,000 --> 00:27:06,000
Da får vi verdien 3.

321
00:27:09,000 --> 00:27:12,000
Men variablene element peker opp til en eller annen adresse i minnet.

322
00:27:13,000 --> 00:27:15,000
Der ligger verdien 3.

323
00:27:16,000 --> 00:27:23,000
Liste med index 2 peker også opp til den samme adressen i minnet, der den samme verdien ligger.

324
00:27:25,000 --> 00:27:30,000
Så det er egentlig to variabler som peker på samme sted, på samme ting.

325
00:27:32,000 --> 00:27:35,000
Hvis jeg nå gjør dette element er like element pluss 2.

326
00:27:35,000 --> 00:27:50,000
Så det som er viktig å forstå der er at da vil jeg ikke endre den verdien som ligger på den minneadressen.

327
00:27:51,000 --> 00:27:53,000
For Python har bestemt at 3 ligger der.

328
00:27:54,000 --> 00:27:58,000
Så jeg tar element, og er like element pluss 2, så har jeg endret 3 pluss 2, får verdien 5.

329
00:27:58,000 --> 00:28:06,000
Så vet Python at nå er det verdien 5 vi skal ha, og den ligger et annet sted.

330
00:28:08,000 --> 00:28:13,000
Så variablene element har fått en ny verdi som ligger på et annet sted i minnet.

331
00:28:17,000 --> 00:28:22,000
Mens liste med index 2 peker fortsatt på den samme adressen og den samme verdien som var der før.

332
00:28:23,000 --> 00:28:26,000
Vi har bare endret elementet, vi har ikke endret liste i det hele tatt.

333
00:28:28,000 --> 00:28:34,000
Det å forstå det er en ting jeg har tatt kjempenyttig, hvis du skal finne rare feil i programmen din.

334
00:28:35,000 --> 00:28:37,000
Det er en veldig vanlig kjelletefeil.

335
00:28:38,000 --> 00:28:44,000
Men det kan også være viktig for å lese og forstå hvordan dere skal jobbe med t-eksamen.

336
00:28:44,000 --> 00:28:59,000
Selv om to variabler peker på den samme verdien, hvis vi endrer en av dem, så vil det ikke skje noe med den andre.

337
00:29:00,000 --> 00:29:01,000
Da må vi endre den også.

338
00:29:01,000 --> 00:29:03,000
Jeg tror jeg har sagt det viktigste.

339
00:29:04,000 --> 00:29:06,000
At jeg sier videre vil kanskje være overkomplisert.

340
00:29:07,000 --> 00:29:13,000
Hvis vi hadde sagt at liste 2, verdien med liste med index 2, skal være like verdien med liste med index 2 pluss 2,

341
00:29:14,000 --> 00:29:21,000
da ville vi gjort det motsatt, og da ville vi endret hva liste 2 og liste 2 med index 2 skulle være.

342
00:29:21,000 --> 00:29:25,000
Hvis verdien med liste med index 2, skal være like verdien med liste med index 2 pluss 2,

343
00:29:26,000 --> 00:29:31,000
da ville vi gjort det motsatt, og da ville vi endret hva liste 2 pekte på,

344
00:29:32,000 --> 00:29:35,000
men variablen element ville vært uendret av fortsatt at verdien 3.

345
00:29:36,000 --> 00:29:38,000
Så det motsatte vil også.

346
00:29:39,000 --> 00:29:43,000
Det er ikke noe magisk med lister, det er bare sånn referanser fungerer i Python.

347
00:29:43,000 --> 00:29:44,000
Det er bare sånn.

348
00:29:59,000 --> 00:30:01,000
Referanse mot kopi har jeg skrevet her.

349
00:30:03,000 --> 00:30:07,000
Her er et eksempel på to variabler som peker på det samme objektet.

350
00:30:07,000 --> 00:30:13,000
Her er en liste, vi først gir variablen A verdi, her er en liste som vi lager,

351
00:30:14,000 --> 00:30:21,000
og så setter vi B like A, da har vi to variabler A og B som begge peker på den samme adressen i minnet.

352
00:30:22,000 --> 00:30:26,000
Så to variabler kan fint ha den samme verdien.

353
00:30:27,000 --> 00:30:31,000
Det er bare en adresse til hvor i minnet det ligger, ikke noe problem.

354
00:30:32,000 --> 00:30:36,000
Hvis vi derimot bruker en sånn pumped slice, eller hva vi nå skal kalle det,

355
00:30:37,000 --> 00:30:42,000
akkurat som kolon, så vil det lages en kopi av lista A.

356
00:30:45,000 --> 00:30:48,000
Denne kopien blir da verdien til variablen B.

357
00:30:49,000 --> 00:30:53,000
Da vil disse to listene ligge på forskjellige adresser i minnet,

358
00:30:54,000 --> 00:30:57,000
og de vil leve uavhengig av hverandre.

359
00:30:58,000 --> 00:31:02,000
Det viktigste er forskjell på to av variabler som er referert til samme ting,

360
00:31:03,000 --> 00:31:07,000
og to variabler hvor en har referert til originalen og en referert til kopien.

361
00:31:11,000 --> 00:31:14,000
Hvis vi prøver å endre det første elementet til fire,

362
00:31:15,000 --> 00:31:18,000
i det øverste tilfellet hvor begge peker på den samme lista,

363
00:31:19,000 --> 00:31:21,000
så vil begge variabler bli endret her.

364
00:31:22,000 --> 00:31:25,000
Fordi den ene lista som de peker på, den er blitt endret.

365
00:31:26,000 --> 00:31:29,000
Men i tilfellet nummer to, så er det bare originalen vi kommer til å endre,

366
00:31:30,000 --> 00:31:32,000
men kopien er helt uendret, for der har det ikke skjedd noe.

367
00:31:34,000 --> 00:31:38,000
Så vi har mulighet til å kopiere ting, og vi har mulighet til at ting refererer til det samme.

368
00:31:39,000 --> 00:31:41,000
Det kan vi velge da.

369
00:31:50,000 --> 00:31:51,000
Range og slice.

370
00:31:52,000 --> 00:31:56,000
De er nyttige, og jeg har slått dem sammen her, fordi de har litt til felles.

371
00:31:58,000 --> 00:32:00,000
Hvis vi bruker funksjonen range,

372
00:32:03,000 --> 00:32:05,000
den har tre parametre som kaller for start, stopp og stepp.

373
00:32:07,000 --> 00:32:11,000
Da får du en liste med indekser, eller mer generelt,

374
00:32:12,000 --> 00:32:16,000
så får du en liste med heltall, som starter og stopper et sted.

375
00:32:16,000 --> 00:32:20,000
Hvis vi tar en slike slice, som lager en sub-liste av en liste,

376
00:32:21,000 --> 00:32:23,000
da har vi også start, stopp og stepp.

377
00:32:24,000 --> 00:32:28,000
Da får du en liten bit, eller en slice av en liste.

378
00:32:29,000 --> 00:32:31,000
Så hva er det de her har felles?

379
00:32:32,000 --> 00:32:36,000
For begge disse her, så vil tallet, eller verdien vi putter i start,

380
00:32:37,000 --> 00:32:39,000
det vil være fra og med.

381
00:32:40,000 --> 00:32:42,000
Vi skal ha en range fra og med tallet to,

382
00:32:42,000 --> 00:32:45,000
eller vi skal ha elementer fra og med index to i en liste.

383
00:32:47,000 --> 00:32:49,000
Stopp alltid til, men ikke mer.

384
00:32:52,000 --> 00:32:59,000
Det fine med det i listesammenheng, er at hvis vi putter lengden av lista i stopp,

385
00:33:00,000 --> 00:33:02,000
enten det er en range eller en slice,

386
00:33:03,000 --> 00:33:06,000
så får vi alltid til og med det siste elementet,

387
00:33:07,000 --> 00:33:09,000
men ikke går vi utenfor på liste.

388
00:33:09,000 --> 00:33:15,000
Step er vanligvis i en, det sier bare hvor mange vi skal hoppe over hver gang.

389
00:33:16,000 --> 00:33:19,000
Skal vi ta hver verdi, eller andre verdi, eller tredje hver verdi,

390
00:33:20,000 --> 00:33:22,000
og så videre. Så det vil oppføre seg likt i begge de.

391
00:33:26,000 --> 00:33:30,000
I spesialtilfelle, hvis vi bare tar range og et tall,

392
00:33:31,000 --> 00:33:35,000
så kan det tallet være lengden av en liste.

393
00:33:35,000 --> 00:33:37,000
Så får du alle indexene til en liste av denne lengden.

394
00:33:38,000 --> 00:33:41,000
Hvis vi bare har et tall i en range, så blir det stopp.

395
00:33:42,000 --> 00:33:44,000
Vi skal ha det til, men ikke mer av det tallet.

396
00:33:47,000 --> 00:33:49,000
Det er definert at det skal oppføre seg sånn.

397
00:33:50,000 --> 00:33:54,000
Det er ofte noe vi trenger å bare gi med fra og med null til,

398
00:33:55,000 --> 00:33:58,000
men ikke mer lengden av en liste, så får du alle indexene.

399
00:33:59,000 --> 00:34:03,000
Vi skal bare ta en liten sjekk på hvor langt utenpresentasjonen egentlig er nå.

400
00:34:06,000 --> 00:34:09,000
Ok. Timing-messig, så er ikke det her så galt.

401
00:34:11,000 --> 00:34:13,000
Liste og strengende tekst har litt til felles.

402
00:34:16,000 --> 00:34:18,000
Vi har en liste som vi har en masse på.

403
00:34:19,000 --> 00:34:21,000
Vi har en liste som vi har en masse på.

404
00:34:22,000 --> 00:34:24,000
Liste og strengende tekst har litt til felles.

405
00:34:24,000 --> 00:34:26,000
Liste og strengende tekst har litt til felles.

406
00:34:28,000 --> 00:34:30,000
Vi kan bruke indexer på begge to.

407
00:34:31,000 --> 00:34:36,000
Hvis vi bruker en index på en streng med tekst,

408
00:34:37,000 --> 00:34:41,000
så får vi ut tegne som ligger på den plassen i strengen.

409
00:34:42,000 --> 00:34:45,000
Både liste og streng har jo det her med at de har element,

410
00:34:46,000 --> 00:34:48,000
eller deler som ligger i en fast strekk.

411
00:34:50,000 --> 00:34:52,000
Slicing-programmer på begge to.

412
00:34:53,000 --> 00:34:59,000
Hvis vi skal ta fra starten til, men ikke med, index to,

413
00:35:00,000 --> 00:35:01,000
så får vi index null og en.

414
00:35:02,000 --> 00:35:06,000
Akkurat som på en liste vil vi da få en del av strengen.

415
00:35:08,000 --> 00:35:10,000
En forløkkel vil bare gå gjennom alle elementene.

416
00:35:11,000 --> 00:35:12,000
Så bruker vi en forløkkel på en streng,

417
00:35:13,000 --> 00:35:19,000
så går vi gjennom alle bostavene eller tegnene i strengen.

418
00:35:20,000 --> 00:35:22,000
Mellomrommet også tegn, viktig å huske på.

419
00:35:23,000 --> 00:35:24,000
Linjeskiftet tegnet til og med.

420
00:35:27,000 --> 00:35:30,000
Forskjellene på liste og streng er noen som er verdt å venne.

421
00:35:31,000 --> 00:35:33,000
Du kan endre en liste, men du kan ikke endre en streng.

422
00:35:34,000 --> 00:35:35,000
Direkt det.

423
00:35:36,000 --> 00:35:38,000
Du kan ikke endre en streng med en index og si at,

424
00:35:39,000 --> 00:35:40,000
hei, endre i til en i.

425
00:35:41,000 --> 00:35:45,000
Da får du feilbeengel, da får du beskjed om at en streng kan ikke endres.

426
00:35:46,000 --> 00:35:48,000
Men det du kan gjøre er hvis du bruker pluss mellom to streng,

427
00:35:49,000 --> 00:35:50,000
så lager du en ny streng.

428
00:35:51,000 --> 00:35:53,000
Da har du ikke endret den gamle, men du har laget en ny.

429
00:35:54,000 --> 00:35:55,000
Det får du lov til.

430
00:35:56,000 --> 00:35:58,000
Det er ikke noe problem med å lage nye strenger og gamle strenger,

431
00:35:59,000 --> 00:36:01,000
men du får ikke lov til å endre en du allerede har lagd.

432
00:36:02,000 --> 00:36:06,000
Når den ligger der i minhetstedet, så er den der helt til programmersluttet kjøremiskelig.

433
00:36:07,000 --> 00:36:10,000
Av den grunn kan en streng være nøkkel i en ordbok,

434
00:36:11,000 --> 00:36:14,000
en dictionary, fordi et krav til en nøkkel i en ordbok er at

435
00:36:15,000 --> 00:36:18,000
når den er puttet inn der, så skal den ikke endres etterpå.

436
00:36:19,000 --> 00:36:23,000
Så kan du plutselig miste kontrollen over hva som ligger der i nøkkelene,

437
00:36:24,000 --> 00:36:25,000
så kan vi fjerne ting.

438
00:36:26,000 --> 00:36:28,000
Men det kommer vi tilbake til.

439
00:36:30,000 --> 00:36:34,000
Så har jeg sett at liste-comprehensions, som det kalles,

440
00:36:35,000 --> 00:36:38,000
er en snar vei til å lage lister som er greit å kjenne til.

441
00:36:40,000 --> 00:36:43,000
Det er en spesial tilfelle hvor du tar hvert element i en liste,

442
00:36:44,000 --> 00:36:46,000
så gjør du noe med det, og så putter du svaret i en ny liste.

443
00:36:46,000 --> 00:36:50,000
Det kan du alltid gjøre med en løkkel, at du kan gå gjennom en liste og gjøre noe,

444
00:36:51,000 --> 00:36:53,000
og appende til en ny liste som du har laget.

445
00:36:54,000 --> 00:36:56,000
Men det finnes en snar vei her som jeg har sett i eksamsoppgaver,

446
00:36:57,000 --> 00:36:59,000
at det forventes at man kjenner til.

447
00:37:01,000 --> 00:37:03,000
Da kan du skrive på denne måten.

448
00:37:04,000 --> 00:37:11,000
At ny liste, så bruker du firkenklava, så skriver du noe med utvik for element i en gammel liste,

449
00:37:12,000 --> 00:37:14,000
så vil det lages en forløkke på en linje,

450
00:37:14,000 --> 00:37:16,000
så dette er bare en forløkke.

451
00:37:17,000 --> 00:37:20,000
Et eksempel er en liste som kalles naturlige tall,

452
00:37:21,000 --> 00:37:23,000
kanskje ikke alle naturlige tallene, for den vil være uendelig lang,

453
00:37:24,000 --> 00:37:26,000
men for noen av de i hvert fall.

454
00:37:27,000 --> 00:37:29,000
Så går du gjennom hvert tall i naturlige tall,

455
00:37:30,000 --> 00:37:32,000
oppi tallet i to,

456
00:37:33,000 --> 00:37:38,000
og da vil alle kvadrattallene til svaret havne i en liste som her kalles kvadrattall.

457
00:37:39,000 --> 00:37:41,000
Så det er ikke noe annet.

458
00:37:42,000 --> 00:37:44,000
Det er bare en snarvei.

459
00:37:45,000 --> 00:37:47,000
Det er ikke så mye man forstår om forløkket,

460
00:37:48,000 --> 00:37:50,000
så kan man egentlig det man trenger,

461
00:37:51,000 --> 00:37:53,000
men det er greit å være klar over at det er en kompakt måte å skrive det på.

462
00:38:00,000 --> 00:38:04,000
Det meste i Python kan puttes inn i noe annet.

463
00:38:05,000 --> 00:38:07,000
Det er fleksibelt på den måten,

464
00:38:08,000 --> 00:38:10,000
og det gjelder jo de fleste programmeringsspråk.

465
00:38:11,000 --> 00:38:13,000
Det er jo overskikkelig og fint.

466
00:38:14,000 --> 00:38:16,000
Kanskje ikke.

467
00:38:17,000 --> 00:38:19,000
Når det blir så mange fintkantklammer som det er,

468
00:38:20,000 --> 00:38:22,000
så mister man jo litt oversikten, det må jeg bare si.

469
00:38:23,000 --> 00:38:25,000
Så hvis vi skal hente ut noe fra en liste i en liste i en liste,

470
00:38:26,000 --> 00:38:28,000
så kan det være lurt å ta et nivå av gangen.

471
00:38:29,000 --> 00:38:31,000
At jeg lager meg en variabel indri-liste,

472
00:38:32,000 --> 00:38:34,000
som tar for eksempel den siste lista i ytterliste,

473
00:38:35,000 --> 00:38:37,000
og sier at det er en liste som er i den ytterliste,

474
00:38:38,000 --> 00:38:40,000
og så kan jeg ta et nivå av gangen.

475
00:38:41,000 --> 00:38:43,000
Her har vi det.

476
00:38:44,000 --> 00:38:46,000
Litt mer oversiktlig.

477
00:38:47,000 --> 00:38:49,000
Kan lage meg en innerste liste som inneholder den siste lista i den indri-lista igjen.

478
00:38:50,000 --> 00:38:52,000
Og tallet jeg skal ta,

479
00:38:53,000 --> 00:38:55,000
det er kanskje det første elementet der.

480
00:38:56,000 --> 00:38:58,000
Sånn kan vi pakke det ut lag for lag.

481
00:39:00,000 --> 00:39:02,000
Det er alltid noen som liker alt på en gang.

482
00:39:06,000 --> 00:39:08,000
Så selvfølgelig, hvis du bare,

483
00:39:08,000 --> 00:39:10,000
det er ikke selvfølgelig,

484
00:39:12,000 --> 00:39:14,000
men fordi det skal være mulig,

485
00:39:15,000 --> 00:39:17,000
så har man gjort det sånn at

486
00:39:18,000 --> 00:39:20,000
du kan ta den ytterliste, så tar du en indri-liste, en indri-liste, en indri-liste,

487
00:39:21,000 --> 00:39:23,000
og så får du akkurat samme resultat.

488
00:39:25,000 --> 00:39:27,000
Så først tar jeg ytterliste,

489
00:39:28,000 --> 00:39:30,000
første indri-liste er 2, ok.

490
00:39:31,000 --> 00:39:33,000
Da blir ytterliste 2 indri-liste, og så tar jeg indri-liste 1 fra den igjen.

491
00:39:34,000 --> 00:39:36,000
Da får jeg en innerste liste, altså indri-liste 0 i den.

492
00:39:36,000 --> 00:39:38,000
Jeg kunne gjort det med parenteser

493
00:39:39,000 --> 00:39:41,000
hvis jeg skulle gjort det ordentlig tydelig for meg selv

494
00:39:42,000 --> 00:39:44,000
hva som foregår. Det er greit å sette i hvert fall.

495
00:39:45,000 --> 00:39:47,000
Det er greit å vite at det går an.

496
00:39:50,000 --> 00:39:52,000
Tupla er jo,

497
00:39:53,000 --> 00:39:55,000
har jo vært nevnt.

498
00:39:56,000 --> 00:39:58,000
Det er nærmest en spesial tilfelle av en liste.

499
00:40:02,000 --> 00:40:04,000
Tupla har den der greia med at

500
00:40:04,000 --> 00:40:06,000
når du først har lagd en tupla,

501
00:40:08,000 --> 00:40:10,000
så kan du ikke endre på elementene dine senere.

502
00:40:11,000 --> 00:40:13,000
Da er de der.

503
00:40:14,000 --> 00:40:16,000
Du kan ikke forlenge eller forkorte dem heller.

504
00:40:24,000 --> 00:40:26,000
Jeg trodde faktisk at man alltid måtte bruke en runde-poeng til å ha rundt i

505
00:40:27,000 --> 00:40:29,000
for at dette skulle bli en tupla,

506
00:40:30,000 --> 00:40:32,000
men det ser ut til at det fungerer utenå.

507
00:40:32,000 --> 00:40:34,000
Det er ikke noe å gjøre.

508
00:40:35,000 --> 00:40:37,000
Du bare sløyfer parenteser i hodet, så får du en.

509
00:40:38,000 --> 00:40:40,000
Hvis det ikke er fra før.

510
00:40:41,000 --> 00:40:43,000
Da har du en liste som ikke kan endres.

511
00:40:44,000 --> 00:40:46,000
Som jeg sa om strings,

512
00:40:47,000 --> 00:40:49,000
de kan puttes som nøkkel i en ordbok,

513
00:40:50,000 --> 00:40:52,000
for du kan ikke endre dem senere.

514
00:40:53,000 --> 00:40:55,000
Samme kan du gjøre med en tupla.

515
00:40:56,000 --> 00:40:58,000
Du kan også splitte opp en tupla i flere variabler.

516
00:40:59,000 --> 00:41:01,000
Si at A ligger 1, B ligger 2, C ligger 3.

517
00:41:02,000 --> 00:41:04,000
Siste kommer skal ikke være der.

518
00:41:05,000 --> 00:41:07,000
Kommer etter C har det ikke vært.

519
00:41:11,000 --> 00:41:13,000
En liten typo.

520
00:41:16,000 --> 00:41:18,000
Vi kan oppdatere i real-time.

521
00:41:19,000 --> 00:41:21,000
Hei, herlig.

522
00:41:25,000 --> 00:41:27,000
Og så den mystiske sippen.

523
00:41:28,000 --> 00:41:30,000
Den er det gode poenget på.

524
00:41:31,000 --> 00:41:33,000
Mange synes den er litt farlig.

525
00:41:34,000 --> 00:41:36,000
Jeg brukte sippen i et år før jeg skjønte hva den gjorde.

526
00:41:37,000 --> 00:41:39,000
Jeg tenkte at hvis jeg putter sippen her, så fungerer det.

527
00:41:40,000 --> 00:41:42,000
Jeg vet ikke hvorfor, men sånn er det noen ganger.

528
00:41:43,000 --> 00:41:45,000
Ikke alltid, men.

529
00:41:46,000 --> 00:41:48,000
Jeg har oppdaget grunnen til denne sippen.

530
00:41:49,000 --> 00:41:51,000
Hvis jeg har en liste med tall og bokstave,

531
00:41:52,000 --> 00:41:54,000
så kan jeg ta brauklydelåsen og sippe de sammen

532
00:41:54,000 --> 00:41:56,000
til en liste som at hvert tall hører til en bokstav.

533
00:41:58,000 --> 00:42:00,000
Da får jeg en liste med tupler,

534
00:42:01,000 --> 00:42:03,000
så hvert tuple inneholder et tall, og bokstaven hører sammen.

535
00:42:07,000 --> 00:42:09,000
Dette kan man bruke til å gå gjennom flere lister på en gang.

536
00:42:13,000 --> 00:42:15,000
Fordi hvis jeg da

537
00:42:18,000 --> 00:42:20,000
sipper flere lister sammen,

538
00:42:21,000 --> 00:42:23,000
sånn at de første elementene i bokstavene

539
00:42:24,000 --> 00:42:26,000
høres sammen, og de andre elementene høres sammen,

540
00:42:28,000 --> 00:42:30,000
så går jeg gjennom denne liste med tupler.

541
00:42:32,000 --> 00:42:34,000
Så har jeg tilgang til elementene fra hver liste som høres sammen,

542
00:42:36,000 --> 00:42:38,000
hver gang løkka går gjennom.

543
00:42:39,000 --> 00:42:41,000
Det gir meg litt nye muligheter som jeg ikke ville hatt ellers.

544
00:42:44,000 --> 00:42:46,000
Hvis alle listene er like lange som de da må være,

545
00:42:47,000 --> 00:42:49,000
så kunne man laget indexer med en range,

546
00:42:50,000 --> 00:42:52,000
og gått gjennom en range,

547
00:42:52,000 --> 00:42:54,000
og plukket element fra den listen,

548
00:42:55,000 --> 00:42:57,000
og fra den listen, og fra den listen, og sånn.

549
00:42:58,000 --> 00:43:00,000
Men i og med at dette har blitt observert i eksamensavning,

550
00:43:01,000 --> 00:43:03,000
så tenkte jeg at det var greit å nevne det.

551
00:43:04,000 --> 00:43:06,000
Jeg liker denne måten å tenke på, bare for å få en bilde av hva som foregår.

552
00:43:09,000 --> 00:43:11,000
Så jeg nevner det nå.

553
00:43:15,000 --> 00:43:17,000
Jeg tror Arrays er et greit sted å ta

554
00:43:18,000 --> 00:43:20,000
pause på.

555
00:43:20,000 --> 00:43:22,000
Så vi fortsetter kvart over.

556
00:43:24,000 --> 00:43:26,000
Jeg er klar til å sette opp taket på pause.

557
00:43:36,000 --> 00:43:38,000
Jeg fikk noen spørsmål i pausen, så jeg gikk litt over tid.

558
00:43:39,000 --> 00:43:41,000
Beklager det.

559
00:43:42,000 --> 00:43:44,000
Men jeg tror vi skal komme komfortabelt gjennom,

560
00:43:45,000 --> 00:43:47,000
og fortsette der vi snart.

561
00:43:47,000 --> 00:43:49,000
Som sagt, før pausen skal jeg snakke litt om Arrays,

562
00:43:50,000 --> 00:43:52,000
hva som er forskjellig fra de og liste.

563
00:43:55,000 --> 00:43:57,000
Så Arrays, som dere muligens husker,

564
00:43:58,000 --> 00:44:00,000
kan bare ha én bestemt typeverdi i hele Arrayen.

565
00:44:01,000 --> 00:44:03,000
Ikke blande mange typer som liste kan ha.

566
00:44:06,000 --> 00:44:08,000
Og det geniale med Arrays er at du kan gjøre en regnoppersån

567
00:44:09,000 --> 00:44:11,000
av en hel Array av gangen.

568
00:44:12,000 --> 00:44:14,000
Så hvis du tar en Array, lik en annen summen av to Arrays,

569
00:44:14,000 --> 00:44:16,000
så gjør du en sumoppersån på hvert enkelt element,

570
00:44:17,000 --> 00:44:19,000
og så får du ut en Array med samme dimensjon.

571
00:44:22,000 --> 00:44:24,000
Og hvis de ikke har samme størrelse eller dimensjoner,

572
00:44:25,000 --> 00:44:27,000
så feiler de jo nødvendigvis.

573
00:44:30,000 --> 00:44:32,000
Men det kan du i hvert fall ikke gjøre med en liste.

574
00:44:33,000 --> 00:44:35,000
Det må du gå gjennom en løkke eller flere,

575
00:44:36,000 --> 00:44:38,000
og bruke oppersån på hvert enkelt element.

576
00:44:39,000 --> 00:44:41,000
Så Arrays er ganske mye kjappere på det.

577
00:44:44,000 --> 00:44:48,000
Funksjoner som er laget for tall vil vanligvis fungere for Arrays også.

578
00:44:49,000 --> 00:44:53,000
Spesielt hvis det er en mpy-funksjon, fordi de er bygd med Arrays i mind,

579
00:44:54,000 --> 00:44:56,000
men matfunksjoner kan være litt verre med.

580
00:44:57,000 --> 00:44:58,000
Det kommer litt an på.

581
00:44:59,000 --> 00:45:01,000
Og for lister så gjelder det definitivt ikke.

582
00:45:03,000 --> 00:45:05,000
Da vil man få en feil med.

583
00:45:07,000 --> 00:45:11,000
En særlig nettmeri er at du kan skrive komma mellom indekster

584
00:45:11,000 --> 00:45:14,000
hvis du har en Array, inn i en Array, inn i en Array.

585
00:45:15,000 --> 00:45:18,000
Det blir jo nærmest en tredimensional matrise i så fall.

586
00:45:20,000 --> 00:45:25,000
Mens liste er nødt til å indeksere i tre omganger, som man ser her.

587
00:45:27,000 --> 00:45:30,000
Jeg mistenker at det der fungerer greit for Arrays også,

588
00:45:31,000 --> 00:45:33,000
men den første vil i hvert fall fungere bra.

589
00:45:34,000 --> 00:45:38,000
Og Arrays er jo mye raskere, spesielt for de vektoriserte utøpningene.

590
00:45:38,000 --> 00:45:40,000
Så går det fort.

591
00:45:46,000 --> 00:45:53,000
I forbindelse med Arrays, hvis du skal lage en Array som inneholder tall fra til et eller annet,

592
00:45:54,000 --> 00:45:55,000
så bruker man Lidspace.

593
00:45:56,000 --> 00:46:01,000
Den har noen forskjeller fra Range som er verdt å merke seg for at du skal klare å holde det i hodet.

594
00:46:02,000 --> 00:46:06,000
Range på liste er jo kun helt tall.

595
00:46:09,000 --> 00:46:15,000
Og det stopper parametrene i Range.

596
00:46:16,000 --> 00:46:23,000
Hvis du sier at en Range skal gå til, men ikke med tre, så får du ikke med tre tall i en Range.

597
00:46:25,000 --> 00:46:28,000
I Lidspace vil du også kunne få desimaltall.

598
00:46:29,000 --> 00:46:38,000
Og da har du også start og stopp i Lidspace, men da er det til og med rettetil for et tall og to.

599
00:46:39,000 --> 00:46:48,000
Av ulike grunner oppfører disse seg forskjellig, fordi de lager litt for forskjellige anvendelser.

600
00:46:50,000 --> 00:46:52,000
Så det er greit å være klar over.

601
00:46:53,000 --> 00:46:59,000
Hvis du skal vite hvor mange tall det blir i en Range, så må du i verste fall se på

602
00:47:00,000 --> 00:47:07,000
stopp, minus start, delt på stepp, så får du antallet.

603
00:47:08,000 --> 00:47:17,000
Selv om det er til, men ikke med tre, så vil du kunne bruke det til å regne ut hvor mange elementer det er.

604
00:47:18,000 --> 00:47:21,000
Lidspace er mye lettere, for det er det siste tallet.

605
00:47:22,000 --> 00:47:25,000
Det sier bare hvor mange elementer du har i denne Range som du får ut.

606
00:47:26,000 --> 00:47:29,000
Så det er lettere å se hvor mange elementer det kommer til å være.

607
00:47:30,000 --> 00:47:35,000
I alle tilfeller, hvis du bare tar Range et eller annet tall, så får du så mange elementer i den.

608
00:47:36,000 --> 00:47:37,000
Så da er det enkelt.

609
00:47:38,000 --> 00:47:40,000
Men i noen andre tilfeller kan det være litt mer kompensert.

610
00:47:41,000 --> 00:47:44,000
Jeg har ikke skrevet dette, men det finnes jo en R-Range.

611
00:47:44,000 --> 00:47:51,000
Det finnes jo en R-Range funksjon også, som gjør at Range blir en Array, ikke en liste.

612
00:47:52,000 --> 00:47:55,000
Men det blir jo en eget Range-objekt.

613
00:47:56,000 --> 00:47:58,000
I Perseus oppdager vi at Zip også blir et eget Zip-objekt.

614
00:47:59,000 --> 00:48:02,000
Men både Range og Zip kan gjøres om til en liste.

615
00:48:03,000 --> 00:48:06,000
Vi skriver liste, fordi det er en test, og så putter vi objekter inn i det.

616
00:48:07,000 --> 00:48:09,000
Så du får i hvert fall ut noe listeaktig.

617
00:48:09,000 --> 00:48:16,000
Hvis du skal ha dette til å oppføre seg akkurat som en liste, for eksempel med utskrift og sånne ting, så er det greit å gjøre en liste av det etterpå.

618
00:48:22,000 --> 00:48:23,000
Over til noe litt annet.

619
00:48:25,000 --> 00:48:28,000
Vi snakker mye om lister og arves og sånne ting nå.

620
00:48:30,000 --> 00:48:36,000
Ordbøker, Dictionaries, er jo den kuleste datafrukturen av de.

621
00:48:36,000 --> 00:48:38,000
Den kuleste samlingen av element.

622
00:48:39,000 --> 00:48:45,000
En liste er jo begrenset hvor du har helt tatt sin indekse som alltid starter på null, og bare har en fast rekkefølge.

623
00:48:47,000 --> 00:48:49,000
Det er jo litt sånn begrensende og kjedelig.

624
00:48:50,000 --> 00:48:54,000
En ordbok, i stedet for disse indeksene, har du nøkler som kan være nesten hva som helst.

625
00:48:55,000 --> 00:49:00,000
I stedet for 0, 1 og 2, kan jeg bruke helt andre verdier til å slå opp i en Dictionary.

626
00:49:01,000 --> 00:49:03,000
Jeg kan til og med gjøre motsatt.

627
00:49:03,000 --> 00:49:06,000
Jeg vil ikke at nøklene skal være tall, jeg vil at de skal være bokstaver.

628
00:49:07,000 --> 00:49:10,000
Så jeg kan bytte om hva nøklene og verdiene skal være.

629
00:49:12,000 --> 00:49:14,000
Det er noen unntak selvfølgelig.

630
00:49:15,000 --> 00:49:19,000
Nøkler kan ikke være lister, nøkler kan ikke være nye ordbøker,

631
00:49:20,000 --> 00:49:22,000
nøkler kan i utgangspunktet ikke være egendefinerte klasser.

632
00:49:23,000 --> 00:49:27,000
Da må du lage dem på riktig måte, slik at de ikke endrer seg senere.

633
00:49:28,000 --> 00:49:31,000
Men verdiene i en ordbok kan være alt, egentlig.

634
00:49:32,000 --> 00:49:33,000
Alt mulig.

635
00:49:34,000 --> 00:49:37,000
Så bare for å få begrepene på plass.

636
00:49:38,000 --> 00:49:41,000
I en liste har vi elementer som har hver sin indeks.

637
00:49:42,000 --> 00:49:45,000
I en ordbok har vi verdier som har hver sin nøkle.

638
00:49:46,000 --> 00:49:49,000
Ordbøker er ganske mye mer fleksible.

639
00:49:52,000 --> 00:49:56,000
Noe av det vi lurer på er at jeg har en eller annen verdi.

640
00:49:57,000 --> 00:50:04,000
Finnes denne verdien i denne samlingen, så har jeg en liste eller ordbok som eksisterer i dette.

641
00:50:05,000 --> 00:50:09,000
Så har jeg en liste eller ordbok som eksisterer i dette.

642
00:50:09,000 --> 00:50:16,000
Hvis vi gjør en test om A finnes i liste, så sjekker vi om elementet A finnes i liste.

643
00:50:22,000 --> 00:50:25,000
Og A i ordbok sjekker om en nøkkel finnes i ordboka.

644
00:50:26,000 --> 00:50:28,000
Dette er litt motsatt.

645
00:50:29,000 --> 00:50:33,000
I en liste er det litt mer eller mindre, men det er ikke så mye.

646
00:50:33,000 --> 00:50:35,000
Det er ikke noe nøkkel som finnes i ordboka.

647
00:50:36,000 --> 00:50:38,000
Dette er litt motsatt.

648
00:50:39,000 --> 00:50:44,000
I en liste er det elementet du sjekker, men i en ordbok er det ikke verdien.

649
00:50:45,000 --> 00:50:47,000
Men nøkkel.

650
00:50:49,000 --> 00:50:53,000
Hvis du vil lete etter en verdi i en ordbok og sier at denne finnes,

651
00:50:54,000 --> 00:50:58,000
så kan du bruke en metode som heter values.

652
00:50:58,000 --> 00:51:02,000
Hvis du har en ordbok, så har du en metode som heter values.

653
00:51:03,000 --> 00:51:12,000
Så du lager en liste med verdiene, og sjekker om verdien finnes der.

654
00:51:13,000 --> 00:51:17,000
Man kan gjøre det også, men da må man passe på å gjøre det.

655
00:51:18,000 --> 00:51:24,000
Litt om testing av program er nyttig å gjøre.

656
00:51:25,000 --> 00:51:27,000
Eller nyttig å kunne noe om.

657
00:51:28,000 --> 00:51:34,000
I tradisjonell vitenskapelig programmering, og nå mener jeg tradisjonell på den dårlige måten,

658
00:51:35,000 --> 00:51:39,000
at man aldri kommenterer kode, og alle tester er bare prints,

659
00:51:40,000 --> 00:51:42,000
så vil man skrive alt mulig til skjermen.

660
00:51:42,000 --> 00:51:45,000
For sånn triviel testing fungerer det.

661
00:51:46,000 --> 00:51:48,000
Men det finnes bedre måter å gjøre det på.

662
00:51:49,000 --> 00:51:52,000
Man kan lage ennå en test, hvor du har en test,

663
00:51:53,000 --> 00:51:56,000
og hvis du skriver assert foran, så får du en feilmelding hvis testen feiler.

664
00:51:57,000 --> 00:51:59,000
Du har en del ting som du vil passe på at aldri går gærent.

665
00:52:00,000 --> 00:52:01,000
Så kan du teste med assert.

666
00:52:02,000 --> 00:52:03,000
Hvis du gjør noen endringer i programmet ditt,

667
00:52:04,000 --> 00:52:09,000
så vil du få en feilmelding om det, så går ikke det under radaren.

668
00:52:09,000 --> 00:52:12,000
For det skumleste er jo de feiler du aldri finner.

669
00:52:14,000 --> 00:52:15,000
Det var det jeg nødt til å si.

670
00:52:16,000 --> 00:52:20,000
Dere får ikke brukt debuggerer på eksamen, selvfølgelig,

671
00:52:21,000 --> 00:52:24,000
men i den virkelige verdenen er det veldig smart,

672
00:52:25,000 --> 00:52:28,000
hvis man skal prøve å finne ut hva er gærent med programmet mitt,

673
00:52:29,000 --> 00:52:30,000
i stedet for å begynne å printe alt mulig,

674
00:52:31,000 --> 00:52:34,000
så kan man bruke en debugger, for eksempel Python Tutor,

675
00:52:35,000 --> 00:52:36,000
eller VS Code er også en debugger man kan bruke,

676
00:52:36,000 --> 00:52:38,000
til å steppe gjennom koden steg for steg,

677
00:52:39,000 --> 00:52:41,000
og hele tiden følge med på å innholde variaberene mine.

678
00:52:42,000 --> 00:52:43,000
Så kan du følge med på det.

679
00:52:44,000 --> 00:52:45,000
Det er et kjempebra verktøy, egentlig.

680
00:52:46,000 --> 00:52:51,000
Så for feil som er vanskelig å finne, så er det stærkt anbefalt.

681
00:52:55,000 --> 00:52:57,000
Litt om hardcoding.

682
00:52:58,000 --> 00:53:02,000
Hvis vi setter verdier direkte i programmet,

683
00:53:03,000 --> 00:53:06,000
så har vi ganske god kontroll på hva de kommer til å være,

684
00:53:07,000 --> 00:53:11,000
men ulempen er at hvis noen skal bruke programmet,

685
00:53:12,000 --> 00:53:13,000
og de skal endre noen verdier,

686
00:53:14,000 --> 00:53:19,000
så må de kunne nok Python til å forstå hva som skjer,

687
00:53:20,000 --> 00:53:22,000
og så må de gå inn og endre programmet hver gang det skal endres.

688
00:53:23,000 --> 00:53:24,000
Noen ganger er kanskje det ok.

689
00:53:25,000 --> 00:53:31,000
Men mer generelt, så er det kanskje bedre at programmet kan be brukeren

690
00:53:32,000 --> 00:53:35,000
skrive inn en verdier selv hvis det vil variere fra gang til gang.

691
00:53:36,000 --> 00:53:39,000
Da blir tersken lavere for at noen skal kunne bruke det.

692
00:53:41,000 --> 00:53:44,000
Veldig viktig å huske på at input funksjonen som gir deg noe

693
00:53:45,000 --> 00:53:47,000
i infrastrukturen, alltid tar inn tekst.

694
00:53:48,000 --> 00:53:50,000
Så hvis jeg kjører det her,

695
00:53:51,000 --> 00:53:55,000
så er det like input av, gi meg et tal, input, gi meg enda et tal.

696
00:53:56,000 --> 00:53:57,000
Hva tror dere skjer?

697
00:53:58,000 --> 00:54:00,000
Så skriver jeg inn 4 og 2.

698
00:54:05,000 --> 00:54:08,000
Da kommer det inn en streng av et ekst, så da blir det slått sammen,

699
00:54:09,000 --> 00:54:12,000
så får du 42 som svar, så kanskje ikke var det det var ut etter,

700
00:54:13,000 --> 00:54:14,000
hvis dette skal gjøres matematisk.

701
00:54:15,000 --> 00:54:20,000
Så skal du regne med tal, for eksempel floats,

702
00:54:21,000 --> 00:54:25,000
så må jeg bruke en eller annen funksjon til å gjøre om inputen til tal i hvert tilfelle,

703
00:54:25,000 --> 00:54:27,000
og da kan jeg regne med det.

704
00:54:28,000 --> 00:54:31,000
Det er lett å glemme.

705
00:54:32,000 --> 00:54:34,000
Selv om jeg skriver inn et tal på tastaturet,

706
00:54:35,000 --> 00:54:37,000
så blir det tolka som tekst, da er det klart.

707
00:54:38,000 --> 00:54:40,000
For det er forskjell på tall- og pegnote.

708
00:54:42,000 --> 00:54:45,000
Ofte skal jeg også lese inn data fra en tekstfil,

709
00:54:46,000 --> 00:54:50,000
og metoden er stort sett den samme, åpne fila som en filobjekt med open,

710
00:54:51,000 --> 00:54:57,000
kanskje det er en linje med kolonnavn eller headers,

711
00:54:58,000 --> 00:55:01,000
det kan hende, men kanskje ikke det det er engang.

712
00:55:02,000 --> 00:55:05,000
Da går du gjennom en løkke linje for linje,

713
00:55:06,000 --> 00:55:07,000
det som ligger i filobjektet,

714
00:55:08,000 --> 00:55:10,000
og hver linje vil da være en streng med tekst,

715
00:55:11,000 --> 00:55:13,000
det er en tekstfil, så det er kanskje ikke så merkelig.

716
00:55:14,000 --> 00:55:17,000
Da kan du gjøre hva du vil med hver linje i fila.

717
00:55:17,000 --> 00:55:20,000
For eksempel, du kan splitte de opp i ord.

718
00:55:22,000 --> 00:55:24,000
Så jeg tar ordene i linje, så bruker jeg en metode som heter split.

719
00:55:25,000 --> 00:55:30,000
Split er en metode som du kan gjøre på alle streng objekt,

720
00:55:31,000 --> 00:55:32,000
så hver gang den ser et mellomrom,

721
00:55:33,000 --> 00:55:35,000
så tar den det ut som en substring,

722
00:55:36,000 --> 00:55:40,000
og så får du en liste med korte strings.

723
00:55:41,000 --> 00:55:44,000
Entuelt kan du spesifisere at andre skildetegn,

724
00:55:44,000 --> 00:55:50,000
for eksempel komma, hvis du har komma mellom alle tingene du vil dele opp.

725
00:55:51,000 --> 00:55:54,000
Og så for hvert ord i en liste med ord,

726
00:55:55,000 --> 00:55:56,000
kan du da gjøre nye ting.

727
00:55:57,000 --> 00:55:58,000
For eksempel.

728
00:55:59,000 --> 00:56:00,000
Og til slutt er det viktig å lukke filet,

729
00:56:01,000 --> 00:56:02,000
så den blir stående åpen.

730
00:56:06,000 --> 00:56:08,000
Du kan faktisk aldri teste hva som skjer hvis du ikke gjør det,

731
00:56:09,000 --> 00:56:12,000
men der holder man seg til det man burde gjøre.

732
00:56:15,000 --> 00:56:19,000
Og det er greit å kjenne til noe nytt i streng operasjoner.

733
00:56:20,000 --> 00:56:23,000
Hva kan jeg gjøre med et streng objekt?

734
00:56:25,000 --> 00:56:28,000
Nå kommer vi litt inn på, vi er nærmest objektorientert nå,

735
00:56:29,000 --> 00:56:33,000
at objektene er data som selv vet hvordan de skal gjøre enkelte ting,

736
00:56:34,000 --> 00:56:41,000
som er litt mer selvstendige enn passive data som man må gjøre ting med.

737
00:56:42,000 --> 00:56:47,000
Så et streng objekt vet hvordan det skal dele seg opp i en liste med kortere strenger.

738
00:56:49,000 --> 00:56:52,000
Det vet hvordan du skal ta en liste med kortere strenger og lage en ny streng,

739
00:56:53,000 --> 00:56:56,000
som inneholder disse etter hverandre med join.

740
00:56:58,000 --> 00:57:03,000
I Replace kan du lete etter en substreng i en streng og bytte ut med noe annet.

741
00:57:04,000 --> 00:57:06,000
Du kan bytte ut et tegn med et annet, et palme med et annet,

742
00:57:07,000 --> 00:57:09,000
kanskje det er lengre sekvenser du kan bytte ut.

743
00:57:11,000 --> 00:57:15,000
Det er en metode isDigit som rettner et true hvis det bare er tall i en streng.

744
00:57:16,000 --> 00:57:17,000
Sjekk om det er noe tall.

745
00:57:18,000 --> 00:57:20,000
IsAlpha, sjekk om det bare er bokstaver.

746
00:57:21,000 --> 00:57:24,000
Upper tar en streng og gjør om alle små bokstaver til store.

747
00:57:25,000 --> 00:57:28,000
Lower tar en streng og gjør om alle store bokstaver til små.

748
00:57:31,000 --> 00:57:34,000
Det er nyttig å kjenne til, å være borte i de her.

749
00:57:34,000 --> 00:57:37,000
Plotting skal jeg ikke si så mye om, for jeg vet at dere har gjort det masse.

750
00:57:38,000 --> 00:57:41,000
Det er greit å kunne gjøre det grunnleggende med plotting,

751
00:57:42,000 --> 00:57:43,000
slik at man nesten kan gjøre det i søvnene.

752
00:57:44,000 --> 00:57:45,000
Hvis dere kjenner av at dere er litt ustød på det,

753
00:57:46,000 --> 00:57:48,000
så er litt mengdetrening på det ganske smart.

754
00:57:50,000 --> 00:57:53,000
Men jeg kommer ikke til å gå gjennom det i detalj nå.

755
00:57:54,000 --> 00:57:56,000
Jeg skal bare nevne noen nyttige tips.

756
00:57:57,000 --> 00:58:01,000
Det er viktig å huske at dere kan kalle plott flere ganger før du kaller det.

757
00:58:01,000 --> 00:58:03,000
Da kan du få flere kurver i samme vindu.

758
00:58:08,000 --> 00:58:12,000
Det er greit å ikke glemme title og legend hvis du skal ha plottet.

759
00:58:13,000 --> 00:58:15,000
Sånn at det blir et litt oversiktlig plott.

760
00:58:16,000 --> 00:58:20,000
Også kan man huske å bruke den label-parameteren i plottfunksjonen,

761
00:58:21,000 --> 00:58:24,000
slik at legend-funksjonen har noe den kan vise frem.

762
00:58:25,000 --> 00:58:28,000
At hver linje får en annen beskrivelse av hva slags plott.

763
00:58:28,000 --> 00:58:33,000
At hver linje får en annen beskrivelse av hva slags kurve vi har her.

764
00:58:36,000 --> 00:58:38,000
Jeg hopper ganske kjapt gjennom det.

765
00:58:42,000 --> 00:58:49,000
Funksjoner er jo nesten utrolig at vi først nå har kommet til det.

766
00:58:50,000 --> 00:58:52,000
Men det har vært så mye grunnleggende å ta først.

767
00:58:53,000 --> 00:58:55,000
Funksjoner er jo nesten noe av det aller viktigste.

768
00:58:56,000 --> 00:59:01,000
Det å se forskjell på parametre og argumenter er viktig.

769
00:59:02,000 --> 00:59:05,000
Så poenget med funksjoner er at du kan gjøre komplekse operasjoner,

770
00:59:06,000 --> 00:59:07,000
som ganske mange linjer med kode.

771
00:59:08,000 --> 00:59:13,000
De kan skrives på én linje i stedet der du kaller funksjonen virkelig.

772
00:59:14,000 --> 00:59:19,000
Så da trenger ikke alle detaljerne være midt i programmet ditt.

773
00:59:20,000 --> 00:59:23,000
Du kan gjemme bort alle detaljerne i funksjonen,

774
00:59:23,000 --> 00:59:26,000
så kan programmet bare si at nå gjør vi det her.

775
00:59:27,000 --> 00:59:28,000
Hvordan det gjøres, det forklart et annet sted.

776
00:59:29,000 --> 00:59:30,000
Da blir programmet ditt mye mer oversiktlig.

777
00:59:32,000 --> 00:59:33,000
Det er fint.

778
00:59:35,000 --> 00:59:37,000
Funksjoner kan også gjenbrukes.

779
00:59:38,000 --> 00:59:40,000
Du kan bruke det flere ganger for flere steder i samme program,

780
00:59:41,000 --> 00:59:42,000
eller i andre program.

781
00:59:43,000 --> 00:59:44,000
Så du har litt denne gjenbruk.

782
00:59:45,000 --> 00:59:47,000
Skal du endre noe, så endrer du det bare i ett sted.

783
00:59:48,000 --> 00:59:52,000
Men her må du ikke endre noe som skjer etter hverandre.

784
00:59:53,000 --> 00:59:55,000
Du kan bruke det i forskjellige steder med masse anarkode i mellom.

785
00:59:56,000 --> 00:59:57,000
Så det er veldig fleksibel.

786
01:00:00,000 --> 01:00:04,000
Funksjonen i programmering er et lite program i programmet,

787
01:00:05,000 --> 01:00:08,000
som egentlig lever sitt eget liv.

788
01:00:09,000 --> 01:00:13,000
Det har sine helt egne lokale variabler som moderprogrammet ikke kjenner til.

789
01:00:18,000 --> 01:00:21,000
Det å tenke på programmet som et helt eget lite program,

790
01:00:21,000 --> 01:00:25,000
som kjører isolert, er en veldig nyttig måte å tenke på.

791
01:00:29,000 --> 01:00:33,000
Men det hadde vært ganske useles hvis vi ikke kunne sende litt informasjon

792
01:00:34,000 --> 01:00:36,000
mellom hodeprogrammet vårt og funksjonen.

793
01:00:37,000 --> 01:00:40,000
For å sende informasjon inn til en funksjon, så bruker vi parametre.

794
01:00:44,000 --> 01:00:49,000
Parametre er definert i dette det funksjonen skal ta inn.

795
01:00:50,000 --> 01:00:54,000
Hver gang vi kaller funksjonen, så gir vi disse parametrene forskjellige verdier,

796
01:00:55,000 --> 01:00:56,000
som vi kaller for argumentet.

797
01:00:57,000 --> 01:01:03,000
Der blir det indatt av til funksjonen i det funksjonen skal det der.

798
01:01:04,000 --> 01:01:06,000
Det kan være forskjellig hver gang funksjonen kalles.

799
01:01:07,000 --> 01:01:11,000
Disse parametrene er også lokale variabler som funksjonen kjenner til,

800
01:01:12,000 --> 01:01:15,000
men som resten av programmet på en måte ikke vet om.

801
01:01:15,000 --> 01:01:19,000
Disse argumentene A og B er variabler som finnes i hodeprogrammet,

802
01:01:20,000 --> 01:01:22,000
så hodeprogrammet kjenner det til dem.

803
01:01:23,000 --> 01:01:25,000
Hodeprogrammet vet hva A og B er for noe,

804
01:01:26,000 --> 01:01:29,000
men X og Y vet hodeprogrammet ingenting om.

805
01:01:30,000 --> 01:01:32,000
Når vi kaller funksjonen med argumentene A og B,

806
01:01:33,000 --> 01:01:36,000
så tar funksjonen og sier min lokale X skal være verdien av A,

807
01:01:37,000 --> 01:01:39,000
min lokale Y skal være verdien av B,

808
01:01:40,000 --> 01:01:42,000
og så kjenner jeg at det er noe jeg vet om.

809
01:01:42,000 --> 01:01:44,000
Min lokale Y skal være verdien av B,

810
01:01:45,000 --> 01:01:47,000
og så gjør funksjonen noe med disse,

811
01:01:48,000 --> 01:01:53,000
og når funksjonen har kjørt ferdig, så er disse variablerne borte igjen.

812
01:01:54,000 --> 01:02:00,000
Lokale variabler og parametre lever bare så lenge funksjonen kjører.

813
01:02:04,000 --> 01:02:06,000
Det går også an å gi parametrene standardverdier,

814
01:02:07,000 --> 01:02:09,000
hvis vi ikke gir dem noen verdier.

815
01:02:09,000 --> 01:02:14,000
Vi kan definere at X skal være 1 og Y skal være 0,

816
01:02:15,000 --> 01:02:19,000
hvis ikke det er noe tall, så kan de få noen standardverdier.

817
01:02:20,000 --> 01:02:21,000
Det går an.

818
01:02:23,000 --> 01:02:25,000
For å sende informasjon tilbake til programmet etterpå,

819
01:02:26,000 --> 01:02:30,000
så bruker vi returverdier, sånn at programmet kan få noe tilbake fra funksjonen.

820
01:02:31,000 --> 01:02:34,000
Der kan det puttes i en variabel.

821
01:02:34,000 --> 01:02:39,000
Her er variablene verdiene, for det blir da like returverdien fra funksjonen,

822
01:02:40,000 --> 01:02:42,000
hver enn den returnering skal puttes inn.

823
01:02:43,000 --> 01:02:47,000
Du kan returnere en verdi, eller du kan returnere flere.

824
01:02:49,000 --> 01:02:51,000
Hvis du returnerer flere, så blir det egentlig en tuple,

825
01:02:52,000 --> 01:02:54,000
men vi kan også putte de i hver sin variabel,

826
01:02:55,000 --> 01:02:59,000
hvis ikke vi har lyst til å forholde oss til tuplene, så det går an å gjøre på den måten.

827
01:02:59,000 --> 01:03:07,000
Jeg sa at alle verdier i Python er objekte.

828
01:03:08,000 --> 01:03:13,000
Det gjør funksjoner også, som om ikke det var nok.

829
01:03:14,000 --> 01:03:17,000
Funksjonsnavn er egentlig bare variabelnavn,

830
01:03:18,000 --> 01:03:22,000
og verdien til den variablen blir da funksjon.

831
01:03:23,000 --> 01:03:27,000
Vi får en litt annen fargelegging i VS Code og andre editorer,

832
01:03:27,000 --> 01:03:30,000
fordi editoren vet at dette var en funksjon,

833
01:03:31,000 --> 01:03:34,000
men for Pythons inntil er det ikke så stor forskjell.

834
01:03:36,000 --> 01:03:38,000
Og det er praktisk bruksområdet her.

835
01:03:39,000 --> 01:03:42,000
Fordelen med at funksjoner og objekter er på en måte,

836
01:03:43,000 --> 01:03:45,000
er at en funksjon kan derfor være argument til en annen funksjon,

837
01:03:46,000 --> 01:03:49,000
sånn at vi kaller en annen funksjon og sier

838
01:03:50,000 --> 01:03:54,000
«Hei funksjon, du skal bruke denne andre funksjonen til å gjøre greia di».

839
01:03:55,000 --> 01:03:58,000
Det åpner opp noen muligheter som vi ellers ikke ville hatt.

840
01:04:00,000 --> 01:04:03,000
Det er ikke alle programmeringspraktikker går an å gjøre det her,

841
01:04:04,000 --> 01:04:06,000
men Python er som sagt veldig fleksibel.

842
01:04:07,000 --> 01:04:12,000
Men med stor frihet kommer det stort ansvar.

843
01:04:13,000 --> 01:04:16,000
Vi kan miste funksjoner, i hvert fall midlertidig,

844
01:04:17,000 --> 01:04:21,000
hvis vi gjør noe lite lurt, som omdefinere hva print betyr.

845
01:04:21,000 --> 01:04:24,000
Det skal ikke lenger være den funksjonen som skal gjøres til skjermen,

846
01:04:25,000 --> 01:04:26,000
men det skal være verdien 2.

847
01:04:27,000 --> 01:04:29,000
Så vil dette få til feil mening.

848
01:04:30,000 --> 01:04:34,000
Altså sånn «Hei, du kan ikke kalle et helt tall».

849
01:04:35,000 --> 01:04:38,000
Så det er jo da ikke anbefalt.

850
01:04:39,000 --> 01:04:41,000
Men man mister ikke den permanent.

851
01:04:42,000 --> 01:04:44,000
Neste gang du kjører programmet er den tilbake igjen.

852
01:04:45,000 --> 01:04:47,000
Så inntar jeg, men det er kanskje ikke så godt.

853
01:04:47,000 --> 01:04:50,000
Av samme grunn litt mer typiske feil å gjøre.

854
01:04:51,000 --> 01:04:53,000
De ferdigste line-variabler som heter print,

855
01:04:54,000 --> 01:04:56,000
det er kanskje ikke så unødvendig å tenke på,

856
01:04:57,000 --> 01:05:00,000
men mer vanlig er at man kaller en variabel som «zoom» eller «list».

857
01:05:01,000 --> 01:05:03,000
Vi kan miste funksjonen som «summere lista»,

858
01:05:04,000 --> 01:05:07,000
vi kan miste lista i seg selv, og det er litt upraktisk.

859
01:05:08,000 --> 01:05:12,000
Det kan gi litt feilmeldinger som man umiddelbart ikke forstår.

860
01:05:12,000 --> 01:05:16,000
Så det er derfor jeg har brukt variablene som «zoomen» og «liste» og litt sånt,

861
01:05:17,000 --> 01:05:20,000
for å unngå å overskrive noe som allerede ligger der.

862
01:05:21,000 --> 01:05:24,000
Og jo mer du importerer, jo flere variabler må du egentlig unngå.

863
01:05:25,000 --> 01:05:28,000
Så det er kanskje enda en grunn til å unngå den importstjerne-greia.

864
01:05:29,000 --> 01:05:32,000
Det er kanskje ikke så farlig om du mister ting du ikke hadde tenkt å bruke,

865
01:05:33,000 --> 01:05:35,000
men allikevel.

866
01:05:37,000 --> 01:05:39,000
Yes.

867
01:05:40,000 --> 01:05:44,000
Så verdier er jo objekter, funksjoner er jo objekter.

868
01:05:49,000 --> 01:05:52,000
Det er verdt å nevne en spesiell type funksjon som kalles for en metode.

869
01:05:53,000 --> 01:05:57,000
Det er når du har et objekt, og så kaller du en funksjon på det objektet.

870
01:05:59,000 --> 01:06:02,000
Så det vi kan kalle for en alenestående funksjon,

871
01:06:03,000 --> 01:06:07,000
da skriver du bare funksjonsnavnet, og så har du kanskje noen argumenter bak der.

872
01:06:08,000 --> 01:06:10,000
Her har du i et.

873
01:06:11,000 --> 01:06:14,000
Det er jo den mest grunnleggende typen funksjon.

874
01:06:15,000 --> 01:06:18,000
Hvis du har en funksjon som tilhører et objekt,

875
01:06:19,000 --> 01:06:22,000
så bruker vi variabelen som inneholder objekter, punktum,

876
01:06:23,000 --> 01:06:27,000
og så kommer funksjonen etterpå med de parametrene man har.

877
01:06:28,000 --> 01:06:32,000
Det er kanskje ikke åpenbart at her vil det faktisk egentlig være to argumenter til denne funksjonen.

878
01:06:33,000 --> 01:06:36,000
Først har du objekter som hører til, som er funksjoner.

879
01:06:37,000 --> 01:06:44,000
Det skal alltid være et argument, og så kanskje noen argumenter til etterpå.

880
01:06:45,000 --> 01:06:52,000
Så både liste og hei, her er argumentene til funksjonen kanskje ikke åpenbart.

881
01:06:54,000 --> 01:07:01,000
Når vi kaller en metode på et objekt, så vil objektet automatisk bruke seg selv som argument.

882
01:07:02,000 --> 01:07:09,000
Det er derfor vi alltid har denne parameteren selv når vi definerer en metode i en klasse.

883
01:07:10,000 --> 01:07:14,000
At objektet må være klar over seg selv på en eller annen måte,

884
01:07:15,000 --> 01:07:18,000
og selv gjøre at vi får det til.

885
01:07:20,000 --> 01:07:22,000
Dette er ikke noe naturlov egentlig.

886
01:07:23,000 --> 01:07:25,000
Det er laget med vilje.

887
01:07:26,000 --> 01:07:28,000
Vi vil at det skal funke sånn,

888
01:07:28,000 --> 01:07:34,000
fordi det er for at vi mennesker skulle tenke at dette objektet er litt intelligent og selv vet hvordan det skal gjøres.

889
01:07:35,000 --> 01:07:37,000
Det er denne objektorienterte måten å tenke på.

890
01:07:39,000 --> 01:07:47,000
Jeg kunne bare hatt de passive objektene som alltid er sendt inn som argument til en eller annen funksjon.

891
01:07:48,000 --> 01:07:55,000
Men hvis jeg i stedet ser på meg at en liste vet selv hvordan den skal legges til et nytt element i seg selv,

892
01:07:55,000 --> 01:08:04,000
så er det en måte å tenke på programmet og organisere det på som gjør at det blir mer leselig og lettere å lese og skrive programmer.

893
01:08:05,000 --> 01:08:07,000
Det er et verktøy for å håndtere kompleksitet.

894
01:08:08,000 --> 01:08:15,000
Så brukes det jo mye, så skal man jobbe med program som andre har laget, som man uansett kjenner til.

895
01:08:17,000 --> 01:08:21,000
Det er greit å være bevisst på hva forskjellene er mellom klasse og dreng.

896
01:08:21,000 --> 01:08:25,000
Klasse og dreng er oppskrifter som sier hvordan en type objekt fungerer.

897
01:08:26,000 --> 01:08:32,000
Der ligger alle metodene, eller objektenes instruksjoner, de er definert i klassen.

898
01:08:33,000 --> 01:08:37,000
Og alle objekter av samme type har disse metodene felles.

899
01:08:38,000 --> 01:08:40,000
Her er det objekter av denne typen kan gjøre.

900
01:08:40,000 --> 01:08:41,000
Ja.

901
01:08:49,000 --> 01:08:50,000
Jeg kommer til deg.

902
01:08:51,000 --> 01:08:52,000
Yes.

903
01:08:54,000 --> 01:08:55,000
Vi er på vei dit.

904
01:08:57,000 --> 01:08:58,000
Yes.

905
01:08:59,000 --> 01:09:03,000
Et objekt er ikke oppskrift av det. Resultatet av å bruke oppskrifter er sånn.

906
01:09:04,000 --> 01:09:07,000
Jeg kan ha en banalt eksempel, kanskje.

907
01:09:08,000 --> 01:09:11,000
Jeg kan ha en kakeoppskrift som definerer en klasse av kake.

908
01:09:12,000 --> 01:09:15,000
Og hver faktiske kake jeg lager vil da være et objekt.

909
01:09:16,000 --> 01:09:23,000
Jeg vet ikke hvor langt jeg kan dra den metaforen, men for oversiktsskyl kan jeg nevne det.

910
01:09:24,000 --> 01:09:28,000
Og objekter kan være forskjellige, for instansvariablene til objektene kan ha forskjellige verdier.

911
01:09:29,000 --> 01:09:35,000
Jeg kan ha stekt disse kakene på forskjellige tider, og så har de forskjellig konsistens.

912
01:09:36,000 --> 01:09:38,000
Selv om jeg egentlig har fullt samme oppskrift.

913
01:09:39,000 --> 01:09:44,000
Så innputtene har vært litt forskjellige til disse objektene.

914
01:09:45,000 --> 01:09:52,000
Et enkelt eksempel. Alle lister kan bruke append.

915
01:09:53,000 --> 01:09:59,000
De vet at det er definert for klassen, men hver enkelt liste kan ha forskjellige lengder.

916
01:10:00,000 --> 01:10:06,000
Så det er klassene de har felles, og objektene kan likevel være forskjellige.

917
01:10:08,000 --> 01:10:11,000
Instansvariabler var det du lurte på.

918
01:10:11,000 --> 01:10:25,000
En instansvariabel er en variabel som tilhører objektene, men hvert objekt kan ha forskjellige verdier på den.

919
01:10:26,000 --> 01:10:31,000
Så disse variablene som har selvpunktum og variabelnavne, det er en instansvariabel.

920
01:10:32,000 --> 01:10:36,000
Og det er der forskjellene ligger. Det er ofte de som har forskjellige verdier for forskjellige objekter.

921
01:10:36,000 --> 01:10:44,000
For forskjellige objekter er det stort sett to ting som er forskjellige.

922
01:10:45,000 --> 01:10:48,000
Det ene er hvor de ligger i minnet på maskinen, for de ligger ikke på samme sted.

923
01:10:49,000 --> 01:10:52,000
Og det andre er at variablene deres kan ha forskjellige verdier.

924
01:10:55,000 --> 01:11:01,000
En vanlig variabel vil jo ha én verdi.

925
01:11:01,000 --> 01:11:11,000
Men instansvariablene har ikke noen felles verdi for alle objekter.

926
01:11:12,000 --> 01:11:15,000
Da vil de ha forskjellige verdier.

927
01:11:16,000 --> 01:11:23,000
For eksempel, hvis vi lager en klasse som har med planeter å gjøre, så har de en verdi som heter tyngde aksklarasjon.

928
01:11:24,000 --> 01:11:28,000
Så vil forskjellige planeter ha forskjellig aksklarasjon på overflaten.

929
01:11:32,000 --> 01:11:39,000
Så spørsmålet er hvordan skal de her metodene som er felles forholde seg til de her variablene som er individuelle?

930
01:11:40,000 --> 01:11:42,000
For alle objektene har forskjellige navn.

931
01:11:43,000 --> 01:11:49,000
Hvordan skal oppskriftene referere til dette objektet vi har her akkurat nå?

932
01:11:50,000 --> 01:11:56,000
Vi kan ikke vite på forhånd at vi har et objekt som heter jorda og et som heter mars osv.

933
01:11:57,000 --> 01:12:01,000
Her kommer denne spesialparameteren selv inn.

934
01:12:02,000 --> 01:12:04,000
Den får alltid objektet selv som verdi.

935
01:12:05,000 --> 01:12:08,000
Via selv får vi tilgang til alle disse variablene.

936
01:12:09,000 --> 01:12:15,000
Selv.tyngde aksklarasjon vil da gi oss tyngde aksklarasjon til dette objektet hva den måtte være.

937
01:12:17,000 --> 01:12:23,000
Når vi da definerer en metode i en klasse, så bruker vi alltid selv som parametre.

938
01:12:23,000 --> 01:12:28,000
Så alle metodene skal ha en eller annen måte å referere til objektet og variablene derpå.

939
01:12:29,000 --> 01:12:32,000
Det kan være andre parametre som kommer i tillegg.

940
01:12:33,000 --> 01:12:41,000
Når vi da kaller metoden, så har vi alltid objektet først, så punktum og så metodenavnet.

941
01:12:41,000 --> 01:12:45,000
Objektet blir da puttet inn i selv når det kalles.

942
01:12:45,000 --> 01:12:48,000
Det kan også være andre parametre som får verdier på vanligvis.

943
01:12:54,000 --> 01:13:05,000
Disse lokale variablene inni en funksjon, og disse instansvariablene som tilhører objektet, er litt forskjellige.

944
01:13:06,000 --> 01:13:09,000
Jeg sa at funksjonene var småprogrammer i programmet.

945
01:13:10,000 --> 01:13:15,000
Så variablen definert inni en funksjon, den vil forsvinne når funksjonen er ferdig.

946
01:13:16,000 --> 01:13:22,000
Hvis jeg er inni denne funksjonsreferensen, har laget en variabel som heter snart-porte, og en gang funksjonen er kjørt ferdig, så er den lost.

947
01:13:23,000 --> 01:13:28,000
Eneste måten å redde den verdien der på er å returnere den.

948
01:13:29,000 --> 01:13:42,000
Men, hvis jeg har en instansvariabel som heter lever videre, så vil den fortsette å eksistere etter at funksjonen er kjørt.

949
01:13:43,000 --> 01:13:45,000
Hvorfor er det så forskjellig?

950
01:13:45,000 --> 01:13:48,000
Selv er en referanse til objektet selv.

951
01:13:49,000 --> 01:13:51,000
Objektet selv har denne variablen.

952
01:13:52,000 --> 01:14:01,000
Dette objektet som kommer inn som en verdi her, via selv, det fantes jo fra før av, og det vil finnes etter at metoden er kjørt ferdig.

953
01:14:02,000 --> 01:14:06,000
Dermed vil instansvariablen også eksistere etter at funksjonen er kjørt.

954
01:14:08,000 --> 01:14:10,000
Det var det med returverdiet som jeg sa i sted.

955
01:14:11,000 --> 01:14:16,000
Hvis vi har en lokal variabel i funksjonen, så finner vi ut at denne er lyst til å ta vare på.

956
01:14:16,000 --> 01:14:23,000
Den må vi sjekke, og så må vi returnere den til der den ble kalt for at den skal kunne ha et liv etter funksjonen.

957
01:14:26,000 --> 01:14:30,000
Av og til har vi en funksjon som kaller en funksjon, som kaller en ny funksjon, som kaller en ny funksjon.

958
01:14:31,000 --> 01:14:41,000
Hvis vi i det innerste nivået der har en eller annen verdi, og denne er viktig, så må vi returnere, returnere, returnere, og jobbe oss tilbake på den måten.

959
01:14:42,000 --> 01:14:47,000
Hvis det da ikke er en instansvariabel, for da er det fikset for oss.

960
01:14:48,000 --> 01:14:52,000
Det er kanskje en fordel med objekter, at du trenger ikke å returnere så mye frem og tilbake.

961
01:14:54,000 --> 01:14:58,000
Det er lettere å ta vare på ting. Du kan bare putte det i objekter du jobber med.

962
01:15:01,000 --> 01:15:05,000
Konstruktøren er en spesiell metode. Jeg liker å kalle det en magisk metode.

963
01:15:06,000 --> 01:15:07,000
Det er en av mange.

964
01:15:08,000 --> 01:15:11,000
Det greiene med en magisk metode er at vi aldri kaller dem direkte.

965
01:15:13,000 --> 01:15:15,000
Vi skriver aldri sånn, nå kaller vi i nytt.

966
01:15:16,000 --> 01:15:19,000
Vi kunne nok gjort det, det hadde kanskje funket, men det er ikke derfor de finnes.

967
01:15:20,000 --> 01:15:22,000
De er derfor blitt kalt automatisk når andre ting skjer.

968
01:15:24,000 --> 01:15:33,000
Så hver gang et objekt er laget, så vet Python at nå skal i nytt-metoden kalles, og den klargjør objektet for bruk.

969
01:15:36,000 --> 01:15:47,000
En ting kan være at hvis vi har noen instansvariaver som skal ha verdi med en gang, at det er noen parametre her, og så skal de gis til objektet, så kan vi initialisere objektet på den måten.

970
01:15:48,000 --> 01:15:50,000
Og sette de instansvariaverene med en gang.

971
01:15:51,000 --> 01:16:00,000
Det er absolutt ikke det eneste vi kan gjøre. Vi kan gjøre mye nyttig og smart der, men det er kanskje det vanligste og enkleste caset.

972
01:16:05,000 --> 01:16:15,000
Så her er eksempel over, så jeg vil A være en parametre, og selv A er en instansvariavel, og det er to forskjellige variaver, selv om de er på samme verdi.

973
01:16:16,000 --> 01:16:26,000
Etter at konstruktøren har kjørt, så vil variabelen A slutte å eksistere, men selv punktet A, instansvariavelen, den vil leve videre sammen med objektet.

974
01:16:29,000 --> 01:16:31,000
Som et eksempel på det vi snakket om i start.

975
01:16:32,000 --> 01:16:48,000
Så da kan vi gi disse parametrene verdier når vi lager et nytt objekt, og da vil instansvariavelen få disse verdiene som ligger i disse variavelene her.

976
01:16:53,000 --> 01:17:00,000
Men det finnes flere magiske metoder enn bare konstruktøren, som er den vi, den må jo være der.

977
01:17:01,000 --> 01:17:04,000
Men det finnes andre som vi kan lage, hvis vi vil.

978
01:17:04,000 --> 01:17:06,000
Da har vi en magisk metode som heter Call.

979
01:17:07,000 --> 01:17:14,000
Den kaller vi heller aldri direkte, men den kalles etomatisk når vi prøver å kalle et objekt som om det var en funksjon.

980
01:17:15,000 --> 01:17:20,000
Enkelt kan vi kanskje si at Call er det som gjør et objekt til en funksjon.

981
01:17:21,000 --> 01:17:28,000
Hvis ikke Call er definert, så får vi feilmelding når vi prøver å kalle objektet på en måte.

982
01:17:29,000 --> 01:17:34,000
Det å bruke et objekt som en funksjon gir oss litt mer frihet til hvordan vi vil gjøre ting.

983
01:17:35,000 --> 01:17:38,000
Str, også et eksempel.

984
01:17:39,000 --> 01:17:53,000
Hver gang dere ser to underscores og et navn, og så to underscores til, i hvert fall i en klassemetode, så betyr det at dette er en magisk metode som kalles når vi gjør noe annet.

985
01:17:53,000 --> 01:17:55,000
Som ikke er meningen at vi skal kalle direkte.

986
01:17:56,000 --> 01:18:06,000
Hver gang vi prøver å gjøre objektet om til en string, eller hver gang vi prøver å printe et objekt, så vil vi kalle denne str-metoden.

987
01:18:07,000 --> 01:18:13,000
Hvis vi lager vår egen klasse og det ikke finnes noen str-metoder, så får vi bare en standar.

988
01:18:14,000 --> 01:18:18,000
Her ligger min klasse, og det ligger på den min adressen her.

989
01:18:19,000 --> 01:18:22,000
Og det er ikke så informativt akkurat.

990
01:18:23,000 --> 01:18:31,000
Et unntak som jeg kan nevne dere faktisk, er at hvis vi prøver å skrive ut en liste med objekt, så vil vi ofte få ut dette.

991
01:18:32,000 --> 01:18:38,000
Når vi skriver ut en liste, så kalles det ikke str-metoden på ting som ligger der.

992
01:18:38,000 --> 01:18:41,000
Det finnes en annen magisk metode som heter repr.

993
01:18:43,000 --> 01:18:54,000
Hvis du lager en repr-metode som representerer objektet ditt, så vil du også få se at når objektet ditt ligger i en liste, så vil du kunne se at det skrives ut på en fin måte.

994
01:18:55,000 --> 01:19:00,000
Akkurat hvorfor det er sånn, det har litt med hvordan lister fungerer å gjøre.

995
01:19:01,000 --> 01:19:04,000
Det finnes andre magiske metoder i tillegg til det.

996
01:19:04,000 --> 01:19:09,000
Vi kan endre oppførselen på pluss og minus med magiske metoder.

997
01:19:10,000 --> 01:19:15,000
Sammen med likhet, større enn, og så videre.

998
01:19:16,000 --> 01:19:28,000
Vi snakket også til om at plussoperatoren oppførte seg forskjellig for strenge og heltal, og grunnen til det er at metoden er definert forskjellig for disse to klasserne.

999
01:19:29,000 --> 01:19:41,000
Nå har jeg ikke skrevet det her, men jeg kan jo nevne det at i tillegg til self, så må vi ha en eller annen parameter som inneholder det andre objektet, other, er det vanlig å kalle det.

1000
01:19:41,000 --> 01:19:46,000
Hvis du skal ha en operatør som fungerer på to forskjellige objekter av samme klasser.

1001
01:19:47,000 --> 01:19:53,000
Så den første av de blir self, og den andre blir other, vanligvis.

1002
01:19:53,000 --> 01:19:55,000
Det har du formoden kanskje selv.

1003
01:19:56,000 --> 01:20:03,000
Om dette kurset ikke innholdsrikt nok, så har jeg blant annet en arv i dette også.

1004
01:20:04,000 --> 01:20:10,000
Da begynner vi å gå langt ut til det.

1005
01:20:12,000 --> 01:20:20,000
Men arv betyr at du har laget en klasse, eller du har mange klasser, og så har de ganske mye til felles.

1006
01:20:21,000 --> 01:20:29,000
Hvis vi skal lage en klasse som gjør nesten det samme som en annen klasse gjør fra før.

1007
01:20:29,000 --> 01:20:39,000
For eksempel, hvis vi vil ha en spesiell type liste som kan summere hvert element som Aris gjør, men ellers en helt vanlig liste, la oss si at vi har en annen grunn å ha lyst på det.

1008
01:20:40,000 --> 01:20:50,000
Så kan vi bare finne opp grunnet på nytt og lage liste fra begynnelse, men hvis man ikke er spesielt interessert, så er det kanskje ikke det man har lyst til å gjøre.

1009
01:20:51,000 --> 01:20:58,000
Det man kan gjøre da, er at jeg kan lage en ny klasse som arver fra den klassen jeg har lyst til å utvide.

1010
01:20:58,000 --> 01:21:05,000
Min spesialist kan arve fra liste, og så tar jeg bare og endrer, eller overskriver, add-metoden.

1011
01:21:05,000 --> 01:21:14,000
For spesialist skal add fungere annerledes enn liste, når du skal legge sammen en liste og en annen.

1012
01:21:17,000 --> 01:21:28,000
Hvis jeg skriver denne metoden på den første måten, så vil spesialistobjektene oppføre seg som Aris gjør, selvfølgelig mer tregere, fordi det var en liste i bunn, og den er ikke så rask.

1013
01:21:28,000 --> 01:21:30,000
Men du får den samme funksjonaliteten.

1014
01:21:31,000 --> 01:21:35,000
I tillegg til å endre hvordan ting fungerer, så kan du også...

1015
01:21:37,000 --> 01:21:43,000
Alt annet som lister kan gjøre, det trenger vi ikke å skrive på nytt, for det har vi bare arvet direkte fra listen.

1016
01:21:44,000 --> 01:21:50,000
I tillegg til å endre ting, så kan vi legge til nye metoder, vi kan legge til nye instansvariabler, vi kan gjøre mye gøy.

1017
01:21:53,000 --> 01:21:55,000
Mye muligheter.

1018
01:21:56,000 --> 01:22:07,000
Når mange klasser vi lager har mye til felles, så kan det være lurt å samle alt det som er felles i en overklass, som inneholder de felles tingene.

1019
01:22:07,000 --> 01:22:20,000
Så kan hver subklasse, arve fra denne moderklassen, sånn at vi har alt felles et sted, og alt som er spesielt er bare definert som unntaker som bekrefter reglene, husker jeg.

1020
01:22:21,000 --> 01:22:29,000
Hvis vi skal endre noe som er felles for alle disse klasserne, så trenger vi ikke endre de alle sammen, vi kan bare endre det et sted.

1021
01:22:32,000 --> 01:22:41,000
I likhet med funksjonene, så er klasser et verktøy for å håndtere kompleksitet, og la oss samle ting på et sted, så det kan gjenbrukes mange andre steder.

1022
01:22:42,000 --> 01:22:46,000
Det er for at programmet skal bli kortere, lettere å lese og lettere å jobbe med.

1023
01:22:47,000 --> 01:22:50,000
For ting blir fort komplekst nok, men likevel.

1024
01:22:51,000 --> 01:22:57,000
Et eksempel som dere har sett er disse ODE-algoritmerne for ordinære defensialbeininger.

1025
01:22:58,000 --> 01:23:07,000
De har mye til felles, men en metode vil være forskjellig for hver algoritme.

1026
01:23:08,000 --> 01:23:16,000
Alle av dere kan prøve å løse det samme problemet, og det er likevel det som er felles, men hvordan de løser det, det kommer an på hvilken du bruker.

1027
01:23:18,000 --> 01:23:23,000
Det er en kjapp repetisjon av en numerisk løsning av ordinære defensialbeininger.

1028
01:23:25,000 --> 01:23:34,000
Det stivereste på denne formen er at du har en annen funksjon som vi skal prøve å finne, en derivert av den, en annen funksjon av inputt og opputt av den funksjonen.

1029
01:23:38,000 --> 01:23:41,000
For å løse det numerisk, vi gjør det med en differenslenging.

1030
01:23:42,000 --> 01:23:45,000
Vi representerer den deriverte på denne måten.

1031
01:23:47,000 --> 01:23:51,000
Du deler opp en kontinuerlig funksjon i små steg, som gjør at den numeriske løsningen er mulig.

1032
01:23:52,000 --> 01:23:58,000
Du trenger også en annen startverdi, en annen grensebetingelse for å få det til.

1033
01:23:59,000 --> 01:24:10,000
Resultatet blir da arrays med verdier som tilnærmer funksjonen, og kan flottes etterpå av en inputt- og en output-array, som du kan flotte etterpå og se hvordan denne funksjonen ser ut.

1034
01:24:13,000 --> 01:24:20,000
Den algoritme som jeg har funnet i det jeg har sett i kurset så far er fordøyler.

1035
01:24:21,000 --> 01:24:23,000
Du har gitt initialbetingelser.

1036
01:24:23,000 --> 01:24:27,000
Du definerer en steglengde som kan kalles K eller DT.

1037
01:24:32,000 --> 01:24:39,000
Da vil denne regelen la deg finne neste inputtverdi, og så har du på samme måte en regel for å finne neste outputverdi.

1038
01:24:39,000 --> 01:24:46,000
Fordøyler er jo ikke den raskeste måten å løse definisjonen på, i måte i antall steg.

1039
01:24:48,000 --> 01:24:52,000
Den finner faktisk ikke alltid svaret heller. Den kan bli ustabil.

1040
01:24:53,000 --> 01:24:59,000
Hvis steglengden din er for stor, kan du fjerne deg mer og mer fra svaret, så det er ikke gitt at det konvergerer mot noe fornuftig.

1041
01:24:59,000 --> 01:25:04,000
Det finnes mer effektive og mer pålitelige algoritmer enn fordøyler.

1042
01:25:05,000 --> 01:25:10,000
Det er en som heter Leapfrog, som er ganske enkel og stabil.

1043
01:25:11,000 --> 01:25:19,000
Man kan bruke den ellers, men formålet med å lære fordøyler er å bygge opp en forståelse av steglengden.

1044
01:25:19,000 --> 01:25:21,000
Fordøyler er ganske intuitiv.

1045
01:25:22,000 --> 01:25:29,000
Veien fra den matematiske definisjonen til løsningsavgifter er ganske kort.

1046
01:25:32,000 --> 01:25:36,000
Dette er muligens egentlig mat-instensum, men jeg snikker litt over det.

1047
01:25:37,000 --> 01:25:40,000
Det er en matematisk instensum, men det er en matematisk instensum.

1048
01:25:40,000 --> 01:25:42,000
Det er muligens egentlig mat-instensum, men jeg snikker litt over det.

1049
01:25:46,000 --> 01:25:50,000
Det er muligens egentlig mat-instensum, men jeg snikker litt over det.

1050
01:25:51,000 --> 01:25:57,000
Det vil være relevant i mange sammenhenger senere.

1051
01:25:58,000 --> 01:26:04,000
Hvis steglengden din er for stor, går du alt for langt i steg, så blir svaret matematisk unngjaktig.

1052
01:26:05,000 --> 01:26:08,000
Eller hvis den er ustabil, blir det bare verre og verre.

1053
01:26:09,000 --> 01:26:16,000
Men hvis steglengden er for liten, blir den fryktelig liten i folket avrunningsfølg på maskinen, og da får vi problemer.

1054
01:26:17,000 --> 01:26:24,000
For hver gang noe er rundet av fordi tallet har bare gitt antall siffer, så vil vi miste veldig mye informasjon.

1055
01:26:25,000 --> 01:26:28,000
Så det gjelder å finne en steglengde som balanserer disse ytterfolket.

1056
01:26:29,000 --> 01:26:33,000
Du skal ha den matematiske unngjaktigheten i den tilnærmingen til funksjonen så liten som mulig.

1057
01:26:34,000 --> 01:26:37,000
Men den skal ikke bli så liten at vi begynner å få avrunningsproblemer.

1058
01:26:38,000 --> 01:26:40,000
Det kan være forskjellig fra case to case.

1059
01:26:41,000 --> 01:26:44,000
Der refererer jeg bare til en matinformatisk liknende kurs.

1060
01:26:45,000 --> 01:26:49,000
Det er mulig at fysikkvarianten av dette også tar det opp.

1061
01:26:50,000 --> 01:26:51,000
Det får vi håpe.

1062
01:26:55,000 --> 01:27:00,000
Det som er viktig er å kjenne til hvordan man lager en enkel ODE-løser med en klasse.

1063
01:27:01,000 --> 01:27:02,000
Det har dere jo jobbet med nå.

1064
01:27:03,000 --> 01:27:07,000
Og det er også viktig å ikke glemme hvordan man bruker en sånn ODE-løser i et annet program.

1065
01:27:09,000 --> 01:27:12,000
Folk blir ofte veldig flinke til å skrive i klasser.

1066
01:27:13,000 --> 01:27:15,000
Og så er det litt verre hvordan man bruker en klasse.

1067
01:27:16,000 --> 01:27:21,000
Jeg mistenker det skyldes at folk har lært seg noen klasser uten at de kan liste og string.

1068
01:27:22,000 --> 01:27:25,000
Når vi skal lage en klasse selv, hvordan bruker jeg denne?

1069
01:27:26,000 --> 01:27:28,000
Så kan det være lurt å trene litt på.

1070
01:27:29,000 --> 01:27:30,000
Så øv dere på å bruke det.

1071
01:27:31,000 --> 01:27:35,000
Og gjerne bruk disse ODE-solverene som et eksempel, for de dukker jo gjerne opp.

1072
01:27:38,000 --> 01:27:41,000
Helt avslutningsvis, så er vi nesten på tida.

1073
01:27:42,000 --> 01:27:46,000
Neste uke, samme tid, samme sted, så blir det en gjennomgang av prøveeksamen.

1074
01:27:47,000 --> 01:27:50,000
Prøveeksamen legges ut før gjennomgangen, åpenbart.

1075
01:27:51,000 --> 01:27:57,000
Jeg lurer på om de faktisk sa dagen før man skulle ha at det legges ut på mandag en gang.

1076
01:27:58,000 --> 01:28:01,000
Vi får se om det blir da eller om det blir tidligere.

1077
01:28:02,000 --> 01:28:03,000
Men i hvert fall senest mandag er planen.

1078
01:28:04,000 --> 01:28:07,000
Så skal vi ta en gjennomgang her neste uke, og det er det jeg skal gjøre.

1079
01:28:08,000 --> 01:28:10,000
Jeg vet at det ikke står i minestudiet.

1080
01:28:13,000 --> 01:28:16,000
Så vi må legge ut en beskjed på evnesida, så folk vet om det.

1081
01:28:17,000 --> 01:28:18,000
Men nå vet i hvert fall dere at det skjer.

1082
01:28:19,000 --> 01:28:23,000
Spre gjerne ordet til andre, som at prøveeksamen kommer.

1083
01:28:24,000 --> 01:28:30,000
Da kan man øve seg på å logge inn i en spæra, som er det vi bruker i eksamenslokalet, og løse det hjemmefra.

1084
01:28:31,000 --> 01:28:33,000
Så dere blir vant til eksamenssystemet og oppgavetyper og sånne ting.

1085
01:28:34,000 --> 01:28:37,000
Så tar vi gjennomgangen her, tirsdag om i uke.

1086
01:28:38,000 --> 01:28:39,000
Så må dere gjøre det samme med dere.

1087
01:28:40,000 --> 01:28:43,000
Så spre ordet, og takk for meg.