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.