1
00:00:02,982 --> 00:00:06,461
[SKAN MŪZIKA]

2
00:01:12,065 --> 00:01:13,210
DEIVIDS MALANS: Labi.

3
00:01:13,210 --> 00:01:17,072
Tas ir CS50, un šī ir sestā nedēļa,
kurā mēs beidzot pārejam no 

4
00:01:17,072 --> 00:01:20,935
Scratch uz C, un tagad uz Python. 

5
00:01:20,935 --> 00:01:24,575
Un patiesi, šī būs zināmā mērā
unikāla pieredze, jo, tāpat kā pirms 

6
00:01:24,575 --> 00:01:28,215
dažām nedēļām — iespējams, pirmo
reizi — un tagad, šodien, jūs 

7
00:01:28,215 --> 00:01:31,855
apgūsiet jaunu valodu. 

8
00:01:31,855 --> 00:01:34,940
Taču mērķis šeit nav tikai noslogot
jūs ar saturu, sintaksi un ko tur 

9
00:01:34,940 --> 00:01:38,025
vēl, bet drīzāk - nodrošināt jums
visiem zināšanas, lai nākotnē jūs 

10
00:01:38,025 --> 00:01:41,110
paši sev mācītu jaunas valodas. 

11
00:01:41,110 --> 00:01:43,845
Un tāpēc patiešām - tas, ko mēs
darīsim šodien, tas, ko mēs darīsim 

12
00:01:43,845 --> 00:01:46,580
šonedēļ, ir - palīdzēt jums būt
neatkarīgiem. 

13
00:01:46,580 --> 00:01:49,813
Un, kad Python būs pagātne un
pasaule būs pārgājusi uz kādu citu 

14
00:01:49,813 --> 00:01:53,046
valodu, jūs būsiet labi sagatavoti,
lai saprastu, kā apgūt kādu jaunu 

15
00:01:53,046 --> 00:01:56,280
sintaksi, jaunu valodu un risināt
problēmas. 

16
00:01:56,280 --> 00:01:58,835
Tagad atcerieties, nulles nedēļā
mēs sākām šeit — vienkārši sveicam 

17
00:01:58,835 --> 00:02:01,390
pasauli. 

18
00:02:01,390 --> 00:02:03,820
Un jau nedēļu vēlāk valodā C, viss
strauji kļuva daudz, daudz 

19
00:02:03,820 --> 00:02:06,250
sarežģītāks. 

20
00:02:06,250 --> 00:02:09,445
Un, ja jums joprojām ir problēmas
ar sintaksi, pārbaudāt savas 

21
00:02:09,445 --> 00:02:12,640
piezīmes vai iepriekšējo kodu, tas
ir pilnīgi normāli. 

22
00:02:12,640 --> 00:02:15,805
Un tas ir viens no iemesliem, kāpēc
bez C ir arī citas valodas, 

23
00:02:15,805 --> 00:02:18,970
tostarp šī valoda, ko sauc par
Python. 

24
00:02:18,970 --> 00:02:21,230
Cilvēki gadu desmitu garumā ir
sapratuši: jee, tas ne vienmēr bija 

25
00:02:21,230 --> 00:02:23,490
labākais dizaina risinājums, vai
arī cilvēki ir sapratuši: oho, jūs 

26
00:02:23,490 --> 00:02:25,750
zināt ko? 

27
00:02:25,750 --> 00:02:28,190
Tagad, kad datori ir kļuvuši ātrāki
ar lielāku atmiņu un ātrākiem 

28
00:02:28,190 --> 00:02:30,630
centrālajiem procesoriem, mēs
faktiski ar mūsu programmēšanas valodām 

29
00:02:30,630 --> 00:02:33,070
varam paveikt vairāk. 

30
00:02:33,070 --> 00:02:35,027
Tātad, tāpat kā cilvēka valodas
attīstās, attīstās arī faktiskās 

31
00:02:35,027 --> 00:02:36,985
programmēšanas valodas. 

32
00:02:36,985 --> 00:02:40,810
Un pat programmēšanas valodā
parasti ir dažādas versijas.

33
00:02:40,810 --> 00:02:43,765
Mēs, piemēram, esam izmantojuši
valodas C C11 versiju, kas tika 

34
00:02:43,765 --> 00:02:46,720
atjaunināta 2011. gadā. 

35
00:02:46,720 --> 00:02:48,760
Taču pati Python valoda turpina
attīstīties, un tagad tai ir 3  plus 

36
00:02:48,760 --> 00:02:50,800
versija. 

37
00:02:50,800 --> 00:02:53,680
Un arī tur šīs lietas attīstīsies
tuvākajā nākotnē.

38
00:02:53,680 --> 00:02:56,560
Par laimi, tas, ko jūs tūlīt
redzēsiet, ir “Hello, World!” trešo 

39
00:02:56,560 --> 00:02:59,440
reizi, bet tas būs burtiski tā: 

40
00:02:59,440 --> 00:03:02,605
Nekādas trakās sintakses augšā vai
lejā, mazāk semikolu, ja tādi ir, 

41
00:03:02,605 --> 00:03:05,770
mazāk iekavu. 

42
00:03:05,770 --> 00:03:08,630
Un patiešām daudzi traucējošie
faktori pazūd.

43
00:03:08,630 --> 00:03:13,000
Tātad, lai tur nokļūtu, apsvērsim,
kā mēs līdz šim esam programmējuši.

44
00:03:13,000 --> 00:03:16,067
Tātad jūs rakstāt programmu C
valodā, un, cerams, jums nav sintakses 

45
00:03:16,067 --> 00:03:19,135
kļūdu, tāpēc esat gatavs to
izveidot, tas ir - kompilēt. 

46
00:03:19,135 --> 00:03:20,635
Un tā: jūs palaižat make, un pēc
tam palaižat programmu, piemēram, 

47
00:03:20,635 --> 00:03:22,135
./hello. 

48
00:03:22,135 --> 00:03:25,123
Vai, ja atcerēsieties otro nedēļu,
kad mēs ielūkojāmies zem pārsega 

49
00:03:25,123 --> 00:03:28,112
tajā, ko dara make, tā tiešām
palaiž faktisko kompilatoru — ko sauc 

50
00:03:28,112 --> 00:03:31,101
par clang — varbūt ar dažiem
komandrindas argumentiem izveido 

51
00:03:31,101 --> 00:03:34,090
programmu ar nosaukumu hello. 

52
00:03:34,090 --> 00:03:36,128
Un tad jūs varētu izdarīt ./hello.

53
00:03:36,128 --> 00:03:38,199
Tātad šodien jūs sāksiet darīt kaut
ko līdzīgu pēc būtības, bet ar 

54
00:03:38,199 --> 00:03:40,270
mazākiem soļiem. 

55
00:03:40,270 --> 00:03:42,670
Jums vairs nebūs jākompilē savs
kods un pēc tam tas jāpalaiž, un pēc 

56
00:03:42,670 --> 00:03:45,070
tam, iespējams, tas jālabo vai
jāmaina, un pēc tam jāapkopo kods un 

57
00:03:45,070 --> 00:03:47,470
jāpalaiž tas, un tad atkārtot un
atkārtot to atkal. 

58
00:03:47,470 --> 00:03:52,542
Koda palaišanas process tiks
vienkāršots līdz tikai vienai darbībai.

59
00:03:52,542 --> 00:03:55,841
Pagaidām par to var domāt, ka, lai
gan C bieži tiek izmantota kā 

60
00:03:55,841 --> 00:03:59,141
kompilēta valoda, kurā jūs vispirms
to konvertējat nullēs un 

61
00:03:59,141 --> 00:04:02,440
vieniniekos, Python ļaus jums
paātrināt darbu, kurājums, 

62
00:04:02,440 --> 00:04:05,740
cilvēkprogrammētājiem, nav
jākompilē. 

63
00:04:05,740 --> 00:04:08,612
Jūs vienkārši palaidīsiet tā saukto
tulku — kas pēc konstrukcijas ir 

64
00:04:08,612 --> 00:04:11,485
nosaukts tieši tāpat kā pati
valoda — un palaidīsiet šo programmu, 

65
00:04:11,485 --> 00:04:14,357
kas būs instalēta VS Code vai arī
jūsu Mac datoros vai personīgajos 

66
00:04:14,357 --> 00:04:17,230
datoros. 

67
00:04:17,230 --> 00:04:20,515
Tas tikai liks jūsu datoram
interpretēt šo kodu un izdomāt, kā nokļūt 

68
00:04:20,515 --> 00:04:23,800
līdz zemākajam 0 un 1 līmenim. 

69
00:04:23,800 --> 00:04:26,626
Bet kods vairs nav jākompilē pašam.

70
00:04:26,626 --> 00:04:31,690
Ņemot to vērā, padomājiet, kā kods
izskatīsies blakus.

71
00:04:31,690 --> 00:04:34,136
Patiesībā, apskatīsim dažus Scratch
blokus, tāpat kā mēs darījām 

72
00:04:34,136 --> 00:04:36,582
pirmajā nedēļā ar valodu C, un
izpildīsim vēl dažus blakus. 

73
00:04:36,582 --> 00:04:39,643
Jo, lai gan dažas sintakses šonedēļ
un turpmāk būs atšķirīgas, idejas 

74
00:04:39,643 --> 00:04:42,705
patiešām būs vienādas. 

75
00:04:42,705 --> 00:04:45,565
Pagaidām nav tik daudz kā
intelektuāli jauna.

76
00:04:45,565 --> 00:04:49,070
Tā kā nulles nedēļā mēs, iespējams,
būtu sasveicinājušies ar pasauli 

77
00:04:49,070 --> 00:04:52,575
ar šo purpursarkano uzdevumu,
šodien, protams, vai, pareizāk sakot, 

78
00:04:52,575 --> 00:04:56,080
pirmajā nedēļā, C valodā tas
izskatījās šādi. 

79
00:04:51,220 --> 00:04:54,942
Bet šodien, virzoties uz priekšu,
tas gluži vienkārši izskatīsies 

80
00:04:54,942 --> 00:04:58,665
šādi. 

81
00:04:58,665 --> 00:05:02,082
Un, ja mēs virzāmies turp un
atpakaļ - tikai uz mirkli, šeit atkal ir 

82
00:05:02,082 --> 00:05:05,500
valodas C versija - pamanot C
valodai līdzīgās īpašības. 

83
00:05:05,500 --> 00:05:07,350
Un tikai mazs ieskats šeit, Python
valodā, es apgalvoju, ka tagad tas 

84
00:05:07,350 --> 00:05:09,200
ir šis. 

85
00:05:09,200 --> 00:05:13,190
Par ko jums šķietami vairs nav
jāuztraucas?

86
00:05:13,190 --> 00:05:14,940
Kas pazuda?

87
00:05:14,940 --> 00:05:15,990
Tātad semikols ir pazudis.

88
00:05:15,990 --> 00:05:17,531
Un tiešām, jums tie vairs nav
vajadzīgi, lai pabeigtu lielāko savu 

89
00:05:17,531 --> 00:05:19,073
domu daļu. 

90
00:05:19,073 --> 00:05:19,830
Vēl kaut kas?

91
00:05:19,830 --> 00:05:20,860
Mērķauditorija: slīpsvītra n.

92
00:05:20,860 --> 00:05:22,690
DEIVIDS MALANS: Tātad slīpsvītras n
nav.

93
00:05:22,690 --> 00:05:24,837
Un tas ir interesanti, jo mēs
joprojām iegūsim jaunu līniju, taču mēs 

94
00:05:24,837 --> 00:05:26,985
redzēsim, ka tā ir kļuvusi par
noklusējuma līniju. 

95
00:05:26,985 --> 00:05:29,085
Un šī ir nedaudz smalkāka, taču
tagad funkcija tiek saukta par print, 

96
00:05:29,085 --> 00:05:31,185
nevis par printf. 

97
00:05:31,185 --> 00:05:33,610
Tāpēc šajā ziņā tā ir nedaudz
pazīstamāka.

98
00:05:33,610 --> 00:05:34,110
Labi.

99
00:05:34,110 --> 00:05:37,176
Tātad, runājot par bibliotēku
izmantošanu — tas ir, kodu, ko citi 

100
00:05:37,176 --> 00:05:40,242
cilvēki ir uzrakstījuši, — mēs esam
izdarījuši tādas darbības kā 

101
00:05:40,242 --> 00:05:43,308
#include cs50.h, lai izmantotu CS50
galvenes datni vai standarta I/O, 

102
00:05:43,308 --> 00:05:46,374
vai standarta lib, vai virkni, vai
jebkuras citas galvenes datnes, 

103
00:05:46,374 --> 00:05:49,440
visas, ko esat izmantojuši. 

104
00:05:49,440 --> 00:05:52,146
Turpinot, šajā pirmajā nedēļā, mēs
jums iedosim līdzīgu CS50 

105
00:05:52,146 --> 00:05:54,853
bibliotēku — tikai īsa apmācība, un
mēs ātri izkustēsimies, jo 

106
00:05:54,853 --> 00:05:57,560
patiesībā strādāt Python valodā ir
daudz vieglāk, kā mēs to vēlāk 

107
00:05:57,560 --> 00:06:00,267
redzēsim. 

108
00:06:00,267 --> 00:06:02,716
Bet sintakse tai darbībai tagad būs
CS50 bibliotēkas importēšana šādā 

109
00:06:02,716 --> 00:06:05,165
veidā. 

110
00:06:05,165 --> 00:06:07,537
Un, kad mums ir šī iespēja, mēs
faktiski uzreiz varam sākt rakstīt 

111
00:06:07,537 --> 00:06:09,910
kādu kodu. 

112
00:06:09,910 --> 00:06:12,420
Patiesībā ļaujiet man šeit pāriet
uz VS kodu.

113
00:06:12,420 --> 00:06:14,760
Un tāpat kā agrāk es izveidošu
jaunu datni.

114
00:06:14,760 --> 00:06:17,260
Bet tā vietā, lai izveidotu kaut ko
ar nosaukumu .c, es iešu uz 

115
00:06:17,260 --> 00:06:19,760
priekšu un izveidošu savu pirmo
programmu ar nosaukumu hello.py, 

116
00:06:19,760 --> 00:06:22,260
izmantojot koda vietu hello punkts
py. 

117
00:06:22,260 --> 00:06:24,000
Tas, protams, dod man šo jauno
cilni.

118
00:06:24,000 --> 00:06:28,890
Un ļaujiet man, gluži vienkārši,
darīt to, ko es ierosināju — print, 

119
00:06:28,890 --> 00:06:33,780
"Hello, world" bez /n, bez
semikola, bez f komandā print. 

120
00:06:33,780 --> 00:06:36,270
Un tagad ļaujiet man doties uz savu
termināļa logu.

121
00:06:36,270 --> 00:06:37,792
Un man tas nav jākompilē.

122
00:06:37,792 --> 00:06:39,000
Man nav jādara punktveida
slīpsvītra.

123
00:06:39,000 --> 00:06:41,393
Tā vietā es palaidu programmu ar
nosaukumu python, kuras pastāvēšanas 

124
00:06:41,393 --> 00:06:43,786
mērķis tagad ir interpretēt manu
kodu no augšas uz leju, no kreisās 

125
00:06:43,786 --> 00:06:46,180
puses uz labo. 

126
00:06:46,180 --> 00:06:48,590
Un, ja es palaistu python no
hello.py, turot īkšķus, kā vienmēr - 

127
00:06:48,590 --> 00:06:51,000
voilà! 

128
00:06:51,000 --> 00:06:53,245
Tagad esmu izdrukājis "hello,
world." Tāpēc šķiet, ka mēs esam 

129
00:06:53,245 --> 00:06:55,490
ieguvuši jaunu rindiņu bez maksas
tādā nozīmē, ka tas notiek 

130
00:06:55,490 --> 00:06:57,735
automātiski. 

131
00:06:57,735 --> 00:06:59,977
Dolāra zīme nav dīvaini izvietota
tajā pašā rindiņā, kā tas kādreiz 

132
00:06:59,977 --> 00:07:02,220
bija pirmajā nedēļā. 

133
00:07:02,220 --> 00:07:04,493
Bet tā šeit ir tikai neliela
detaļa.

134
00:07:04,493 --> 00:07:07,260
Ja tagad pārejam atpakaļ uz dažām
citām iespējām — tiešām, ar CS50 

135
00:07:07,260 --> 00:07:10,027
bibliotēku, jūs varat arī ne tikai
importēt pašu bibliotēku, bet arī 

136
00:07:10,027 --> 00:07:12,795
noteiktas funkcijas. 

137
00:07:12,795 --> 00:07:15,487
Un jūs redzēsiet, ka īslaicīgi mēs
jums piešķirsim palīgfunkciju, ko 

138
00:07:15,487 --> 00:07:18,179
sauc par get_string, tāpat kā
valodā C, kas liek tai darboties tieši 

139
00:07:18,179 --> 00:07:20,872
tāpat kā C valodā. 

140
00:07:20,872 --> 00:07:22,766
Un mēs redzēsim pāris citas
funkcijas, kas primāri tikai atvieglos 

141
00:07:22,766 --> 00:07:24,660
dzīvi. 

142
00:07:24,660 --> 00:07:26,977
Bet, ātri, vai mēs ietrenēsimies
tā, lai nekas patiešām nebūtu 

143
00:07:26,977 --> 00:07:29,295
līdzīgs CS50? 

144
00:07:29,295 --> 00:07:29,970
Labi.

145
00:07:29,970 --> 00:07:32,640
Nu, kā Python vispārīgāk ir ar
funkcijām?

146
00:07:32,640 --> 00:07:35,790
Ja vēlaties, uztaisīsim ātru
ievadu, līdzīgi kā mēs to darījām 

147
00:07:35,790 --> 00:07:38,940
pirmajā nedēļā ar valodu C,
salīdzinot vienu ar otru. 

148
00:07:38,940 --> 00:07:42,150
Tātad mūsu Scratch pasaulē viena no
pirmajām programmām, ko mēs 

149
00:07:42,150 --> 00:07:45,360
rakstījām, bija šī te, kur mēs
prasījām cilvēkiem viņu vārdu. 

150
00:07:45,360 --> 00:07:48,855
Pēc tam mēs izmantojām atgriešanās
vērtību, kas tika automātiski 

151
00:07:48,855 --> 00:07:52,350
saglabāta šajā atbildes mainīgajā
kā otrs arguments, lai pievienojot, 

152
00:07:52,350 --> 00:07:55,845
lmēs varētu teikt "Hello, David"
vai "Hello, Carter". Tātad, tas bija 

153
00:07:55,845 --> 00:07:59,340
nulles nedēļā. 

154
00:07:59,340 --> 00:08:01,143
Pirmajā nedēļā mēs to pārveidojām
uz šo.

155
00:08:01,143 --> 00:08:03,810
Un šeit ir lielisks piemērs tādām
lietām kā ātrā eskalācija.

156
00:08:03,810 --> 00:08:05,910
Un atkal tāpēc mēs sākām lietot
Scratch.

157
00:08:05,910 --> 00:08:09,060
Šeit ir tikai tik daudz traucēkļu
tās pašas idejas sasniegšanā. 

158
00:08:09,060 --> 00:08:12,010
Un pat šodien mēs atteiksimies no
daļas no šīs sintakses.

159
00:08:12,010 --> 00:08:17,940
Tātad valodā C, mums bija jādeklarē
mainīgais kā virkne, te.

160
00:08:17,940 --> 00:08:19,935
Mums, protams, bija semikols un tā
tālākk.

161
00:08:19,935 --> 00:08:23,017
Nu, Python valodā salīdzināmais
kods tagad izskatīsies vienkāršāk - 

162
00:08:23,017 --> 00:08:26,100
šādi. 

163
00:08:26,100 --> 00:08:29,250
Tātad semikols atkal pazudis abās
rindās, tā iemesla dēļ.

164
00:08:29,250 --> 00:08:30,450
Tātad tas ir labi.

165
00:08:30,450 --> 00:08:33,100
Kas vēl, šķiet, ir mainījies vai
pazudis?

166
00:08:33,100 --> 00:08:33,600
Jā.

167
00:08:33,600 --> 00:08:35,340
Mērķauditorija: [? Vai jums ir?]

168
00:08:33,600 --> 00:08:35,340
tāda paša veida mainīgais?

169
00:08:35,340 --> 00:08:36,090
DEIVIDS MALANS: Jā.

170
00:08:36,090 --> 00:08:39,419
Tāpēc man nebija īpaši jāsaka, ka
atbilde tagad ir virkne.

171
00:08:39,419 --> 00:08:41,820
Un patiešām Python valoda ir
dinamiski drukāta.

172
00:08:41,820 --> 00:08:44,910
Un patiesībā tā no konteksta
secinās, ko tieši jūs glabājat šajā 

173
00:08:44,910 --> 00:08:48,000
mainīgajā. 

174
00:08:48,000 --> 00:08:50,775
Citas detaļas, kas šķiet nedaudz
atšķirīgas?

175
00:08:53,640 --> 00:08:54,607
Mazliet savādākas.

176
00:08:54,607 --> 00:08:55,940
Kas vēl jums iekrīt acīs?

177
00:08:55,940 --> 00:08:56,482
es atgriezīšos.

178
00:08:56,482 --> 00:08:58,690
Šī bija C versija.

179
00:08:58,690 --> 00:09:00,715
Un varbūt tagad koncentrējieties uz
otro rindiņu, jo mēs esam gana 

180
00:09:00,715 --> 00:09:02,740
izsmēluši pirmo. 

181
00:09:02,740 --> 00:09:04,690
Šeit ir Python versija.

182
00:09:04,690 --> 00:09:05,720
Kas šeit atšķiras?

183
00:09:05,720 --> 00:09:06,220
Jā?

184
00:09:06,220 --> 00:09:08,845
Mērķauditorija: jums nav
jāuztraucas par %s vai procentiem.

185
00:09:08,845 --> 00:09:10,930
mainīgais pēc [? tiem. ?]

186
00:09:10,930 --> 00:09:11,680
DEIVIDS MALANS: Jā.

187
00:09:11,680 --> 00:09:12,820
Nav vairs neviena %s.

188
00:09:12,820 --> 00:09:16,480
Patlaban nav otra argumenta, kā
tāda, ko drukāt.

189
00:09:16,480 --> 00:09:17,818
Tagad tas joprojām ir nedaudz
dīvaini.

190
00:09:17,818 --> 00:09:20,485
It kā es šeit būtu aritmētiski
izvietojis kādu papildinājumu.

191
00:09:20,485 --> 00:09:21,860
Bet tas tā nav.

192
00:09:21,860 --> 00:09:23,230
Dažiem no jums jau ir bijusi
programma.

193
00:09:23,230 --> 00:09:27,377
Un daži no jums varētu zināt, ko
nozīmē pluss šajā kontekstā?

194
00:09:27,377 --> 00:09:29,960
Tātad, lai apvienotu vai,
tehniskajā valodā, kāds zina šo žargonvārdu?

195
00:09:29,960 --> 00:09:30,390
Jā.

196
00:09:30,390 --> 00:09:31,040
Mērķauditorija: Konkatenēt.

197
00:09:31,040 --> 00:09:32,460
DEIVIDS MALANS: Konkatenēt.

198
00:09:32,460 --> 00:09:35,006
Tātad konkatenēt - ir stilīgs
veids, ko Scratch sauc par 

199
00:09:35,006 --> 00:09:37,553
pievienošanu, proti, - paņemt vienu
virkni kreisajā pusē, vienu 

200
00:09:37,553 --> 00:09:40,100
virkni labajā un savienot tās kopā.


201
00:09:40,100 --> 00:09:41,880
Lai tos salīmētu kopā, ja vēlaties.

202
00:09:41,880 --> 00:09:43,080
Tātad tas nav papildinājums.

203
00:09:43,080 --> 00:09:45,080
Tā būtu, ja tā vietā būtu
iesaistīti skaitļi.

204
00:09:45,080 --> 00:09:47,900
Bet tāpēc, ka šajā mainīgajā mums
ir virkne — Hello comma — un vēl 

205
00:09:47,900 --> 00:09:50,720
viena virkne, pamatojoties uz to,
ko cilvēks ievadīja, reaģējot uz šo 

206
00:09:50,720 --> 00:09:53,540
get_string funkciju. 

207
00:09:53,540 --> 00:09:56,588
Tas konkatenēs Hello, komats,
atstarpe, un pēc tam Deivids vai 

208
00:09:56,588 --> 00:09:59,637
Kārters vai ko citu, ko cilvēks ir
ierakstījis. 

209
00:09:59,637 --> 00:10:02,720
Bet izrādās, ka Python valodā to
var izdarīt savādākos veidos.

210
00:10:02,720 --> 00:10:04,387
Un mēs jums parādīsim dažus no
tiem.

211
00:10:04,387 --> 00:10:06,821
Un arī šajā gadījumā mēģiniet
nesatraukties vai neapjaukt no 

212
00:10:06,821 --> 00:10:09,255
dažnedažādiem veidiem, kā var
atrisināt problēmas. 

213
00:10:09,255 --> 00:10:11,677
Izredzes ir tādas, ka jūs saņemsiet
padomus un paņēmienus visam 

214
00:10:11,677 --> 00:10:14,100
mūžam, ja turpināsiet programmēt,. 

215
00:10:14,100 --> 00:10:16,710
Tāpēc sniegsim tikai dažus
iespējamos veidus.

216
00:10:16,710 --> 00:10:19,195
Tātad, šeit ir otrs veids, kā
izdrukāt hello, komats, Deivids vai 

217
00:10:19,195 --> 00:10:21,680
hello, komats, Kārters. 

218
00:10:21,680 --> 00:10:22,655
Bet kas ir mainījies?

219
00:10:22,655 --> 00:10:26,030
Iepriekšējā versijā es skaidri
izmantoju konkatenēšanu.

220
00:10:26,030 --> 00:10:28,257
Un atstarpe šeit ir gramatiski
svarīga, lai mēs to iegūtu pēdējā 

221
00:10:28,257 --> 00:10:30,485
frāzē. 

222
00:10:30,485 --> 00:10:33,735
Tagad es ierosinu atbrīvoties no
šīs atstarpes, lai pievienotu komatu 

223
00:10:33,735 --> 00:10:36,985
arī ārpus pēdiņām. 

224
00:10:36,985 --> 00:10:39,723
Bet, ja atcerēsieties C valodu,
tas, iespējams, nozīmē tikai to, ka 

225
00:10:39,723 --> 00:10:42,461
print, kas pēc būtības ir līdzīga
printf, var būt ne tikai viens 

226
00:10:42,461 --> 00:10:45,200
arguments, bet pat divi. 

227
00:10:45,200 --> 00:10:48,940
Un patiesībā šī komata dēļ pēdiņām
pa vidu, tas ir hello, komats, un 

228
00:10:48,940 --> 00:10:52,680
pēc tam tas tiks automātiski
konkatenēts ar — pat neizmantojot plusu, 

229
00:10:52,680 --> 00:10:56,420
neatkarīgi no atbildes vērtības. 

230
00:10:56,420 --> 00:10:59,320
Un pēc noklusējuma, tikai
gramatikas skaistumam, print funkcija 

231
00:10:59,320 --> 00:11:02,220
vienmēr nodrošina atstarpi starp
katru no vairākiem argumentiem, ko 

232
00:11:02,220 --> 00:11:05,120
ievadāt. 

233
00:11:05,120 --> 00:11:07,290
Mēs redzēsim, kā jūs varat to
ignorēt.

234
00:11:07,290 --> 00:11:09,248
Bet pagaidām tas ir tikai vēl viens
veids, kā to izdarīt.

235
00:11:09,248 --> 00:11:12,262
Tagad, iespējams, labāks, kaut arī
nedaudz sarežģīts veids, kā to 

236
00:11:12,262 --> 00:11:15,276
izdarīt – vai tikai arvien biežāk
sastopamais veids – iespējams, ir 

237
00:11:15,276 --> 00:11:18,290
trešā versija, kas arī izskatās
nedaudz dīvaina. 

238
00:11:18,290 --> 00:11:20,555
Un, iespējams, dīvainības izlec.

239
00:11:20,555 --> 00:11:23,036
Mēs pēkšņi esam ieviesuši šīs
figūriekavas, kuru, es apsolīju, 

240
00:11:23,036 --> 00:11:25,518
lielākoties vairs nav. 

241
00:11:25,518 --> 00:11:26,060
Un tās ir.

242
00:11:26,060 --> 00:11:28,790
Bet šīs virknes iekšpusē esmu
izveidojis figūriekavas, ko tas varētu 

243
00:11:28,790 --> 00:11:31,520
nozīmēt? 

244
00:11:31,520 --> 00:11:32,918
Tikai intuitīvi.

245
00:11:32,918 --> 00:11:35,210
Un šeit ir piemērs, kā jūs mācāties
jaunu valodu.

246
00:11:35,210 --> 00:11:39,945
Vienkārši no konteksta seciniet, kā
Python, iespējams, darbojas.

247
00:11:39,945 --> 00:11:40,820
Ko tas varētu nozīmēt?

248
00:11:40,820 --> 00:11:41,320
Jā?

249
00:11:41,320 --> 00:11:45,160
Mērķauditorija: [nesadzirdami]

250
00:11:45,160 --> 00:11:45,910
DEIVIDS MALANS: Jā.

251
00:11:45,910 --> 00:11:49,053
Tātad šī ir norāde, jo
figūriekavas — jo tā tika izstrādāta Python 

252
00:11:49,053 --> 00:11:52,196
valoda — mēs vēlamies pievienot
atbildes vērtību, nevis burtiski 

253
00:11:52,196 --> 00:11:55,340
ATBILDI. 

254
00:11:55,340 --> 00:11:58,410
Un stilīgais vārds šeit ir tāds, ka
atbildes mainīgais tiks 

255
00:11:58,410 --> 00:12:01,480
interpolēts, tas ir - tiks aizstāts
ar tā faktisko vērtību. 

256
00:12:01,480 --> 00:12:04,150
Bet, bet, bet-- un tas patiesībā
izskatās dīvaini; tas tika ieviests 

257
00:12:04,150 --> 00:12:06,820
Python valodā pirms dažiem gadiem. 

258
00:12:06,820 --> 00:12:11,230
Acīmredzot kas man vēl bija
jāmaina, lai šīs figūriekavas darbotos?

259
00:12:11,230 --> 00:12:11,935
Jā?

260
00:12:11,935 --> 00:12:14,260
Mērķauditorija: Nometiet f pirms...
DEIVIDS MALANS: Jā.

261
00:12:14,260 --> 00:12:15,160
Tur ir šis dīvainais f.

262
00:12:15,160 --> 00:12:17,245
Un tā, tā ir kā daļa no printf.

263
00:12:17,245 --> 00:12:20,950
Bet tagad tas ir iekavās.

264
00:12:20,950 --> 00:12:22,945
Tas ir tikai veids, kā Python to
izstrādāja.

265
00:12:22,945 --> 00:12:25,990
Tāpēc pirms dažiem gadiem, kad viņi
ieviesa tā sauktās formāta 

266
00:12:25,990 --> 00:12:29,035
virknes vai fstrings, jūs burtiski
pievienojāt burtu f virknēm 

267
00:12:29,035 --> 00:12:32,080
pēdiņās. 

268
00:12:32,080 --> 00:12:35,125
Un pēc tam var izmantot šādas
viltības, piemēram, ievietot 

269
00:12:35,125 --> 00:12:38,170
figūriekavas, lai vērtība tiktu
automātiski aizstāta. 

270
00:12:38,170 --> 00:12:40,750
Ja aizmirstat f, jūs burtiski
redzēsiet hello, komats, figūriekavas, 

271
00:12:40,750 --> 00:12:43,330
atbilde, aizverošās figūriekavas. 

272
00:12:43,330 --> 00:12:45,355
Ja pievienojat f, tas patiešām ir
interpolēts.

273
00:12:45,355 --> 00:12:47,360
Vērtība ir pievienota.

274
00:12:47,360 --> 00:12:47,860
Labi.

275
00:12:47,860 --> 00:12:50,185
Jautājumi par to, kā šajā gadījumā
mēs varam vienkārši sasveicināties 

276
00:12:50,185 --> 00:12:52,510
ar pasauli, izmantojot Python. 

277
00:12:52,510 --> 00:12:53,350
Jā?

278
00:12:53,350 --> 00:12:55,280
Mērķauditorija: Ja jūs to darītu
bez f, kas notiktu?

279
00:12:55,280 --> 00:12:57,260
Mērķauditorija: [? F. ?]

280
00:12:57,260 --> 00:12:58,385
DEIVIDS MALANS: Bez f?

281
00:12:58,385 --> 00:13:01,557
Ja izlaidīsiet f, jūs burtiski
redzēsit HELLO, komats, figūriekavas, 

282
00:13:01,557 --> 00:13:04,730
ATBILDE, aizverošās figūriekavas. 

283
00:13:04,730 --> 00:13:05,930
Tad patiešām izdarīsim to.

284
00:13:05,930 --> 00:13:08,300
Ļaujiet man ātri atgriezties pie VS
Code šeit.

285
00:13:08,300 --> 00:13:11,540
Man joprojām ir atvērta datne ar
nosaukumu hello.py.

286
00:13:11,540 --> 00:13:14,210
Un ļaujiet man iet uz priekšu un
nedaudz mainīt to.

287
00:13:14,210 --> 00:13:20,930
Tāpēc es iešu uz priekšu un,
teiksim, no cs50 importēšu get_string.

288
00:13:20,930 --> 00:13:23,540
Un tā ir tikai jaunā sintakse, ko
es ierosinu izmantot, lai importētu 

289
00:13:23,540 --> 00:13:26,150
funkciju no kāda cita bibliotēkas. 

290
00:13:26,150 --> 00:13:29,705
Tagad es uzdošu jautājumu —
izmantosim get_string, saglabājot 

291
00:13:29,705 --> 00:13:33,260
atbildes rezultātu. 

292
00:13:33,260 --> 00:13:37,855
Tātad get_string, pēdiņās "What's
your name?" Un tad šajā rindā es 

293
00:13:37,855 --> 00:13:42,450
apzināti kļūdīšos, tieši kā jūsu
jautājumā. 

294
00:13:42,450 --> 00:13:46,820
Ļaujiet man vienkārši pateikt
hello, komats, atbilde, un tikai šo.

295
00:13:46,820 --> 00:13:50,315
Pat ja atbilde ir mainīgais, Python
nebūs tik pārgalvīga, lai 

296
00:13:50,315 --> 00:13:53,810
vienkārši pievienotu mainīgā, ko
sauc par atbildi, vērtību. 

297
00:13:53,810 --> 00:13:57,485
Protams, ja es ierakstīšu savu
vārdu, tas būs - ups!

298
00:13:57,485 --> 00:13:58,880
Es rakstīju pārāk ātri.

299
00:13:58,880 --> 00:14:00,470
Ļaujiet man turpināt un atkārtot to
vēlreiz.

300
00:14:00,470 --> 00:14:03,252
Ja es palaižu python ar hello.py,
ierakstu savu vārdu un nospiežu 

301
00:14:03,252 --> 00:14:06,035
taustiņu Enter, es saņemu hello,
komats, atbilde. 

302
00:14:06,035 --> 00:14:07,160
Nu, ļaujiet man izdarīt vienu
labāk.

303
00:14:07,160 --> 00:14:10,680
Ļaujiet man uzlikt šīs figūriekavas
tāpat kā iepriekš.

304
00:14:10,680 --> 00:14:13,340
Ļaujiet man atkārtoti palaist
python no hello.py.

305
00:14:13,340 --> 00:14:14,060
What's your name?

306
00:14:14,060 --> 00:14:14,405
DAVID.

307
00:14:14,405 --> 00:14:16,363
Un šeit atkal ir atbilde uz jūsu
jautājumu.

308
00:14:16,363 --> 00:14:18,780
Tagad mēs burtiski iegūstam
figūriekavas.

309
00:14:18,780 --> 00:14:21,710
Galu galā risinājums šeit ir tikai
pievienot f, atkārtoti palaist 

310
00:14:21,710 --> 00:14:24,640
manu programmu kopā ar David. 

311
00:14:24,640 --> 00:14:26,482
Un tagad: hello, komats, David.

312
00:14:26,482 --> 00:14:29,170
Tāpēc tas, protams, ir nedaudz
sarežģītāks nekā tie, kuriem ir pluss 

313
00:14:29,170 --> 00:14:31,858
vai komats, taču tas kļūst par
arvien biežāk izmantojamu. 

314
00:14:31,858 --> 00:14:33,650
Kāpēc?

315
00:14:31,858 --> 00:14:33,650
jo jūs varat to lasīt no kreisās uz
labo pusi.

316
00:14:33,650 --> 00:14:34,720
Tas ir jauki un ērti.

317
00:14:34,720 --> 00:14:36,125
Tas ir ne tik sarežģīts kā %s.

318
00:14:36,125 --> 00:14:39,010
Tātad, ja vēlaties, tā ir jauna un
uzlabota printf versija C valodā, 

319
00:14:39,010 --> 00:14:41,895
kas balstīta uz programmētāju gadu
desmitiem ilgo pieredzi, veicot 

320
00:14:41,895 --> 00:14:44,780
šādas darbības. 

321
00:14:44,780 --> 00:14:49,540
Vai jums ir jautājumi par drukāšanu
šādā veidā?

322
00:14:49,540 --> 00:14:52,780
Tagad mēs esam ceļā uz
programmēšanu Python valodā.

323
00:14:52,780 --> 00:14:53,280
Jebko?

324
00:14:53,280 --> 00:14:53,780
Labi.

325
00:14:53,780 --> 00:14:56,825
Nu, ko mēs vēl varam darīt ar šo
valodu?

326
00:14:56,825 --> 00:15:02,096
Ļaujiet man ieteikt mums uzskatīt,
ka mums, piemēram, ir arī dažas 

327
00:15:02,096 --> 00:15:07,368
citas funkcijas, kuras mēs varam
pievienot kombinācijai, proti, 

328
00:15:07,368 --> 00:15:12,640
teiksim - arī daži datu veidi. 

329
00:15:12,640 --> 00:15:15,600
Ļaujiet man pāršķirstīt šeit, lai
atgrieztos pie slaidiem.

330
00:15:15,600 --> 00:15:18,318
Un Python valodā ir dažādi datu
veidi, kā mēs drīz redzēsim.

331
00:15:18,318 --> 00:15:19,485
Bet tie nav tik precīzi formulēti.

332
00:15:19,485 --> 00:15:22,267
Kā mēs jau redzējām, izmantojot
virkni no get_string, jums nav 

333
00:15:22,267 --> 00:15:25,050
skaidri jānorāda, kas tas ir. 

334
00:15:25,050 --> 00:15:27,090
Bet jūs redzējāt — atcerieties, C
valodā — visus šos dažādos datu 

335
00:15:27,090 --> 00:15:29,130
tipus. 

336
00:15:29,130 --> 00:15:33,720
Un tad Python valodā šis saraksts
būs patīkami īsāks.

337
00:15:33,720 --> 00:15:37,740
Tātad, šeit ir mūsu saraksts C
valodā.

338
00:15:33,720 --> 00:15:37,740
Šeit ir saīsināts Python saraksts.

339
00:15:37,740 --> 00:15:41,386
Tātad mums joprojām būs virknes,
bet tās tagad tiks īsāk sauktas par 

340
00:15:41,386 --> 00:15:45,032
str - STR. 

341
00:15:41,220 --> 00:15:45,032
Mums joprojām būs int veseliem
skaitļiem.

342
00:15:45,032 --> 00:15:47,490
Mums joprojām būs float peldošā
komata vērtībām.

343
00:15:47,490 --> 00:15:49,900
Mums pat būs bool pateisam un
nepatiesam.

344
00:15:49,900 --> 00:15:53,550
Bet tas, kā tagad trūkst no
saraksta ir - long un float.

345
00:15:53,550 --> 00:15:54,420
Un kāpēc tā?

346
00:15:54,420 --> 00:15:56,220
Pareizāk sakot, long un double.

347
00:15:56,220 --> 00:15:58,650
Atgādināsim, ka C valodā tie
izmantoja vairāk bitu.

348
00:15:58,650 --> 00:16:01,800
Python valodā, savukārt, mazākie
datu tipi (tie paši — int un float) 

349
00:16:01,800 --> 00:16:04,950
izmantoja vairāk bitu jūsu vietā. 

350
00:16:04,950 --> 00:16:08,010
Un tāpēc jums nav jānošķir mazi no
lieliem.

351
00:16:08,010 --> 00:16:10,177
Jūs izmantojat tikai vienu datu
tipu, un valoda nodrošina lielāku 

352
00:16:10,177 --> 00:16:12,345
diapazonu nekā iepriekš. 

353
00:16:12,345 --> 00:16:14,900
Tomēr izrādās, ka būs arī dažas
citas Python iespējas un šie datu 

354
00:16:14,900 --> 00:16:17,455
tipi: viens no tiem tiks saukts par
diapazonu, bet otrs — par 

355
00:16:17,455 --> 00:16:20,010
sarakstu. 

356
00:16:20,010 --> 00:16:21,402
Tāpat pazudīs arī masīvi.

357
00:16:21,402 --> 00:16:23,610
Mēs faktiski izmantosim kaut ko, ko
burtiski sauc par sarakstu.

358
00:16:23,610 --> 00:16:28,110
Kortēži — sava veida x, y pāri
koordinātām un tamlīdzīgām lietām.

359
00:16:28,110 --> 00:16:31,190
Dikti vārdnīcām — tāpēc mums būs
iebūvētas iespējas atslēgu un 

360
00:16:31,190 --> 00:16:34,270
vērtību, kā arī komplektu
glabāšanai. 

361
00:16:34,270 --> 00:16:36,530
Matemātiski - kopa ir vērtību
kopums, taču tā automātiski atbrīvo jūs 

362
00:16:36,530 --> 00:16:38,790
no dublikātiem. 

363
00:16:38,790 --> 00:16:41,130
Tātad, ja mēs vēlētos, mēs pilnībā
varētu visas šīs lietas ieviest C 

364
00:16:41,130 --> 00:16:43,470
valodā. 

365
00:16:43,470 --> 00:16:46,935
Patiešām, piektajā problēmu kopā
jūs esat ieviesuši savu 

366
00:16:46,935 --> 00:16:50,400
pareizrakstības pārbaudītāju,
izmantojot kāda veida jaucējtabulu. 

367
00:16:50,400 --> 00:16:53,235
Izrādās, ka Python jūs varat
atrisināt tās pašas problēmas, tikai 

368
00:16:53,235 --> 00:16:56,070
nedaudz vieglāk. 

369
00:16:56,070 --> 00:16:58,982
Patiesībā ļaujiet man šeit
atgriezties pie VS Code un ieteikt 

370
00:16:58,982 --> 00:17:01,895
rīkoties šādi. 

371
00:17:01,895 --> 00:17:06,210
Ļaujiet man turpināt un izveidot
datni ar nosaukumu dictionary.py.

372
00:17:06,210 --> 00:17:09,466
Ļaujiet man ierosināt, ka es mēģinu
ieviest, teiksim - piektajā 

373
00:17:09,466 --> 00:17:12,722
problēmu kopā, - mūsu
pareizrakstības pārbaudītāju Python valodai, 

374
00:17:12,722 --> 00:17:15,978
nevis C, un galu galā panākt tādu
pašu uzvedību, ar kuru es varēšu 

375
00:17:15,978 --> 00:17:19,235
pārbaudīt veselas virknes vārdu
pareizrakstību. 

376
00:17:19,235 --> 00:17:21,566
Tātad tas ir mazliet pārsteidzīgi,
jo jūs redzēsiet, ka šodienas 

377
00:17:21,566 --> 00:17:23,897
laikā sintakse tiks pārskatīta. 

378
00:17:23,897 --> 00:17:26,580
Bet pagaidām man ir jauna datne ar
nosaukumu dictionary.py.

379
00:17:26,580 --> 00:17:30,810
Un ļaujiet man sākt veidot dažus
vietturus funkcijām.

380
00:17:30,810 --> 00:17:33,206
Mēs tūlīt redzēsim, ka Python
valodā jūs varat definēt funkciju, ko 

381
00:17:33,206 --> 00:17:35,603
sauc par pārbaudi (check), un šī
pārbaudes funkcija var izmantot 

382
00:17:35,603 --> 00:17:38,000
vārdu kā ievadi. 

383
00:17:38,000 --> 00:17:40,292
Un es atgriezīšos pie tā pēc brīža.

384
00:17:40,292 --> 00:17:43,651
Python valodā es varu definēt otru
funkciju, piemēram, ielādi (load), 

385
00:17:43,651 --> 00:17:47,010
kas pati paņems visu vārdnīcu,
tāpat kā piektajā problēmu kopā. 

386
00:17:47,010 --> 00:17:51,010
Un es turpināšu, atgriežoties pie
īstenošanas.

387
00:17:51,010 --> 00:17:53,706
Tikmēr mēs līdzīgā veidā varētu
ieviest funkciju, ko sauc par izmēru 

388
00:17:53,706 --> 00:17:56,403
(size), kas neprasa argumentus, bet
galu galā atgriezīs manas vārdu 

389
00:17:56,403 --> 00:17:59,100
vārdnīcas lielumu. 

390
00:17:59,100 --> 00:18:02,530
Un tad, visbeidzot, lai nodrošinātu
atbilstību piektajai problēmu 

391
00:18:02,530 --> 00:18:05,960
kopai, mēs varētu definēt
izkraušanas (unload) funkciju, kuras mērķis 

392
00:18:05,960 --> 00:18:09,390
ir atbrīvot jebkuru izmantoto
atmiņu un vienkārši atdot to datoram. 

393
00:18:09,390 --> 00:18:11,480
Tagad pastāv iespēja, ka neatkarīgi
no tā, vai jūs joprojām strādājat 

394
00:18:11,480 --> 00:18:13,570
ar pareizrakstības pārbaudītāju vai
esat pabeidzis to, jūs esat 

395
00:18:13,570 --> 00:18:15,660
uzrakstījuši pietiekami daudz koda
rindiņu. 

396
00:18:15,660 --> 00:18:18,550
Un, patiešām, pēc dizaina tas ir
bijis izaicinājums.

397
00:18:18,550 --> 00:18:21,934
Bet viens no iemesliem šīm augstākā
līmeņa valodām, tādām kā Python, 

398
00:18:21,934 --> 00:18:25,318
ir tas, ka jūs varat atskatīties uz
priekšteču veikumiems un daudz 

399
00:18:25,318 --> 00:18:28,703
ātrāk atrisināt ļoti izplatītas
problēmas. 

400
00:18:28,703 --> 00:18:30,698
Tā jūs varat koncentrēties uz savas
jaunās lietotnes vai tīmekļa 

401
00:18:30,698 --> 00:18:32,694
lietojumprogrammas vai sava
projekta izveidi, lai atrisinātu jūs 

402
00:18:32,694 --> 00:18:34,690
interesējošās problēmas. 

403
00:18:34,690 --> 00:18:37,816
Tāpēc, riskējot ar iespējamo
vilšanos dažiem, ļaujiet man ierosināt, 

404
00:18:37,816 --> 00:18:40,943
ka Python, ja vēlaties vārdnīcu
kaut kam kā pareizrakstības 

405
00:18:40,943 --> 00:18:44,070
pārbaudītājam, tad tas ir labi. 

406
00:18:44,070 --> 00:18:47,120
Dodieties uz priekšu un piešķiriet
sev mainīgo - piemēram - vārdus, 

407
00:18:47,120 --> 00:18:50,170
lai saglabātu visus šos vārdus, un
vienkārši piešķiriet to vārdnīcai 

408
00:18:50,170 --> 00:18:53,220
vai, saīsinājumā Python valodā, -
diktam. 

409
00:18:53,220 --> 00:18:55,140
Tas dos jums jaucētabulu.

410
00:18:55,140 --> 00:18:57,430
Tagad izrādās, ka, atsaucot
pareizrakstības pārbaudītāju, jums nav 

411
00:18:57,430 --> 00:18:59,720
jāuztraucas par vārdiem un
definīcijām. 

412
00:18:59,720 --> 00:19:01,763
Tas ir tikai par vārdu
pareizrakstības pārbaudi.

413
00:19:01,763 --> 00:19:03,930
Tātad, runājot nopietni, mums nav
vajadzīgas atslēgas un vērtības.

414
00:19:03,930 --> 00:19:05,610
Mums vajag tikai atslēgas.

415
00:19:05,610 --> 00:19:08,332
Tāpēc es ietaupīšu vēl dažus
taustiņsitienus, vienkārši sakot, ka 

416
00:19:08,332 --> 00:19:11,055
Python valodā tehniski pietiek ar
komplekta izmantošanu. 

417
00:19:11,055 --> 00:19:13,770
Atkal: komplekts ir tikai vērtību
kolekcija bez dublikātiem.

418
00:19:13,770 --> 00:19:16,400
Bet tiem ne vienmēr ir atslēgas un
vērtības.

419
00:19:16,400 --> 00:19:18,250
Tas ir tikai viens vai otrs.

420
00:19:18,250 --> 00:19:20,740
Bet tagad, kas man ir - pirmajā
rindā, es Python valodā pieprasu 

421
00:19:20,740 --> 00:19:23,230
jaucējtabulas ekvivalentu, es
faktiski varu izdarīt kaut ko līdzīgu 

422
00:19:23,230 --> 00:19:25,720
šim. 

423
00:19:25,720 --> 00:19:28,890
Lūk, kā es varētu ieviest pārbaudes
funkciju Python.

424
00:19:28,890 --> 00:19:32,140
Ja vārds, kas nodots šai funkcijai,
ir manā mainīgajā, ko sauc par 

425
00:19:32,140 --> 00:19:35,390
vārdiem, atgrieziet True. 

426
00:19:35,390 --> 00:19:39,360
Citādi turpiniet un atgrieziet
False.

427
00:19:39,360 --> 00:19:40,030
Gatavs.

428
00:19:40,030 --> 00:19:40,530
Nē, pagaidiet.

429
00:19:40,530 --> 00:19:43,518
Jūs domājat, ja vispār tā ir,
varbūt mēs vēlamies izmantot mazos 

430
00:19:43,518 --> 00:19:46,507
burtus, nevis tikai lielos un mazos
burtus. 

431
00:19:46,507 --> 00:19:47,340
Nu, ziniet ko?

432
00:19:47,340 --> 00:19:49,350
Python valodā, ja vēlaties ievadīt
visu vārdu ar mazajiem burtiem, 

433
00:19:49,350 --> 00:19:51,360
jums tas nav jāatkārto ar cilpu. 

434
00:19:51,360 --> 00:19:52,775
Jums nav jāizmanto neviena no šīm C
veida funkcijām vai kaut ko 

435
00:19:52,775 --> 00:19:54,190
līdzīgu. 

436
00:19:54,190 --> 00:19:56,485
Vienkārši sakiet word.lower, un tas
visu pārveidos par mazajiem 

437
00:19:56,485 --> 00:19:58,780
burtiem, lai nodrošinātu paritāti
ar vārdnīcu. 

438
00:19:58,780 --> 00:19:59,440
Labi.

439
00:19:59,440 --> 00:20:02,185
Kā ir ar kaut ko līdzīgu Python
ielādes funkcijai?

440
00:20:02,185 --> 00:20:06,130
Nu, Python valodā varat atvērt
datnes tāpat kā C valodā.

441
00:20:02,185 --> 00:20:06,991
Piemēram, Python valodā Imight
atver vārdnīcas argumentu lasīšanas 

442
00:20:06,991 --> 00:20:11,798
režīmā, tāpat kā fopen Python
valodā. 

443
00:20:11,798 --> 00:20:13,090
Es varētu darīt kaut ko līdzīgu
šim.

444
00:20:13,090 --> 00:20:17,260
Katrai šīs datnes rindiņai, ļaujiet
man iet uz priekšu un manam vārdu 

445
00:20:17,260 --> 00:20:21,430
mainīgajam pievienot šo rindiņu. 

446
00:20:21,430 --> 00:20:24,790
Un tad ļaujiet man iet uz priekšu
un aizvērt šo datni.

447
00:20:24,790 --> 00:20:26,320
Un es domāju, ka esmu pabeidzis.

448
00:20:26,320 --> 00:20:28,180
Es tikai iešu uz priekšu un
atgriezīšu True tikai tāpēc, ka domāju, 

449
00:20:28,180 --> 00:20:30,040
ka esmu jau pabeidzis. 

450
00:20:30,040 --> 00:20:32,350
Tagad arī šeit es varētu mazliet
pasmelties.

451
00:20:32,350 --> 00:20:35,485
Tehniski, ja es lasu katrā datnes
rindiņā, katra vārdnīcas rindiņa 

452
00:20:35,485 --> 00:20:38,620
beidzas ar slīpsvītru n. 

453
00:20:38,620 --> 00:20:40,990
Bet ir vienkāršs veids, kā no tā
atbrīvoties, tāpat kā jūs varētu 

454
00:20:40,990 --> 00:20:43,360
redzēt ar alternatīvu sintaksi. 

455
00:20:43,360 --> 00:20:45,060
Tas, ko es patiesībā darīšu, ir
sekojošs.

456
00:20:45,060 --> 00:20:48,295
Ļaujiet man paņemt no pašreizējās
rindas, pašreizējo vārdu, noņemot 

457
00:20:48,295 --> 00:20:51,530
ar apgriezto joslu — rstrip;
funkcija, ko mēs atkal redzēsim — tā 

458
00:20:51,530 --> 00:20:54,765
vienkārši atbrīvo no jaunās rindas
sekošanas — reversās slīpsvītras n 

459
00:20:54,765 --> 00:20:58,000
šīs rindas beigās. 

460
00:20:58,000 --> 00:20:59,950
Un tas, ko es patiešām vēlos darīt,
ir - pievienot šo vārdu šai 

461
00:20:59,950 --> 00:21:01,900
vārdnīcai. 

462
00:21:01,900 --> 00:21:05,280
Tikmēr, ja es vēlos noskaidrot,
kāds ir manas vārdnīcas lielums, tad 

463
00:21:05,280 --> 00:21:08,660
- jūs, iespējams, rakstīsiet kodu,
lai atkārtotu visas šīs rindas, un 

464
00:21:08,660 --> 00:21:12,040
jūs vienkārši saskaitīsiet tās,
izmantojot mainīgo. 

465
00:21:12,040 --> 00:21:13,060
Python valodā tā nav.

466
00:21:13,060 --> 00:21:15,460
Varat vienkārši atgriezt šo vārdu
garumu.

467
00:21:15,460 --> 00:21:19,360
Un vēl labāk, izmantojot Python,
jums nav jāpārvalda sava atmiņa.

468
00:21:19,360 --> 00:21:20,500
Vairs nav malloc funkcijas.

469
00:21:20,500 --> 00:21:21,700
Vairs nav free funkcijas.

470
00:21:21,700 --> 00:21:24,370
Vairs nav jādomā par atmiņu
manuāli.

471
00:21:24,370 --> 00:21:27,310
Valoda nodarbojas ar to visu jūsu
vietā.

472
00:21:27,310 --> 00:21:28,030
Tātad, zināt, ko?

473
00:21:28,030 --> 00:21:33,640
Pietiek, ja atgriežu True un
apgalvošu, ka izkraušana ir pabeigta.

474
00:21:33,640 --> 00:21:35,170
Un viss.

475
00:21:35,170 --> 00:21:38,680
Atkal, neatkarīgi no tā, vai esat
procesā vai jau esat pabeidzis, 

476
00:21:38,680 --> 00:21:42,190
tas, iespējams, var koriģēt zināmu
neapmierinātību, kā arī apgaismot, 

477
00:21:42,190 --> 00:21:45,700
jo tieši tāpēc pastāv augstāka
līmeņa valodas. 

478
00:21:45,700 --> 00:21:48,760
Jūs varat balstīties uz tiem pašiem
principiem, tām pašām idejām, ar 

479
00:21:48,760 --> 00:21:51,820
kurām jūs saskaraties, cīnoties arī
pagājušajā nedēļā. 

480
00:21:51,820 --> 00:21:55,090
Bet tagad jūs varat izteikties vēl
lakoniskāk.

481
00:21:55,090 --> 00:21:59,170
Šajā vienā rindā ir ieviesta
jaucējtabula, un tagad šī jaucējtabula 

482
00:21:59,170 --> 00:22:03,250
tiek izmantota vienkāršākā veidā. 

483
00:22:03,250 --> 00:22:07,120
Jebkuri jautājumi, tagad par šo,
paturot prātā, ka 5. kopas 

484
00:22:07,120 --> 00:22:10,990
pareizrakstības pārbaudītājamērķis
tomēr ir saprast, kas patiesībā 

485
00:22:10,990 --> 00:22:14,860
notiek zem pārsega, un, vēl labāk,
to pamanīt. 

486
00:22:14,860 --> 00:22:16,435
Tas viss varētu šķist diezgan
pārsteidzošs, bet ļaujiet man iet uz 

487
00:22:16,435 --> 00:22:18,010
priekšu un izdarīt šo. 

488
00:22:18,010 --> 00:22:20,273
Īstenībā man šeit ir uzrakstītas
pāris pareizrakstības pārbaudītāja 

489
00:22:20,273 --> 00:22:22,536
versijas, un man ir versija, kas
rakstīta C valodā, kuras avota kodu 

490
00:22:22,536 --> 00:22:24,800
es nerādīšu. 

491
00:22:24,800 --> 00:22:26,895
Bet es iešu uz priekšu un izveidošu
šo pareizrakstības versiju C 

492
00:22:26,895 --> 00:22:28,990
valodā. 

493
00:22:28,990 --> 00:22:34,270
Un es turpināšu un, teiksim,
sadalīšu šeit savu logu tikai uz brīdi.

494
00:22:34,270 --> 00:22:36,370
Un es iedziļināšos Python
pareizrakstības pārbaudītāja versijā, ko es 

495
00:22:36,370 --> 00:22:38,470
tikko uzrakstīju. 

496
00:22:38,470 --> 00:22:42,323
Kreisajā pusē ļaujiet man turpināt
un palaist pareizrakstības 

497
00:22:42,323 --> 00:22:46,176
programmu — versiju, kuru es
apkopoju C valodā, izmantojot lielu 

498
00:22:46,176 --> 00:22:50,030
tekstu, piemēram, Šerloka Holmsa
tekstu, kurā ir daudz vārdu. 

499
00:22:50,030 --> 00:22:52,496
Un labajā pusē ļaujiet man palaist
Python no speller.py, kas ir 

500
00:22:52,496 --> 00:22:54,963
atsevišķa datne, kuru es uzrakstīju
iepriekš, tāpat kā mēs jums dodam 

501
00:22:54,963 --> 00:22:57,430
speller.c. 

502
00:22:57,430 --> 00:23:00,790
Un līdzīgi es to palaidīšu Šerloka
Holmsa tekstā.

503
00:23:00,790 --> 00:23:03,445
Un es darīšu visu iespējamo, lai
vienlaikus nospiestu taustiņu Enter 

504
00:23:03,445 --> 00:23:06,100
ekrāna kreisajā un labajā pusē. 

505
00:23:06,100 --> 00:23:08,245
Un, cerams, mēs ieraudzīsim to pašu
nepareizi uzrakstīto vārdu 

506
00:23:08,245 --> 00:23:10,390
sarakstu un to laiku. 

507
00:23:10,390 --> 00:23:12,380
Tātad, mēs ejam pa labi.

508
00:23:12,380 --> 00:23:15,136
Šeit mēs ejam pa kreisi.

509
00:23:15,136 --> 00:23:16,730
Labi.

510
00:23:16,730 --> 00:23:18,680
Sacensības, lai noskaidrotu, kurš
šeit uzvarēs.

511
00:23:18,680 --> 00:23:19,820
C atrodas kreisajā pusē.

512
00:23:19,820 --> 00:23:21,680
Python atrodas labajā pusē.

513
00:23:21,680 --> 00:23:23,270
Labi.

514
00:23:23,270 --> 00:23:25,530
Interesanti.

515
00:23:25,530 --> 00:23:28,200
Cerams, ka Python ir tuvu aiz
muguras.

516
00:23:28,200 --> 00:23:30,330
Ņemiet vērā, ka daži no tiem ir
interneta aizkave.

517
00:23:30,330 --> 00:23:33,360
Tātad, tas neobligāti irneprātīgs
sekunžu skaits.

518
00:23:33,360 --> 00:23:37,050
Bet sistēma patiešām izmanto, ja
mēs to izmērām, zemu līmeni.

519
00:23:37,050 --> 00:23:39,630
Cik daudz laika CPU pavadīja,
izpildot manu kodu?

520
00:23:39,630 --> 00:23:41,653
C kopā aizņēma 1,64 sekundes.

521
00:23:41,653 --> 00:23:44,121
Tas bija diezgan ātri, lai gan
pagāja vēl brīdis, līdz visi baiti 

522
00:23:44,121 --> 00:23:46,590
nonāca internetā. 

523
00:23:46,590 --> 00:23:49,050
Python versija tomēr aizņēma cik?

524
00:23:49,050 --> 00:23:50,605
2,44 sekundes.

525
00:23:50,605 --> 00:23:53,100
Tātad, kāds varētu būt secinājums?

526
00:23:53,100 --> 00:23:56,250
Viens, iespējams, es vienkārši
labāk programmēju C valodā nekā 

527
00:23:56,250 --> 00:23:59,400
Python, kas, iespējams, nav
taisnība. 

528
00:23:59,400 --> 00:24:03,210
Bet ko vēl jūs varētu secināt no šī
piemēra?

529
00:24:07,541 --> 00:24:11,176
Varbūt mums vajadzētu atteikties no
Python un palikt pie C?

530
00:24:11,176 --> 00:24:12,070
Nē?

531
00:24:12,070 --> 00:24:14,410
Tātad, kas šeit varētu notikt?

532
00:24:14,410 --> 00:24:17,515
Kāpēc Python versija ir pareiza, un
es domāju, ka visi skaitļi 

533
00:24:17,515 --> 00:24:20,620
sakrīt, tikai ne laiki. 

534
00:24:20,620 --> 00:24:21,820
Kur šeit ir kompromiss?

535
00:24:21,820 --> 00:24:23,915
Nu, šeit atkal ir šis dizaina
kompromiss.

536
00:24:23,915 --> 00:24:24,415
Jā?

537
00:24:24,415 --> 00:24:29,310
programmētāja laiks,
[nesadzirdami]..

538
00:24:29,310 --> 00:24:30,690
DEIVIDS MALANS: Jā, tieši tā.

539
00:24:30,690 --> 00:24:33,970
Lai ietaupītu programmētāja laiku,
Python valodā ir iebūvēts daudz 

540
00:24:33,970 --> 00:24:37,250
vairāk funkciju — vairāk funkciju,
automātiskāka atmiņas pārvaldība 

541
00:24:37,250 --> 00:24:40,530
un tā tālāk, un jums par to ir
jāmaksā. 

542
00:24:40,530 --> 00:24:43,193
Kāda cita kods veic visu šo darbu
jūsu vietā.

543
00:24:43,193 --> 00:24:47,000
Bet, ja viņi ir uzrakstījuši
noteiktukoda rindiņu skaitu, tas ir vēl 

544
00:24:47,000 --> 00:24:50,807
vairāk koda rindiņu, ko ir
jāizpilda, turpretim te, palaižot tikai 

545
00:24:50,807 --> 00:24:54,615
manas koda rindiņas, dators riskē
ar pārlieku vienkāršošanu.. 

546
00:24:54,615 --> 00:24:55,865
Tātad šeit vienkārši ir mazāk
izmaksu.

547
00:24:55,865 --> 00:24:57,448
Un tā, tas ir mūžīgs kompromiss.

548
00:24:57,448 --> 00:25:00,215
Parasti, izmantojot lietotājam
draudzīgāku un modernāku valodu, viena 

549
00:25:00,215 --> 00:25:02,983
no cenām, ko jūs varētu maksāt, ir
veiktspēja. 

550
00:25:02,983 --> 00:25:05,711
Tomēr tagad pasaulē ir daudz gudru
datorzinātnieku, kuri cenšas 

551
00:25:05,711 --> 00:25:08,440
atstumt tos pašus kompromisus. 

552
00:25:08,440 --> 00:25:12,496
Un tāpēc šie tulki, tāpat kā manis
rakstītā komanda, Python tehniski 

553
00:25:12,496 --> 00:25:16,553
var — it īpaši, ja programmu
palaižat atkal un atkal — faktiski, 

554
00:25:16,553 --> 00:25:20,610
slepeni, aizkulisēs, apkopot jūsu
kodu līdz 0 un 1. 

555
00:25:20,610 --> 00:25:22,810
Un tad otrajā, trešajā, ceturtajā
reizē, kad palaižat šo programmu, 

556
00:25:22,810 --> 00:25:25,010
tā varētu būt ātrāka. 

557
00:25:25,010 --> 00:25:27,250
Tātad šeit ir neliels triks, it kā
es tās palaidu vienu un tikai 

558
00:25:27,250 --> 00:25:29,490
vienu reizi. 

559
00:25:29,490 --> 00:25:32,670
Taču laika gaitā mēs varētu gūt
labumu, ja mēs atkal un atkal 

560
00:25:32,670 --> 00:25:35,850
turpinātu palaist Python versiju
un, iespējams, precizētu veiktspēju. 

561
00:25:35,850 --> 00:25:38,017
Bet kopumā šis kompromiss būtu
sekojošs.

562
00:25:38,017 --> 00:25:41,314
Vai jūs drīzāk pavadītu šīs
60 sekundes, ko es uzrakstīju, ieviešot 

563
00:25:41,314 --> 00:25:44,612
pareizrakstības pārbaudītāju, vai
šīs 6 stundas, 16 stundas, kuras 

564
00:25:44,612 --> 00:25:47,910
jūs varētu būt vai esat pavadījis,
lai ieviestu to pašu C valodā? 

565
00:25:47,910 --> 00:25:48,720
Laikam nē.

566
00:25:48,720 --> 00:25:52,650
Produktivitātes nolūkos mums ir šīs
papildu valodas.

567
00:25:52,650 --> 00:25:57,263
Izklaidei ļaujiet man šeit pāriet
uz citu ekrānu un atvērt Python 

568
00:25:57,263 --> 00:26:01,876
versiju, kas faktiski — tikai
sekundes laikā — ir manā Mac datorā, 

569
00:26:01,876 --> 00:26:06,490
nevis mākonī, lai es varētu kaut ko
darīt ar grafiku. 

570
00:26:06,490 --> 00:26:09,930
Tātad, te manā Mac datorā ir tikai
melnbalts termināļa logs.

571
00:26:09,930 --> 00:26:12,150
Un es esmu iepriekš instalējis
Python, tāpat kā mēs jums to izdarījām 

572
00:26:12,150 --> 00:26:14,370
mākonī ar VS Code. 

573
00:26:14,370 --> 00:26:17,730
Ievērojiet, ka man ir šis
fotoattēls, iespējams, ar vienu no jūsu 

574
00:26:17,730 --> 00:26:21,090
iecienītākajiem TV šoviem kopā ar
seriāla Ofiss aktieriem. 

575
00:26:21,090 --> 00:26:24,630
Ievērojiet visas šajā attēlā
redzamās sejas.

576
00:26:24,630 --> 00:26:27,640
Un ļaujiet man ierosināt pūlī
mēģināt atrast vienu seju, CSI stilā, 

577
00:26:27,640 --> 00:26:30,650
ar kuru mēs vēlamies atrast,
iespējams, tā sakot, Skrantonas 

578
00:26:30,650 --> 00:26:33,660
Žņaudzēju. 

579
00:26:33,660 --> 00:26:37,080
Un tā, lūk, šī vīrieša sejas
piemērs.

580
00:26:37,080 --> 00:26:40,385
Tagad, kā mēs varam atrast šo
konkrēto seju pūlī?

581
00:26:40,385 --> 00:26:42,377
Mūsu cilvēka acis, protams, var
viņu izraut, it īpaši, ja esat 

582
00:26:42,377 --> 00:26:44,370
pazīstami ar seriālu. 

583
00:26:44,370 --> 00:26:46,605
Bet ļaujiet man turpināt un
alternatīvi izdarīt šo .

584
00:26:46,605 --> 00:26:49,702
Ļaujiet man iet uz priekšu un
ierosināt palaist kodu, kuru jau 

585
00:26:49,702 --> 00:26:52,800
iepriekš šeit uzrakstīju. 

586
00:26:52,800 --> 00:26:54,630
Šī ir Python programma ar vairākām
koda rindiņām, pie kurām šodien 

587
00:26:54,630 --> 00:26:56,460
nekavēsimies. 

588
00:26:56,460 --> 00:26:58,800
Bet tas ir paredzēts, lai motivētu
to, ko mēs varam darīt.

589
00:26:58,800 --> 00:27:02,137
No spilvenu bibliotēkas, kas nozīmē
Python attēlu bibliotēku, es 

590
00:27:02,137 --> 00:27:05,475
vēlos importēt noteikta veida
informāciju, kādu funkciju, ko sauc par 

591
00:27:05,475 --> 00:27:08,812
attēlu, lai varētu manipulēt ar
attēliem, atšķirībā no mūsu ceturtās 

592
00:27:08,812 --> 00:27:12,150
problēmu kopas. 

593
00:27:12,150 --> 00:27:13,330
Un tas ir spēcīgs.

594
00:27:13,330 --> 00:27:13,830
iekšā?

595
00:27:13,830 --> 00:27:14,330
Python.

596
00:27:14,330 --> 00:27:18,450
Jūs varat vienkārši [MIMICS
EXPLOSION]

597
00:27:18,450 --> 00:27:19,950
importēt sejas atpazīšanu kā
bibliotēku, ko kāds cits ir uzrakstījis.

598
00:27:19,950 --> 00:27:22,770
Pēc tam es izveidošu mainīgo, ko
sauc par attēlu.

599
00:27:22,770 --> 00:27:25,050
Es izmantošu šīs sejas atpazīšanas
bibliotēkas.

600
00:27:25,050 --> 00:27:27,330
load_image_file funkcija.

601
00:27:27,330 --> 00:27:30,030
Tas ir nedaudz daudzvārdisks, bet
pēc būtības ir līdzīgs fopen.

602
00:27:30,030 --> 00:27:32,100
Un es atvēršu office.jpeg.

603
00:27:32,100 --> 00:27:35,237
Pēc tam es paziņošu otru mainīgo,
ko sauc par face_locations, 

604
00:27:35,237 --> 00:27:38,375
daudzskaitlī, jo saskaņā ar šīs
bibliotēkas dokumentāciju es ceru 

605
00:27:38,375 --> 00:27:41,512
saņemt atpakaļ visu seju, kuras
tiek noteiktas, atrašanās vietu 

606
00:27:41,512 --> 00:27:44,650
sarakstu. 

607
00:27:44,650 --> 00:27:45,150
Labi.

608
00:27:45,150 --> 00:27:47,805
Pēc tam es atkārtošu katru no šīm
sejām, izmantojot for cilpu, ko mēs 

609
00:27:47,805 --> 00:27:50,460
redzēsim sīkāk. 

610
00:27:50,460 --> 00:27:52,755
Pēc tam es secināšu, kas ir šīs
sejas augšējais, labais, apakšējais 

611
00:27:52,755 --> 00:27:55,050
un kreisais stūris. 

612
00:27:55,050 --> 00:28:03,040
Un tad es šeit rādīšu tikai šo
seju, ja esmu noteicis vajadzīgo seju.

613
00:28:03,040 --> 00:28:08,760
Ļaujiet man turpināt un palaist
detect.py.

614
00:28:08,760 --> 00:28:12,370
Un mēs redzēsim ne tikai vienu
seju, kuru meklējam.

615
00:28:12,370 --> 00:28:16,430
Bet, ja es palaistu Python no
detect.py, tas veiks visu analīzi.

616
00:28:16,430 --> 00:28:20,650
Šeit tagad es redzēšu lielu
atvērumu visām sejām, kas tika 

617
00:28:20,650 --> 00:28:24,870
konstatētas šajā programmā. 

618
00:28:24,870 --> 00:28:26,870
[Smejas] Labi, dažas labāk

619
00:28:26,870 --> 00:28:28,560
nekā citas, es domāju, ja jūs
pietuvinātu kādu ķerot.

620
00:28:28,560 --> 00:28:29,970
Tipiska Andžela.

621
00:28:29,970 --> 00:28:32,445
Ja vēlaties tagad atrast šo vienu
seju, es domāju, ka mums ir nedaudz 

622
00:28:32,445 --> 00:28:34,920
vairāk jāapmāca programmatūra. 

623
00:28:34,920 --> 00:28:37,095
Tāpēc ļaujiet man atvērt otru
programmu, ko sauc par atpazīšanu, tajā 

624
00:28:37,095 --> 00:28:39,270
notiek daudz kas vairāk. 

625
00:28:39,270 --> 00:28:42,793
Bet ļaujiet man ar rokas mājienu
norādīt, ka es tagad ielādēju ne 

626
00:28:42,793 --> 00:28:46,316
tikai office.jpeg, bet arī
toby.jpeg, lai apmācītu algoritmu, lai 

627
00:28:46,316 --> 00:28:49,840
atrastu šo konkrēto seju. 

628
00:28:49,840 --> 00:28:53,916
Un tāpēc tagad, ja es palaistu šo
otro versiju — recognize.py — ar 

629
00:28:53,916 --> 00:28:57,993
Python no recognize.py — uz brīdi
aizturu elpu; tas, domājams, 

630
00:28:57,993 --> 00:29:02,070
analizē visas sejas — jūs redzat to
pašu oriģinālo fotoattēlu. 

631
00:29:02,070 --> 00:29:05,610
Bet vai jūs redzat šeit izceltu
vienu šādu seju?

632
00:29:05,610 --> 00:29:08,860
Šī koda versija atrada Tobiju,
iezīmēja viņu ar ekrānu un, voilà, 

633
00:29:08,860 --> 00:29:12,110
mums ir sejas atpazīšana. 

634
00:29:12,110 --> 00:29:14,038
Par labu vai sliktu, bet tas notiek
mūsdienās, arvien biežāk 

635
00:29:14,038 --> 00:29:15,967
sabiedrībā. 

636
00:29:15,967 --> 00:29:18,693
Un, godīgi sakot, lai gan es kodu
nerakstīju tiešraidē — jo tas ir 

637
00:29:18,693 --> 00:29:21,420
labs ducis vai vairāk koda
rindiņu — to nav tik daudz. 

638
00:29:21,420 --> 00:29:24,690
Un burtiski visas iestādes — viss,
kas mums jādara, ir importēt sejas 

639
00:29:24,690 --> 00:29:27,960
atpazīšanu, un, voilà, jums ir
piekļuve. 

640
00:29:27,960 --> 00:29:29,890
Šīs tehnoloģijas jau ir šeit.

641
00:29:29,890 --> 00:29:33,820
Bet aizdomāsimies uz brīdi, kā mēs
atradām Tobiju?

642
00:29:33,820 --> 00:29:38,890
Kā šī bibliotēka var — lai gan mēs
neapskatīsim tās ieviešanas 

643
00:29:38,890 --> 00:29:43,960
detaļas, kā tā atrod Tobiju un
atšķir viņu no visām citām sejām pūlī? 

644
00:29:43,960 --> 00:29:47,180
Ko tā varētu darīt, intuitīvi.

645
00:29:47,180 --> 00:29:50,570
Padomājiet pat par p-set four, kam
jums pašiem ir piekļuve datu ziņā.

646
00:29:50,570 --> 00:29:51,083
Jā?

647
00:29:51,083 --> 00:29:53,750
Mērķauditorija: [? Kopš ?] mēs tai
iedevām

648
00:29:53,750 --> 00:29:56,832
Tobija sejas attēlu, tā, iespējams,
skatās, vai pikseļi vienā 

649
00:29:56,832 --> 00:29:59,915
apgabalā ir tādi paši kā citā
apgabalā un piešķir to vienam un tam 

650
00:29:59,915 --> 00:30:02,998
pašam — no tā atsauces attēla uz šo
attēlu. 

651
00:30:02,998 --> 00:30:10,750
ka tā ir tā pati [? persona. ?]

652
00:30:10,750 --> 00:30:11,875
DEIVIDS MALANS: Jā, tieši tā.

653
00:30:11,875 --> 00:30:14,717
Rezumējot par kameru, mēs esam
apmācījuši programmatūru, ja vēlaties, 

654
00:30:14,717 --> 00:30:17,560
piedāvājot tai Tobija sejas
fotoattēlu. 

655
00:30:17,560 --> 00:30:20,030
Tātad, meklējot vienādus vai
patiešām līdzīgus pikseļus — īpaši, ja 

656
00:30:20,030 --> 00:30:22,500
tas ir nedaudz atšķirīgs Tobija
attēls, mēs, iespējams, varam viņu 

657
00:30:22,500 --> 00:30:24,970
atpazīt pūlī. 

658
00:30:24,970 --> 00:30:26,412
Un kas īsti ir cilvēka seja?

659
00:30:26,412 --> 00:30:29,261
Galu galā dators to zina tikai kā
bitu modeli vai - augstākā līmenī - 

660
00:30:29,261 --> 00:30:32,110
pikseļu modeli. 

661
00:30:32,110 --> 00:30:35,726
Tātad varbūt cilvēka seja,
iespējams, kopumā vislabāk var būt 

662
00:30:35,726 --> 00:30:39,342
definēta kā divas acis, deguns un
mute, kas, lai gan mēs visi 

663
00:30:39,342 --> 00:30:42,958
izskatāmies līdzīgi, strukturāli,
protams, mērījumi starp acīm un 

664
00:30:42,958 --> 00:30:46,574
degunu un mutes platumu, ādas tonis
un visas šīs fiziskās īpašības ir 

665
00:30:46,574 --> 00:30:50,190
modeļi, kurus programmatūra,
iespējams, varētu noteikt un pēc tam 

666
00:30:50,190 --> 00:30:53,806
statistiski aplūkojot attēlu,
meklēt vistuvāko iespējamo atbilstību 

667
00:30:53,806 --> 00:30:57,422
šīm vairākāmmērījumu formām,
krāsām, kā arī izmēriem un tā tālāk. 

668
00:30:57,422 --> 00:30:59,130
Un patiešām tā varētu būt
intuīcija.

669
00:30:59,130 --> 00:31:02,705
Bet varenākais šeit atkal ir tas,
cik šī tehnoloģija tagad ir 

670
00:31:02,705 --> 00:31:06,280
vienkārša un viegli pieejama. 

671
00:31:06,280 --> 00:31:06,820
Labi.

672
00:31:06,820 --> 00:31:10,210
Ņemot to vērā, ierosināsim apsvērt,
ko vēl varam darīt ar pašu 

673
00:31:10,210 --> 00:31:13,600
Python, atgriezīsimies pie
pamatiem, lai jūs paši varētu sākt kaut ko 

674
00:31:13,600 --> 00:31:16,990
ieviest paralēli tām rindiņām. 

675
00:31:16,990 --> 00:31:20,340
Tātad bez piekļuves tādām lietām kā
get_string funkcija, CS50 

676
00:31:20,340 --> 00:31:23,690
bibliotēka nodrošina arī dažas
citas lietas, proti, C valodā mums tās 

677
00:31:23,690 --> 00:31:27,040
bija. 

678
00:31:27,040 --> 00:31:29,052
Bet Python valodā būs mazāk.

679
00:31:29,052 --> 00:31:31,396
Python valodā mūsu īstermiņa
bibliotēka sniegs jums ne tikai 

680
00:31:31,396 --> 00:31:33,740
get_string, bet arī get_int un
get_float. 

681
00:31:33,740 --> 00:31:34,240
Kāpēc?

682
00:31:34,240 --> 00:31:37,472
Faktiski ir tikai kaitinoši, kā mēs
drīz redzēsim, atgūt no lietotāja 

683
00:31:37,472 --> 00:31:40,705
veselu skaitli vai peldošu vērtību
un tikai pārliecināties, ka tas ir 

684
00:31:40,705 --> 00:31:43,937
int un peldoša vērtība, nevis tāds
vārds kā kaķis vai suns, vai 

685
00:31:43,937 --> 00:31:47,170
virkne, kas patiesībā nav numurs. 

686
00:31:47,170 --> 00:31:50,060
Mēs varam importēt ne tikai
konkrēto funkciju get_string, bet 

687
00:31:50,060 --> 00:31:52,950
faktiski varam importēt visas šīs
funkcijas pa vienai, piemēram, kā 

688
00:31:52,950 --> 00:31:55,840
mēs to drīz redzēsim. 

689
00:31:55,840 --> 00:31:59,410
Vai pat Python no datnes varat
importēt noteiktas funkcijas.

690
00:31:59,410 --> 00:32:02,560
Kāds no jums jautāja pirms kāda
laika, kad iekļaujat kaut ko līdzīgu 

691
00:32:02,560 --> 00:32:05,710
CS50.h vai standarta I/O .h, jūs
faktiski saņemat visu šajā datnē 

692
00:32:05,710 --> 00:32:08,860
esošo kodu, kas, iespējams, var
palielināt jūsu programmas apjomu vai 

693
00:32:08,860 --> 00:32:12,010
ieguldīto laiku. 

694
00:32:12,010 --> 00:32:16,620
Šādā gadījumā, importējot noteiktas
funkcijas no Python, varat 

695
00:32:16,620 --> 00:32:21,230
nedaudz precīzāk noteikt, kam
vēlaties piekļūt. 

696
00:32:21,230 --> 00:32:21,730
Labi.

697
00:32:21,730 --> 00:32:23,815
Tātad, to sakot, turpināsim un
redzēsim, kā Python valodā izskatās 

698
00:32:23,815 --> 00:32:25,900
nosacījumi. 

699
00:32:25,900 --> 00:32:29,470
Tad atkal kreisajā pusē, šeit, mēs
redzēsim Scratch.

700
00:32:29,470 --> 00:32:32,410
Tātad tas ir tikai izdomāts
piemērs, kurā tiek jautāts, vai x ir 

701
00:32:32,410 --> 00:32:35,350
mazāks par y, tad, teiksim, x ir
mazāks par y. 

702
00:32:35,350 --> 00:32:37,540
C valodā tas izskatījās šādi.

703
00:32:37,540 --> 00:32:41,050
Tagad Python valodā tas izskatīsies
šādi.

704
00:32:41,050 --> 00:32:44,815
Un šeit ir pirms C valodā, un šeit
ir pēc.

705
00:32:44,815 --> 00:32:47,312
Un tikai, lai pieminētu dažas
acīmredzamās atšķirības, kas šķietamiir 

706
00:32:47,312 --> 00:32:49,810
mainījies nosacījuma operatoriem
Python valodā? 

707
00:32:53,013 --> 00:32:53,930
Kādas atšķirības?

708
00:32:53,930 --> 00:32:54,230
Jā.

709
00:32:54,230 --> 00:32:55,920
Mērķauditorija: Trūkst figūriekavu.

710
00:32:55,920 --> 00:32:56,380
DEIVIDS MALANS: Jā.

711
00:32:56,380 --> 00:32:57,760
Tātad vairs nav figūriekavu.

712
00:32:57,760 --> 00:32:59,170
Un patiešām jūs tās neizmantojat.

713
00:32:59,170 --> 00:33:04,138
Kas parādās to vietā, ja jūs varētu
secināt?

714
00:33:04,138 --> 00:33:05,680
Kas, izskatās, ir ieņēmis to vietu?

715
00:33:05,680 --> 00:33:05,890
Kā jūs domājat?

716
00:33:05,890 --> 00:33:06,765
Mērķauditorija: [Nesadzirdami]

717
00:33:06,765 --> 00:33:09,560
DEIVIDS MALANS: Tātad kols šīs
rindas sākumā, šeit.

718
00:33:09,560 --> 00:33:13,760
Bet arī vēl svarīgāka tagad ir šī
atkāpe zem tās.

719
00:33:13,760 --> 00:33:16,570
Tātad dažiem no jums, un mēs to
zinām no darba laika, ir ieradums 

720
00:33:16,570 --> 00:33:19,380
visu ievilkt pa kreisi, vai ne? 

721
00:33:19,380 --> 00:33:21,200
Un tas ir tikai šis trakais haoss,
uz kuru jāskatās.

722
00:33:21,200 --> 00:33:23,000
Mulsinoši, protams.

723
00:33:23,000 --> 00:33:25,430
Bet C un Clang ir diezgan
iecietīgas valodas, ja runa ir par tādām 

724
00:33:25,430 --> 00:33:27,860
lietām kā atstarpes programmā. 

725
00:33:27,860 --> 00:33:29,030
Python valodā, ne-ne.

726
00:33:29,030 --> 00:33:31,820
Pirms dažiem gadiem viņi saprata:
palīdzēsim cilvēkiem palīdzēt 

727
00:33:31,820 --> 00:33:34,610
pašiem sev un prasīsim tikai
standarta atkāpi. 

728
00:33:34,610 --> 00:33:36,620
Tātad četras atstarpes šeit būtu
norma.

729
00:33:36,620 --> 00:33:39,365
Bet, tā kā tas ir ievilkts zem šī
kola, tas patiešām norāda, ka tas 

730
00:33:39,365 --> 00:33:42,110
tagad ir daļa no šī nosacījuma
operatora. 

731
00:33:42,110 --> 00:33:46,340
Šajā nosacījuma operatorā kaut kas
cits ir pazudis, salīdzinot ar C.

732
00:33:46,340 --> 00:33:47,855
Kas vēl ir nedaudz vienkāršots?

733
00:33:47,855 --> 00:33:49,660
Mērķauditorija: [Nesadzirdami

734
00:33:49,660 --> 00:33:50,410
DEIVIDS MALANS: Jā.

735
00:33:50,410 --> 00:33:51,368
Tātad vairs nav iekavu.

736
00:33:51,368 --> 00:33:53,740
Jūs joprojām varat tās izmantot, it
īpaši, ja jums ir nepieciešams 

737
00:33:53,740 --> 00:33:56,112
loģiski veiktu darbību secību,
piemēram, matemātikā. 

738
00:33:56,112 --> 00:33:58,637
Bet šajā gadījumā, ja vēlaties
uzdot vienkāršu jautājumu, piemēram, 

739
00:33:58,637 --> 00:34:01,162
ja x ir mazāks par y, varat to
izdarīt tieši tā. 

740
00:34:01,162 --> 00:34:02,620
Kā būtu, ja jums ir if else?

741
00:34:02,620 --> 00:34:05,170
Šeit ir gandrīz tas pats, ar tādām
pašām izmaiņām.

742
00:34:05,170 --> 00:34:06,800
C valodā tas izskatījās šādi.

743
00:34:06,800 --> 00:34:08,729
Un tas kļūst smagāks — vismaz, ja
mēs šādā veidā izmantojam 

744
00:34:08,729 --> 00:34:10,659
figūriekavas. 

745
00:34:10,659 --> 00:34:13,193
Python valodā mēs varam būt
efektīvāki, lai gan, godīgi sakot, C 

746
00:34:13,193 --> 00:34:15,727
valodā jums ne vienmēr ir
vajadzīgas figūriekavas. 

747
00:34:15,727 --> 00:34:18,280
Bet šeit atkal - iekavas ir
pazudušas.

748
00:34:18,280 --> 00:34:20,020
Figūriekavas ir pazudušas.

749
00:34:20,020 --> 00:34:22,300
Atkāpe ir konsekventa, un mēs tikko
esam pievienojuši citu 

750
00:34:22,300 --> 00:34:24,580
atslēgvārdu - else - ar kolu. 

751
00:34:24,580 --> 00:34:26,325
Bet vairs nav arī semikolu.

752
00:34:26,325 --> 00:34:28,167
Kā būtu ar kaut ko lielāku,
piemēram, šo - if, else priekšrakstā - if 

753
00:34:28,167 --> 00:34:30,010
else? 

754
00:34:30,010 --> 00:34:31,960
Šis ir interesants.

755
00:34:31,960 --> 00:34:35,290
Bet C valodā tas izskatījās šādi –
if, else, if else.

756
00:34:35,290 --> 00:34:38,143
Python valodā tas tagad izskatās
šādi.

757
00:34:38,143 --> 00:34:40,886
Un šeit, iespējams, ir viens
kuriozs, ka, godīgi sakot, pēc visiem 

758
00:34:40,886 --> 00:34:43,630
šiem gadiem, es joprojām ne vienmēr
atceros, kā to uzrakstīt. 

759
00:34:43,630 --> 00:34:46,900
Kas tur dīvains?

760
00:34:46,900 --> 00:34:50,415
Ko jūs redzat kā atšķirīgu?

761
00:34:50,415 --> 00:34:51,230
Jā, šeit.

762
00:34:51,230 --> 00:34:53,520
Mērķauditorija: [Nesadzirdami]

763
00:34:53,520 --> 00:34:54,270
DEIVIDS MALANS: Jā.

764
00:34:54,270 --> 00:34:56,260
Else if vietā ir elif.

765
00:34:56,260 --> 00:34:56,760
Kāpēc?

766
00:34:56,760 --> 00:34:59,340
[Nopūšas] Acīmredzot, else

767
00:34:59,340 --> 00:35:00,795
atstarpe if - tas bija pār daudz
taustiņsitienu cilvēkiem, tāpēc viņi 

768
00:35:00,795 --> 00:35:02,250
to saīsināja šādā veidā. 

769
00:35:02,250 --> 00:35:04,725
Iespējams, tas nozīmē, ka tas ir
nedaudz saprotamāks arī datoram - 

770
00:35:04,725 --> 00:35:07,200
sadalīt if un else. 

771
00:35:07,200 --> 00:35:08,700
Bet tagad kaut kas, kas būtu
jāatceras.

772
00:35:08,700 --> 00:35:10,620
Tas patiešām ir elif un ne else if.

773
00:35:10,620 --> 00:35:11,123
Labi.

774
00:35:11,123 --> 00:35:12,540
Tātad, kā ar mainīgajiem Python?

775
00:35:12,540 --> 00:35:16,036
Es jau esmu izmantojis pāris no
tiem, bet atlasīsim tieši to, kā jūs 

776
00:35:16,036 --> 00:35:19,533
definējat un deklarējat šīs lietas.


777
00:35:19,533 --> 00:35:22,164
Tātad, Scratch valodā, ja mēs
vēlamies izveidot mainīgo, ko sauc par 

778
00:35:22,164 --> 00:35:24,796
skaitītāju, un sākotnēji iestatītu
to vienādu ar 0, mēs darītu kaut 

779
00:35:24,796 --> 00:35:27,428
ko līdzīgu šim - norādītu, ka tas
ir int, izmantotu piešķiršanas 

780
00:35:27,428 --> 00:35:30,060
operatoru, beigtu domu ar semikolu.


781
00:35:30,060 --> 00:35:32,310
Python valodā tas ir vienkāršāk.

782
00:35:32,310 --> 00:35:35,032
Jūs nosaucat mainīgo, izmantojat
piešķiršanas operatoru, tāpat kā 

783
00:35:35,032 --> 00:35:37,755
iepriekš, jūs to iestatāt vienādu
ar kādu vērtību, un viss. 

784
00:35:37,755 --> 00:35:38,880
Jūs nepieminat veidu.

785
00:35:38,880 --> 00:35:41,250
Jūs neminat semikolu vai ko vairāk.

786
00:35:41,250 --> 00:35:43,785
Ko darīt, ja vēlaties mainīt
mainīgo, piemēram, skaitītāju, par 1 — 

787
00:35:43,785 --> 00:35:46,320
tas ir, palielināt par 1? 

788
00:35:46,320 --> 00:35:47,800
Šeit jums ir dažādi veidi.

789
00:35:47,800 --> 00:35:51,350
C valodā mēs redzējām tādu
sintaksi, kur var teikt, ka skaitītājs ir 

790
00:35:51,350 --> 00:35:54,900
vienāds ar skaitītāju plus 1, kas
atkal šķiet neloģiski. 

791
00:35:54,900 --> 00:35:56,610
Kā skaitītājs var būt vienāds ar
skaitītāju plus 1?

792
00:35:56,610 --> 00:35:59,250
Bet atkal mēs lasām šo kodu,
patiešām, no labās uz kreiso pusi, 

793
00:35:59,250 --> 00:36:01,890
atjauninot tā vērtību par 1. 

794
00:36:01,890 --> 00:36:03,550
Python valod tas ir gandrīz tā pat.

795
00:36:03,550 --> 00:36:04,535
Jūs vienkārši atbrīvojaties no
semikola.

796
00:36:04,535 --> 00:36:05,580
Te ir loģika.

797
00:36:05,580 --> 00:36:07,710
Taču atcerieties, ka C valodā mēs
varētu darīt kaut ko nedaudz 

798
00:36:07,710 --> 00:36:09,840
savādāku, ko varam darīt arī Python
valodā. 

799
00:36:09,840 --> 00:36:12,630
Python valodā varat arī lakoniskāk
izdarīt tā — plus ir vienāds ar, 

800
00:36:12,630 --> 00:36:15,420
un pēc tam jebkurš skaitlis, ko
vēlaties pievienot. 

801
00:36:15,420 --> 00:36:17,790
Vai arī varat to mainīt, lai
atņemtu, ja vēlaties.

802
00:36:17,790 --> 00:36:21,495
Diemžēl ir pagājis tas, ka,
iespējams, esat rakstījuši daudz.

803
00:36:21,495 --> 00:36:23,940
Kāds bija cits veids, kā pievienot
1?

804
00:36:23,940 --> 00:36:24,773
Mērķauditorija: Plus plus?

805
00:36:24,773 --> 00:36:26,940
DEIVIDS MALANS: Plus plus diemžēl
vairs nav Python valodā.

806
00:36:26,940 --> 00:36:29,322
Pārāk daudz veidu, kā darīt vienu
un to pašu, tāpēc viņi no tā 

807
00:36:29,322 --> 00:36:31,705
atbrīvojās, izvēloties tikai šo
sintakse. 

808
00:36:31,705 --> 00:36:33,140
Tāpēc arī to paturiet prātā.

809
00:36:33,140 --> 00:36:36,500
Kas par cilpām, ja vēlaties kaut ko
izdarīt Python atkārtoti.

810
00:36:36,500 --> 00:36:40,700
Nu, Scratch, nulles nedēļā, lūk kā
mēs ņaudējām trīs reizes, konkrēti.

811
00:36:40,700 --> 00:36:42,650
Valodā C mums bija daži veidi, kā
to izdarīt.

812
00:36:42,650 --> 00:36:46,460
Šī bija mehāniskāka pieeja, kur jūs
izveidojat mainīgo ar nosaukumu i.

813
00:36:46,460 --> 00:36:47,780
Jūs to iestatāt vienādu ar 0.

814
00:36:47,780 --> 00:36:51,230
Kamēr i ir mazāks par 3,
rīkojieties šādi.

815
00:36:51,230 --> 00:36:54,530
Un tad jūs paši palielināt i atkal
un atkal.

816
00:36:54,530 --> 00:36:57,830
Mehāniska tādā nozīmē, ka jums ir
jāievieš visi šie mehānismi un 

817
00:36:57,830 --> 00:37:01,130
jāgriež tie pašiem, taču tas bija
pareizs veids, kā to izdarīt. 

818
00:37:01,130 --> 00:37:03,537
Python valodā mēs joprojām varam
sasniegt to pašu ideju, taču mums 

819
00:37:03,537 --> 00:37:05,945
nav nepieciešams int atslēgvārds. 

820
00:37:05,945 --> 00:37:07,445
Mums nevajag nevienu semikolu.

821
00:37:07,445 --> 00:37:08,695
Iekavas mums nav vajadzīgas.

822
00:37:08,695 --> 00:37:10,310
Mums nav vajadzīgas figūriekavas.

823
00:37:10,310 --> 00:37:12,305
Mēs nevaram izmantot plus plus,
tāpēc, iespējams, tas ir neliels 

824
00:37:12,305 --> 00:37:14,300
solis atpakaļ, ja esat fans. 

825
00:37:14,300 --> 00:37:17,930
Bet citādi kods, loģika ir tieši
tādi paši.

826
00:37:17,930 --> 00:37:20,390
Taču ir arī citi veidi, kā īstenot
šo ideju.

827
00:37:20,390 --> 00:37:22,950
Atcerieties, ka C, mēs varējām
darīt arī šo.

828
00:37:22,950 --> 00:37:25,880
Varat izmantot for cilpu, kas dara
tieši to pašu.

829
00:37:25,880 --> 00:37:26,893
Abi ir pareizi.

830
00:37:26,893 --> 00:37:28,310
Abi, iespējams, ir labi izstrādāti.

831
00:37:28,310 --> 00:37:32,000
Katrs izvēlas pats savu veidu.

832
00:37:32,000 --> 00:37:35,930
Tomēr Python mums būs jādomā, kā to
izdarīt.

833
00:37:35,930 --> 00:37:41,300
Tātad jūs nedarāt to pašu for
cilpu, kā C valodā.

834
00:37:35,930 --> 00:37:40,794
Tuvākais, ko es varētu izdomāt, ir
šis, kur jūs sakāt i — vai jebkurš 

835
00:37:40,794 --> 00:37:45,658
mainīgais, kuru vēlaties
saskaitīt — in - burtiski prievārds, un pēc 

836
00:37:45,658 --> 00:37:50,522
tam izmantojat kvadrātiekavas. 

837
00:37:50,522 --> 00:37:52,946
Mēs jau iepriekš esam izmantojuši
kvadrātiekavas masīvu un tamlīdzīgu 

838
00:37:52,946 --> 00:37:55,370
lietu kontekstā. 

839
00:37:55,370 --> 00:37:58,420
Un 0, 1, 2 kaut kādā ziņā izskatās
kā masīvs, lai gan esam redzējuši 

840
00:37:58,420 --> 00:38:01,470
arī masīvus ar figūriekavām. 

841
00:38:01,470 --> 00:38:03,950
Bet šīs kvadrātiekavas pagaidām
apzīmē sarakstu.

842
00:38:03,950 --> 00:38:05,420
Python valodā nav masīvu.

843
00:38:05,420 --> 00:38:08,430
Masīvs ir tas blakus esošais
atmiņas gabals, kura izmērs ir kaut kā 

844
00:38:08,430 --> 00:38:11,440
jāmaina, pārvietojot lietas atmiņā,
kā tas bija teikts pirms divām 

845
00:38:11,440 --> 00:38:14,450
nedēļām. 

846
00:38:14,450 --> 00:38:16,812
Python, savukārt, varat vienkārši
izveidot šādu sarakstu, izmantojot 

847
00:38:16,812 --> 00:38:19,175
kvadrātiekavas. 

848
00:38:19,175 --> 00:38:22,047
Un vēl labāk, kā mēs redzēsim, jūs
varat pievienot vai pat noņemt 

849
00:38:22,047 --> 00:38:24,920
lietas no šī saraksta. 

850
00:38:24,920 --> 00:38:27,140
Kaut gan tas nebūs īpaši labi
izstrādāts.

851
00:38:27,140 --> 00:38:28,610
Tas darbosies.

852
00:38:28,610 --> 00:38:32,030
Tas tiks atkārtots Python valodā
trīs reizes.

853
00:38:32,030 --> 00:38:34,445
Bet kas varētu jūs kaitināt šajā
dizainā, pat ja jūs nekad iepriekš 

854
00:38:34,445 --> 00:38:36,860
neesat redzējuši Python? 

855
00:38:36,860 --> 00:38:38,460
Ka šis piemērs nebeidzas labi?

856
00:38:38,460 --> 00:38:38,960
Jā?

857
00:38:38,960 --> 00:38:41,810
liels saraksts [nesardzirdami]..

858
00:38:41,810 --> 00:38:42,560
DEIVIDS MALANS: Jā.

859
00:38:42,560 --> 00:38:45,476
Ja veidojat lielu sarakstu, jums ir
jāievada katrs no šiem cipariem, 

860
00:38:45,476 --> 00:38:48,392
piemēram, komats 3, komats 4,
komats 5, komats, punkts, punkts, 

861
00:38:48,392 --> 00:38:51,308
punkts, 50 komats, punkts, punkts,
punkts. Protams, tas nav labākais 

862
00:38:51,308 --> 00:38:54,224
risinājums, lai visi šie skaitļi
būtu uz ekrāna, bezgalīgi pārklājot 

863
00:38:54,224 --> 00:38:57,140
ekrānu. 

864
00:38:57,140 --> 00:38:59,480
Tātad Python valodā vēl viens
veids, kā to izdarīt, būtu izmantot 

865
00:38:59,480 --> 00:39:01,820
funkciju, ko sauc par diapazonu
(range), kas tehniski ir datu tips 

866
00:39:01,820 --> 00:39:04,160
pats par sevi. 

867
00:39:04,160 --> 00:39:08,080
Un tas atgriež jums tik daudz
vērtību, cik jūs tam prasāt.

868
00:39:08,080 --> 00:39:09,830
diapazonam ir nepieciešami arī daži
citi argumenti.

869
00:39:09,830 --> 00:39:12,910
Bet vienkāršākais lietošanas
gadījums šeit ir, ja vēlaties atgūt 

870
00:39:12,910 --> 00:39:15,990
skaitļus 0, 1 un 2 — kopā trīs
vērtības — jūs sakāt: “Hei, Python, 

871
00:39:15,990 --> 00:39:19,070
lūdzu, norādiet trīs vērtību
diapazonu”. 

872
00:39:19,070 --> 00:39:21,260
Un pēc noklusējuma tie sāk ar 0 uz
augšu.

873
00:39:21,260 --> 00:39:26,390
Taču tas ir efektīvāk nekā visa
saraksta cietā kodēšana uzreiz.

874
00:39:26,390 --> 00:39:29,150
Un labākā metafora, ko es varu
izdomāt, ir kaut kas līdzīgs šim:

875
00:39:29,150 --> 00:39:30,775
Šeit, piemēram, ir kāršu kava.

876
00:39:30,775 --> 00:39:34,430
Tā ir normālā izmēra kava, un tajā,
iespējams, ir 52 kārtis.

877
00:39:34,430 --> 00:39:37,100
Tāpēc, jums zināmo iemeslu dēļ,
koda ierakstīšana no 0 līdz 51 būtu 

878
00:39:37,100 --> 00:39:39,770
nedaudz smieklīga. 

879
00:39:39,770 --> 00:39:44,510
Un tas vienkārši būtu ļoti smagnēji
un neglīti, un tas pārklās visu.

880
00:39:44,510 --> 00:39:46,970
Tas būtu virtuāls ekvivalents tam,
ja es iedotu jums visas šīs 

881
00:39:46,970 --> 00:39:49,430
kārtis, lai jūs paši tiktu ar tām
galā. 

882
00:39:49,430 --> 00:39:52,760
Un, pareizi, tās nav tik lielas,
taču to ir daudz, ko turēt.

883
00:39:52,760 --> 00:39:55,760
Tam ir nepieciešams daudz atmiņas
vai fiziskās krātuves, ja vēlaties.

884
00:39:55,760 --> 00:40:00,426
Metaforiski runājot, diapazons dara
šādi: ja jūs man prasāt trīs 

885
00:40:00,426 --> 00:40:05,093
kārtis, es jums tās pa vienai
izdalīšu, šādi, tā, lai jebkurā brīdī 

886
00:40:05,093 --> 00:40:09,760
datora atmiņā būtu tikai viens
cipars, līdz jums izdalīs nākamo. 

887
00:40:09,760 --> 00:40:12,560
Alternatīva — iepriekšējā versija
būtu: izdalīt man visas trīs kārtis 

888
00:40:12,560 --> 00:40:15,360
uzreiz vai visas 52 kārtis uzreiz. 

889
00:40:15,360 --> 00:40:17,840
Bet šajā gadījumā diapazons ir
daudz efektīvāks.

890
00:40:17,840 --> 00:40:19,700
Varat veikt diapazonu no 1000.

891
00:40:19,700 --> 00:40:22,940
Tas nedos jums sarakstu ar 1000
vērtībām vienlaikus.

892
00:40:22,940 --> 00:40:26,870
Tas dos jums 1000 vērtības pa
vienai, ievērojami samazinot atmiņu 

893
00:40:26,870 --> 00:40:30,800
pašā datorā. 

894
00:40:30,800 --> 00:40:31,310
Labi.

895
00:40:31,310 --> 00:40:34,745
Tātad, tajā pašā laikā, kā izdarīt
kaut ko mūžīgu Scratch valodā?

896
00:40:34,745 --> 00:40:38,667
Mēs to varētu izdarīt burtiski ar
mūžīgu bloku, kas C valodā īsti 

897
00:40:38,667 --> 00:40:42,590
neeksistēja. 

898
00:40:38,060 --> 00:40:42,030
Valodā C mums bija jāuzlauž tas,
sakot True — jo True pēc definīcijas 

899
00:40:42,030 --> 00:40:46,000
ir PATIESA, vienmēr patiesa. 

900
00:40:46,000 --> 00:40:50,420
Tātad tas mums apzināti izraisa
bezgalīgu cilpu.

901
00:40:50,420 --> 00:40:53,375
Python loģika būs gandrīz tāda
pati.

902
00:40:53,375 --> 00:40:57,827
Un bezgalīgas cilpas Python valodā
mēdz būt vēl izplatītākas, jo jūs 

903
00:40:57,827 --> 00:41:02,280
vienmēr varat izlauzties no tām,
tāpat kā C valodā. 

904
00:40:58,760 --> 00:41:02,360
Python valodā tas izskatās šādi. Un
tas ir nedaudz smalkāk, taču te 

905
00:41:02,360 --> 00:41:05,960
vairs nav figūriekavu. 

906
00:41:05,960 --> 00:41:07,370
Iekavas ir pazudušas.

907
00:41:07,370 --> 00:41:10,400
Bet tik neliela atšķirība?

908
00:41:10,400 --> 00:41:13,187
Lielais T, lai apzīmētu True, un
tas būs lielais F, kas apzīmēs False.

909
00:41:13,187 --> 00:41:14,270
Stulbas mazas atšķirības.

910
00:41:14,270 --> 00:41:16,440
Galu galā jūs nepareizi
ierakstīsiet vienu vai otru.

911
00:41:16,440 --> 00:41:19,105
Taču šīs ir lietas, kurām jāpievērš
uzmanība un jāsāk atpazīt, lasot 

912
00:41:19,105 --> 00:41:21,770
kodu. 

913
00:41:21,770 --> 00:41:25,310
Vai jums ir jautājumi par kādu no
šiem blokiem?

914
00:41:25,310 --> 00:41:26,075
Jā?

915
00:41:26,075 --> 00:41:31,360
vienreiz iestatīt uz 0 [? katrai
cilpai? ?]

916
00:41:31,360 --> 00:41:34,945
DEIVIDS MALANS: For cilpā bija i —
tas tika iestatīts uz 0 pirmajā 

917
00:41:34,945 --> 00:41:38,530
iterācijā, tad uz 1 nākamajā, tad
uz 2 trešajā. 

918
00:41:38,530 --> 00:41:39,985
Un tas pats attiecas uz diapazonu.

919
00:41:39,985 --> 00:41:44,050
Tas vienkārši neizmanto tik daudz
atmiņas uzreiz.

920
00:41:44,050 --> 00:41:49,860
Vai ir citi jautājumi par kādu no
šiem Python pamatelementiem?

921
00:41:49,860 --> 00:41:50,400
Labi.

922
00:41:50,400 --> 00:41:53,250
Nu, ejam uz priekšu un izveidosim
kaut ko vairāk par hello.

923
00:41:53,250 --> 00:41:55,725
Ļaujiet man ierosināt, ka šeit mēs
ieviešam, iespējams, vienkāršāko 

924
00:41:55,725 --> 00:41:58,200
kalkulatoru. 

925
00:41:58,200 --> 00:42:02,542
Tāpēc ļaujiet man atgriezties pie
VS Code šeit, atvērt manu termināļa 

926
00:42:02,542 --> 00:42:06,885
logu un atvērt, teiksim, datni ar
nosaukumu calculator.py. 

927
00:42:06,885 --> 00:42:10,510
Un vietnē calculator.py mums būs
iespēja izpētīt dažus no šiem 

928
00:42:10,510 --> 00:42:14,135
elementiem, taču mēs ļausim lietām
diezgan ātri pāraugt 

929
00:42:14,135 --> 00:42:17,760
interesantākajos piemēros, lai mēs
varētu darīt to pašu. 

930
00:42:17,760 --> 00:42:19,510
Un patiesībā ļaujiet man iet uz
priekšu un izdarīt to.

931
00:42:19,510 --> 00:42:22,950
Turklāt es jau iepriekš esmu
paņēmis līdzi kodu.

932
00:42:22,950 --> 00:42:25,905
Piemēram, kaut kas, ko sauc par
calculator0.c, no C valodas pirmās 

933
00:42:25,905 --> 00:42:28,860
nedēļas. 

934
00:42:25,725 --> 00:42:30,072
Un ļaujiet man iet uz priekšu un
faktiski sadalīt savu logu šeit, lai 

935
00:42:30,072 --> 00:42:34,420
es tagad varētu izdarīt kaut ko
līdzīgu. 

936
00:42:34,420 --> 00:42:37,170
Ļaujiet man to pārvietot šeit,
šeit.

937
00:42:37,170 --> 00:42:38,105
Calculator.py.

938
00:42:38,105 --> 00:42:40,633
Tāpēc tagad mana ekrāna kreisajā
pusē ir calculator.c — vai 

939
00:42:40,633 --> 00:42:43,161
calculator0.c, jo tā ir pirmā
versija, ko izveidoju — un 

940
00:42:43,161 --> 00:42:45,690
calculator.py labajā pusē. 

941
00:42:45,690 --> 00:42:48,290
Ļaujiet man turpināt un īstenot to
pašu ideju šeit.

942
00:42:48,290 --> 00:42:52,340
Tātad labajā pusē cs50.h
iekļaušanas analogs būtu no cs50 import 

943
00:42:52,340 --> 00:42:56,390
get_int, ja es patiešām vēlos
izmantot šo funkciju. 

944
00:42:56,390 --> 00:43:00,453
Tagad es turpināšu un došu sev
mainīgo x, nedefinējot tā veidu.

945
00:43:00,453 --> 00:43:02,877
Es izmantošu šo get_int funkciju un
likšu lietotājam ievadīt x, tāpat 

946
00:43:02,877 --> 00:43:05,302
kā C valodā. 

947
00:43:05,302 --> 00:43:08,801
Pēc tam es likšu lietotājam šeit
ievadīt citu int, piemēram, y, tāpat 

948
00:43:08,801 --> 00:43:12,300
kā C valodā. 

949
00:43:08,010 --> 00:43:14,640
Un pašās beigās es iešu uz priekšu
un izdrukāšu x plus y.

950
00:43:14,640 --> 00:43:15,690
Un viss.

951
00:43:15,690 --> 00:43:18,390
Tagad, protams, manā koda C versijā
ir daži komentāri, lai atgādinātu 

952
00:43:18,390 --> 00:43:21,090
jums par katras rindiņas darbību. 

953
00:43:21,090 --> 00:43:23,130
Bet es joprojām esmu to sadalījis
sešās rindās — vai, īstenībā, 

954
00:43:23,130 --> 00:43:25,170
četrās, ja atbrīvojos no tukšās
rindas. 

955
00:43:25,170 --> 00:43:29,580
Tāpēc šeit jau, iespējams, ir
nedaudz skaidrāk.

956
00:43:29,580 --> 00:43:31,590
Tas ir skaidrāks, jo pietrūkst kaut
kādas vēsturiski patiešām 

957
00:43:31,590 --> 00:43:33,600
svarīgas daļas. 

958
00:43:33,600 --> 00:43:38,240
Šķiet, ka es izlaidu, to, ko mēs
vēl īsti neesam izcēluši?

959
00:43:38,240 --> 00:43:39,136
Jā?

960
00:43:39,136 --> 00:43:40,530
Mērķauditorija: [Nesadzirdami]

961
00:43:40,530 --> 00:43:41,280
DEIVIDS MALANS: Jā.

962
00:43:41,280 --> 00:43:42,910
Galvenā funkcija ir pazudusi.

963
00:43:42,910 --> 00:43:45,031
Un patiesībā, iespējams, jūs
uzskatījāt par pašsaprotamu, ka tas 

964
00:43:45,031 --> 00:43:47,152
darbojās pirms brīža, kad es
uzrakstīju hello, bet man arī nebija 

965
00:43:47,152 --> 00:43:49,273
galvenās funkcijas hello programmā.


966
00:43:49,273 --> 00:43:52,440
Un arī šī ir Python un daudzu citu
valodu iezīme.

967
00:43:52,440 --> 00:43:54,920
Tā vietā, lai ievērotu šīs
ilggadējās tradīcijas, ja vēlaties tikai 

968
00:43:54,920 --> 00:43:57,400
rakstīt kodu un kaut ko paveikt,
labi. 

969
00:43:57,400 --> 00:43:59,292
Vienkārši rakstiet kodu un
paveiciet kaut ko arī bez šīs pašas 

970
00:43:59,292 --> 00:44:01,185
tekstveidnes. 

971
00:44:01,185 --> 00:44:04,406
Tātad viss, kas atrodas jūsu Python
datnē — ar kreiso atkāpi, ja 

972
00:44:04,406 --> 00:44:07,628
vēlaties, pēc noklusējuma — tas būs
tikai kods, ko tulks izpilda no 

973
00:44:07,628 --> 00:44:10,850
augšas uz leju, no kreisās puses uz
labo. 

974
00:44:10,850 --> 00:44:14,300
Tagad ļaujiet man iet uz priekšu un
palaist šādu kodu.

975
00:44:14,300 --> 00:44:16,720
Ļaujiet man turpināt un atvērt savu
termināļa logu, palaist python no 

976
00:44:16,720 --> 00:44:19,140
calculator.py. 

977
00:44:19,140 --> 00:44:21,570
Un es uzrakstīšu, ka x ir 1, y ir
2.

978
00:44:21,570 --> 00:44:23,460
Un, kā jūs varētu gaidīt, tas man
dod 3.

979
00:44:23,460 --> 00:44:24,570
Neliela estētiska kļūda.

980
00:44:24,570 --> 00:44:26,590
Es šeit ievietoju atstarpi
nepareizā vietā.

981
00:44:26,590 --> 00:44:27,810
Tātad tā ir iesācēju kļūda.

982
00:44:27,810 --> 00:44:29,220
Ļaujiet man to estētiski salabot.

983
00:44:29,220 --> 00:44:31,050
Ļaujiet man atkārtoti palaist
python no calculator.py.

984
00:44:31,050 --> 00:44:31,680
Ierakstiet 1.

985
00:44:31,680 --> 00:44:32,250
Ievadiet 2.

986
00:44:32,250 --> 00:44:36,280
Un, voilà, tagad tā pati versija
atkal ir te.

987
00:44:36,280 --> 00:44:39,585
Bet ļaujiet man tagad ierosināt
atbrīvoties no šiem palīgriteņiem.

988
00:44:39,585 --> 00:44:42,457
Mēs nevēlamies spert vienu soli uz
priekšu un pēc tam divus soļus 

989
00:44:42,457 --> 00:44:45,330
atpakaļ, pievienojot šos
palīgriteņus, tāpēc ļaujiet man izdarīt šo. 

990
00:44:45,330 --> 00:44:49,893
Manā calculator.py versijā
pieņemsim, ka mēs noņemam palīgriteni, kas 

991
00:44:49,893 --> 00:44:54,456
ir CS50 bibliotēka, un tā vietā
ļaujam man izmantot tikai Python 

992
00:44:54,456 --> 00:44:59,020
iebūvēto funkciju, ko sauc par
ievadi, kas burtiski to arī dara. 

993
00:44:59,020 --> 00:45:01,310
Tas saņem ievadi no lietotāja un
saglabā to, tāpat kā iepriekš, x un 

994
00:45:01,310 --> 00:45:03,600
y. 

995
00:45:03,600 --> 00:45:04,950
Tātad tas nav saistīts ar CS50.

996
00:45:04,950 --> 00:45:07,155
Šī ir reālās pasaules Python
programmēšana.

997
00:45:07,155 --> 00:45:10,740
Ļaujiet man turpināt un atkal
palaist python no calculator.py.

998
00:45:10,740 --> 00:45:16,530
Un, protams, ja x ir 1 un y ir 2, x
plus y, protams, joprojām ir 3.

999
00:45:19,306 --> 00:45:21,795
Acīmredzot tas ir 12, saskaņā ar
Python datiem, līdz iesaistās CS50 

1000
00:45:21,795 --> 00:45:24,285
bibliotēka. 

1001
00:45:24,285 --> 00:45:28,620
Bet vai kāds vēlas secināt, kas
tikko nogāja greizi?

1002
00:45:28,620 --> 00:45:29,160
Jā?

1003
00:45:29,160 --> 00:45:32,925
AUDITORIJA: Mēs vienmēr esam
[nesadzirdami].

1004
00:45:32,925 --> 00:45:33,800
DEIVIDS MALANS: Tieši tā.

1005
00:45:33,800 --> 00:45:37,660
Ievades funkcija pēc konstrukcijas
vienmēr atgriež teksta virkni.

1006
00:45:37,660 --> 00:45:39,410
Galu galā tas ir tas, ko cilvēks
ierakstīja.

1007
00:45:39,410 --> 00:45:42,005
Un, lai gan, jā, es izmantoju
tastatūras ciparu taustiņus, viss 

1008
00:45:42,005 --> 00:45:44,600
joprojām atgriežas teksta veidā. 

1009
00:45:44,600 --> 00:45:47,090
Tagad varbūt mums it kā vajadzētu
izmantot get_int funkciju.

1010
00:45:47,090 --> 00:45:48,575
Nu, tā neeksistē Python valodā.

1011
00:45:48,575 --> 00:45:50,457
Viss, ko varat izdarīt - tas ir
iegūt teksta ievadi — virkni no 

1012
00:45:50,457 --> 00:45:52,340
lietotāja. 

1013
00:45:52,340 --> 00:45:54,415
Bet mēs varam pārveidot vienu par
otru.

1014
00:45:54,415 --> 00:45:58,587
Un tāpēc, lai mēs nejauši
nekonkatenētu — tas ir, apvienotu x plus 

1015
00:45:58,587 --> 00:46:02,760
y — būtu jādara kaut kas līdzīgs
šim. 

1016
00:46:02,760 --> 00:46:04,595
Ļaujiet man atgriezties pie sava
Python koda, šeit.

1017
00:46:04,595 --> 00:46:08,220
Un tā kā C valodā mēs iepriekš
varējām veikt tipveida atlasi — mēs 

1018
00:46:08,220 --> 00:46:11,845
varam pārvērst vienu tipu citā —
tas parasti nenotika, ja darījāt 

1019
00:46:11,845 --> 00:46:15,470
kaut ko sarežģītu, piemēram, int
funkcijas virkni. 

1020
00:46:15,470 --> 00:46:18,450
Jūs varētu izmantot char int
funkcijā un otrādi.

1021
00:46:18,450 --> 00:46:21,775
Bet virknei, atceraties, C veida
bibliotēkā bija īpaša funkcija, ko 

1022
00:46:21,775 --> 00:46:25,100
sauca no atol, tāpat kā ASCII
veselam skaitlim. 

1023
00:46:25,100 --> 00:46:27,880
Tas ir tuvākais analogs šeit.

1024
00:46:27,880 --> 00:46:30,713
Un patiesībā Python valodā to var
izdarīt, izmantojot funkciju int, 

1025
00:46:30,713 --> 00:46:33,546
kas patiesībā ir arī datu veida
nosaukums, lai gan man tas vēl nav 

1026
00:46:33,546 --> 00:46:36,380
jāievada. 

1027
00:46:36,380 --> 00:46:40,490
Un es varu automātiski pārvērst
ievades funkcijas izvadi no virknes 

1028
00:46:40,490 --> 00:46:44,600
uzreiz uz int. 

1029
00:46:44,600 --> 00:46:47,323
Un tagad, ja es atgriezīšos savā
termināļa logā, atkārtoti palaižu 

1030
00:46:47,323 --> 00:46:50,046
python no calculator.py ar x un y
vērtībām 1 un 2, tagad es atkal 

1031
00:46:50,046 --> 00:46:52,770
esmu ierindā. 

1032
00:46:52,770 --> 00:46:56,095
Tātad, piemēram, šonedēļ,
īslaicīgi, CS50 bibliotēka nodarbojas tikai 

1033
00:46:56,095 --> 00:46:59,420
ar konvertēšanu. 

1034
00:46:59,420 --> 00:47:02,517
Un patiešām var būt slikti, ja
ierakstīšu kaut ko nepareizi, 

1035
00:47:02,517 --> 00:47:05,615
piemēram, suns vai kaķis skaitļa
vietā. 

1036
00:47:05,615 --> 00:47:08,400
Bet arī šo problēmu mēs atrisināsim
pēc brīža.

1037
00:47:08,400 --> 00:47:08,900
Labi.

1038
00:47:08,900 --> 00:47:10,445
Kā būtu, ja mēs tagad izdarītu kaut
ko nedaudz savādāku ar mūsu 

1039
00:47:10,445 --> 00:47:11,990
kalkulatoru. 

1040
00:47:16,400 --> 00:47:18,790
Saskaitīšanas vietā veiksim
dalīšanu.

1041
00:47:18,790 --> 00:47:21,390
Tātad z ir vienāds ar x dalīts ar
y, tādējādi iegūstot trešo mainīgo 

1042
00:47:21,390 --> 00:47:23,990
z. 

1043
00:47:23,990 --> 00:47:27,320
Ļaujiet man turpināt un palaist
python no calculator.py vēlreiz.

1044
00:47:27,320 --> 00:47:29,120
Es ierakstīšu 1.

1045
00:47:29,120 --> 00:47:31,790
Šoreiz ierakstīšu 3.

1046
00:47:31,790 --> 00:47:37,470
Un kādu problēmu, jūsuprāt, mēs
redzēsim?

1047
00:47:37,470 --> 00:47:38,400
Vai arī tā ir pazudusi?

1048
00:47:38,400 --> 00:47:43,040
Kas notika, kad es to izdarīju C
valodā, lai gan ar nedaudz slēptāku 

1049
00:47:43,040 --> 00:47:47,680
sintaksi, kad es sadalīju vienu
skaitli, piemēram, 1 dalīts ar 3? 

1050
00:47:47,680 --> 00:47:48,600
Kāds atceras?

1051
00:47:48,600 --> 00:47:49,100
Jā?

1052
00:47:49,100 --> 00:47:51,310
Mērķauditorija: Jūs noapaļosiet
līdz tuvākajam veselam skaitlim.

1053
00:47:51,310 --> 00:47:52,060
DEIVIDS MALANS: Jā.

1054
00:47:52,060 --> 00:47:54,810
Tā tas tiktu noapaļots uz leju līdz
tuvākajam veselam skaitlim, 

1055
00:47:54,810 --> 00:47:57,560
tādējādi tiekot saīsināts. 

1056
00:47:57,560 --> 00:48:00,476
Tātad, ja ņemat veselu skaitli,
piemēram, 1, jūs to sadalāt ar citu 

1057
00:48:00,476 --> 00:48:03,393
veselu skaitli, piemēram, 3, kam
tehniski vajadzētu būt 0,33333, 

1058
00:48:03,393 --> 00:48:06,310
bezgalīgi garam. 

1059
00:48:06,310 --> 00:48:10,297
Bet C valodā, atceraties, jūs
saīsināt vērtību.

1060
00:48:10,297 --> 00:48:12,631
Ja jūs sadalāt int ar int, jūs
saņemat atpakaļ int, kas nozīmē, ka 

1061
00:48:12,631 --> 00:48:14,965
jūs saņemat tikai veselu skaitļa
daļu, kas bija 0. 

1062
00:48:14,965 --> 00:48:16,885
Tagad Python faktiski to nokārto
mūsu vietā un izvairās no 

1063
00:48:16,885 --> 00:48:18,805
saīsināšanas. 

1064
00:48:18,805 --> 00:48:23,129
Bet tas mums joprojām atstāj kādu
citu problēmu, kas, piemēram, nebūs 

1065
00:48:23,129 --> 00:48:27,453
uzreiz acīmredzama. 

1066
00:48:27,453 --> 00:48:28,245
Tas izskatās pareizi.

1067
00:48:28,245 --> 00:48:31,780
Tas ir atrisinājis problēmu C
valodā.

1068
00:48:28,245 --> 00:48:32,127
Tātad saīsināšana nenotiek. Veseli
skaitļi tiek automātiski pārvērsti 

1069
00:48:32,127 --> 00:48:36,010
peldošā komata vērtībā. 

1070
00:48:36,010 --> 00:48:41,970
Bet uz kādas citas problēmas mēs
paklupām pirmajā nedēļā?

1071
00:48:44,480 --> 00:48:49,700
Kas vēl ir kļuvis nepatīkamāks,
strādājot ar vienkāršu aritmētiku?

1072
00:48:49,700 --> 00:48:51,238
Kāds atceras?

1073
00:48:51,238 --> 00:48:53,009
Python sintakse ir nedaudz
atšķirīga, taču ļaujiet man turpināt un 

1074
00:48:53,009 --> 00:48:54,780
izdarīt šo. 

1075
00:48:54,780 --> 00:48:57,758
Izrādās, Python valodā, ja vēlaties
redzēt nozīmīgākus ciparus par 

1076
00:48:57,758 --> 00:49:00,736
tiem, kurus es šeit redzu pēc
noklusējuma, kas ir apmēram ducis, 

1077
00:49:00,736 --> 00:49:03,715
ļaujiet man turpināt un izdrukāt z
šādi. 

1078
00:49:03,715 --> 00:49:06,247
Ļaujiet man vispirms izdrukāt
formāta virkni, jo es vēlos formatēt z 

1079
00:49:06,247 --> 00:49:08,780
interesantā veidā. 

1080
00:49:08,780 --> 00:49:11,330
Un ievērojiet, tas neietekmēs
atšķirību.

1081
00:49:11,330 --> 00:49:13,980
Šī ir tikai formāta virkne, kas
pašlaik bez pārliecinoša iemesla 

1082
00:49:13,980 --> 00:49:16,630
interpolē z šajās figūriekavās,
izmantojot fstring vai formāta 

1083
00:49:16,630 --> 00:49:19,280
virkni. 

1084
00:49:19,280 --> 00:49:21,335
Ja es to izpildīšu vēlreiz ar 1 un
3, mēs patiešām redzēsim tieši to 

1085
00:49:21,335 --> 00:49:23,390
pašu. 

1086
00:49:23,390 --> 00:49:25,925
Bet, ja izmantojat fstring, jums
tiešām ir iespēja formatēt šo virkni 

1087
00:49:25,925 --> 00:49:28,460
precīzāk. 

1088
00:49:28,460 --> 00:49:32,765
Tāpat kā ar %f Python valodā, jūs
varētu sākt precizēt, cik zīmīgos 

1089
00:49:32,765 --> 00:49:37,070
ciparus redzat — C valodā,
attiecīgi. 

1090
00:49:37,070 --> 00:49:38,630
Python valodā jūs varat darīt to
pašu, taču sintakse ir nedaudz 

1091
00:49:38,630 --> 00:49:40,190
atšķirīga. 

1092
00:49:40,190 --> 00:49:43,860
Ja vēlaties, lai dators interpolētu
z un parādītu 50 zīmīgos ciparus, 

1093
00:49:43,860 --> 00:49:47,530
tas ir, 50 ciparus aiz komata,
sintakse ir līdzīga C valodai, taču tā 

1094
00:49:47,530 --> 00:49:51,200
ir nedaudz atšķirīga. 

1095
00:49:51,200 --> 00:49:54,110
Jūs burtiski ievietojat kolu aiz
mainīgā nosaukuma.

1096
00:49:54,110 --> 00:49:56,993
Punkts 50 nozīmē: parādiet man
decimālzīmi un pēc tam 50 ciparus pa 

1097
00:49:56,993 --> 00:49:59,876
labi. Un f tikai norāda: lūdzu,
uzskatiet to par peldošā komata 

1098
00:49:59,876 --> 00:50:02,760
vērtību. 

1099
00:50:02,760 --> 00:50:07,735
Tātad tagad, ja es atkārtoti
palaistu calculator.py python, dalītu 1 

1100
00:50:07,735 --> 00:50:12,710
ar 3, diemžēl - Python nav
atrisinājusi visas pasaules problēmas. 

1101
00:50:12,710 --> 00:50:15,545
Tas atkal bija peldošā komata
neprecizitātes piemērs.

1102
00:50:15,545 --> 00:50:17,692
Tātad šī problēma joprojām ir
latenta.

1103
00:50:17,692 --> 00:50:20,004
Tas, ka pasaule ir progresējusi, ne
vienmēr nozīmē, ka visas mūsu 

1104
00:50:20,004 --> 00:50:22,317
problēmas C valodā ir pazudušas. 

1105
00:50:22,317 --> 00:50:24,638
Ir risinājumi, kuros zinātniskiem
aprēķiniem un tamlīdzīgiem nolūkiem 

1106
00:50:24,638 --> 00:50:26,960
tiek izmantotas trešo pušu
bibliotēkas. 

1107
00:50:26,960 --> 00:50:31,445
Taču peldošā komata neprecizitāte
joprojām ir problēma.

1108
00:50:31,445 --> 00:50:34,260
Tikmēr C valodā bija vēl viena cita
problēma, ar kuru mēs 

1109
00:50:34,260 --> 00:50:37,075
saskārāmies, iekļaujot skaitļus, un
tā bija šī — veselu skaitļu 

1110
00:50:37,075 --> 00:50:39,890
pārpilde. 

1111
00:50:39,890 --> 00:50:42,425
Atceraties, ka vesels skaitlis
valodā C aizņēma tikai 32 bitus, kas 

1112
00:50:42,425 --> 00:50:44,960
nozīmēja, ka jūs varētu saskaitīt
līdz 4 miljardiem vai, iespējams, 

1113
00:50:44,960 --> 00:50:47,495
ja izmantojāt pozitīvus un
negatīvus skaitļus, — līdz 2 miljardiem, 

1114
00:50:47,495 --> 00:50:50,030
pēc kā dīvainas lietas notiktu. 

1115
00:50:50,030 --> 00:50:52,414
Skaitlis būtu 0 vai negatīvs, vai
arī tas pārplūstu vai apgrieztos 

1116
00:50:52,414 --> 00:50:54,798
atpakaļ. 

1117
00:50:54,798 --> 00:50:57,799
Brīnišķīgi, ka Python valodā viņi
vismaz ir pievērsušies tam, 

1118
00:50:57,799 --> 00:51:00,800
tādējādi jūs varat skaitīt tik
augstu, cik vēlaties. 

1119
00:51:00,800 --> 00:51:03,540
Un Python tikai izmantos arvien
vairāk un vairāk bitu un baitu, lai 

1120
00:51:03,540 --> 00:51:06,280
saglabātu patiešām lielus skaitļus,
tāpēc veselu skaitļu pārpilde nav 

1121
00:51:06,280 --> 00:51:09,020
problēma. 

1122
00:51:09,020 --> 00:51:12,215
Ņemot to vērā, Python ir ierobežota
līdz tam, cik ciparu tā 

1123
00:51:12,215 --> 00:51:15,410
vienlaikus parādīs kā virkni uz
ekrāna. 

1124
00:51:15,410 --> 00:51:18,560
Bet matemātiski runājot, jūsu
matemātika tagad būs pareiza.

1125
00:51:18,560 --> 00:51:21,860
Tāpēc mēs esam spēruši pāris soļus
uz priekšu, vienu soli uz sāniem.

1126
00:51:21,860 --> 00:51:25,530
Bet patiešām šeit mēs esam
atrisinājuši dažas no savām problēmām.

1127
00:51:25,530 --> 00:51:26,030
Labi.

1128
00:51:26,030 --> 00:51:32,230
Vai jums ir jautājumi par kādu no
piemēriem, kuri ir bijuši līdz šim?

1129
00:51:32,230 --> 00:51:34,400
Jautājumi?

1130
00:51:34,400 --> 00:51:35,000
Labi.

1131
00:51:35,000 --> 00:51:40,250
Nu, kā būtu ar citu problēmu, ar
kuru mēs saskārāmies C valodā.

1132
00:51:35,000 --> 00:51:41,720
Apskatīsim to arī šeit - Python
valodā.

1133
00:51:41,720 --> 00:51:47,026
Tāpēc ļaujiet man turpināt un
kreisajā pusē atvērt datni, teiksim, 

1134
00:51:47,026 --> 00:51:52,333
compare3.c kreisajā pusē, un
ļaujiet man izveidot jaunu datni labajā 

1135
00:51:52,333 --> 00:51:57,640
pusē ar nosaukumu compare.py. 

1136
00:51:57,640 --> 00:52:00,610
Jo atceraties, ka sliktas lietas
notika, kad mums vajadzēja 

1137
00:52:00,610 --> 00:52:03,580
salīdzināt divas vērtības valodā C.


1138
00:52:00,070 --> 00:52:03,790
Tātad pa kreisi, šeit ir
atgādinājums par to, ko mēs kādreiz darījām 

1139
00:52:03,790 --> 00:52:07,510
ar C, un, ja mēs vēlamies
salīdzināt vērtības, mēs varam iegūt int 

1140
00:52:07,510 --> 00:52:11,230
valodā C, saglabāt to x. 

1141
00:52:11,230 --> 00:52:13,450
get_int valodā C, saglabājiet to y.

1142
00:52:13,450 --> 00:52:16,330
Šeit mums ir mūsu pazīstamā,
nosacītā loģika, tikai izdrukājot if x, 

1143
00:52:16,330 --> 00:52:19,210
x ir mazāks par y, vai nav. 

1144
00:52:19,210 --> 00:52:22,465
Galu galā mēs noteikti varam darīt
to pašu Python, izmantojot kādu 

1145
00:52:22,465 --> 00:52:25,720
diezgan pazīstamu sintaksi. 

1146
00:52:25,720 --> 00:52:27,640
Un vienkārši ātri parādīsim šo.

1147
00:52:27,640 --> 00:52:29,500
Ļaujiet man pāriet šeit.

1148
00:52:29,500 --> 00:52:33,100
Es no cs50 importēšu get_int, lai
gan to varētu izdarīt, izmantojot 

1149
00:52:33,100 --> 00:52:36,700
pašu ievades funkciju. 

1150
00:52:36,700 --> 00:52:39,700
x ir vienāds ar get_int, un es
atgādināšu lietotājam par to.

1151
00:52:39,700 --> 00:52:42,880
y ir vienāds ar get_int, un es
atgādināšū lietotājam par to.

1152
00:52:42,880 --> 00:52:48,490
Pēc tam atcerieties, ka bez iekavām
varu teikt, ja x ir mazāks par y, 

1153
00:52:48,490 --> 00:52:54,100
tad bez f izdrukājiet x is less
than y.. Tad es varu iet uz priekšu 

1154
00:52:54,100 --> 00:52:59,710
un pateikt: else if x ir lielāks
par y, es varu izdrukāt x is greater 

1155
00:52:59,710 --> 00:53:05,320
than y.. Ja vēlaties tagad
iejaukties, ko es salaidu grīstē? 

1156
00:53:05,320 --> 00:53:05,820
Kāds?

1157
00:53:05,820 --> 00:53:06,150
Jā?

1158
00:53:06,150 --> 00:53:06,915
Mērķauditorija: Elif.

1159
00:53:06,915 --> 00:53:07,957
DEIVIDS MALANS: Elif, vai ne?

1160
00:53:07,957 --> 00:53:13,881
Tātad elif x ir lielāks par y, else
- šī daļa ir tāda pati, 

1161
00:53:13,881 --> 00:53:19,805
izdrukājiet x is equal to y.. Šeit
nav nekādas jaunas loģikas. 

1162
00:53:19,805 --> 00:53:21,960
Bet vismaz sintaktiski tā ir
nedaudz tīrāk.

1163
00:53:21,960 --> 00:53:23,730
Patiešām, šī programma ir tikai 11
rindiņas gara, lai gan bez 

1164
00:53:23,730 --> 00:53:25,500
komentāriem. 

1165
00:53:25,500 --> 00:53:27,765
Ļaujiet man turpināt un palaist
python no example.py.

1166
00:53:27,765 --> 00:53:28,350
Paskatīsimies.

1167
00:53:28,350 --> 00:53:30,235
Vai 1 ir mazāks par 2?

1168
00:53:30,235 --> 00:53:30,735
Patiešām.

1169
00:53:30,735 --> 00:53:32,070
Palaidīsim to vēlreiz.

1170
00:53:32,070 --> 00:53:33,330
Vai 2 ir mazāks par 1?

1171
00:53:33,330 --> 00:53:34,890
Nē, tas ir lielāks.

1172
00:53:34,890 --> 00:53:37,740
Visbeidzot, ierakstīsim 1 un 1
divreiz.

1173
00:53:37,740 --> 00:53:38,910
x ir vienāds ar y.

1174
00:53:38,910 --> 00:53:42,030
Tātad mums šeit ir diezgan
paralēla, viens pret vienu konversija.

1175
00:53:42,030 --> 00:53:44,190
Tad darīsim kaut ko interesantāku.

1176
00:53:44,190 --> 00:53:46,750
Kā būtu, ja C valodā atvērtu kaut
ko tādu, ko mēs faktiski 

1177
00:53:46,750 --> 00:53:49,310
salīdzinājām ar mērķi? 

1178
00:53:49,310 --> 00:53:54,815
Tātad, ja es atveru - no
iepriekšējā kursa - kā būtu ar agree.c, kas 

1179
00:53:54,815 --> 00:54:00,320
mudina lietotāju kaut kam piekrist
vai nepiekrist? 

1180
00:54:00,320 --> 00:54:03,860
Un ļaujiet man šeit iekodēt jaunu
versiju, ko sauc par agree.py.

1181
00:54:03,860 --> 00:54:06,720
Un es to darīšu labajā pusē ar
agree.py.

1182
00:54:06,720 --> 00:54:10,147
Bet ar agree.c kreisajā pusē —
ievērojiet, ka šādi mēs darījām šo 

1183
00:54:10,147 --> 00:54:13,575
jā-nē darbību valodā C — mēs
salīdzinājām c, rakstzīmi, kas ir 

1184
00:54:13,575 --> 00:54:17,002
vienāda ar vienpēdiņās Y vai
vienāda ar vienpēdiņās mazo y;. Un tad 

1185
00:54:17,002 --> 00:54:20,430
tas pats par n. 

1186
00:54:20,430 --> 00:54:23,960
Tagad Python valodā tas faktiski
būs nedaudz savādāk šeit.

1187
00:54:23,960 --> 00:54:26,800
Ļaujiet man turpināt un Python
versijā ļaujiet man izdarīt kaut ko 

1188
00:54:26,800 --> 00:54:29,640
līdzīgu šim. 

1189
00:54:29,640 --> 00:54:31,258
Mēs izmantosim get_string.

1190
00:54:31,258 --> 00:54:31,800
Patiesībā, nē.

1191
00:54:31,800 --> 00:54:33,217
Šajā gadījumā mēs izmantosim tikai
ievadi.

1192
00:54:33,217 --> 00:54:36,780
Tātad izdarīsim s vienāds ar input.

1193
00:54:36,780 --> 00:54:40,875
Un mēs jautāsim lietotājam to
pašu — vai piekrītat, jautājuma zīme.

1194
00:54:40,875 --> 00:54:48,940
Tad ejam uz priekšu un sakām: ja s
ir vienāds ar, tad kā būtu ar Y?

1195
00:54:48,940 --> 00:54:49,740
A?

1196
00:54:49,740 --> 00:54:50,758
Kā to izdarīt?

1197
00:54:50,758 --> 00:54:51,550
Nu, dažas lietas.

1198
00:54:51,550 --> 00:54:54,660
Izrādās, es darīšu to — s ir
vienāds ar mazo y.

1199
00:54:54,660 --> 00:54:59,435
Pēc tam es iešu uz priekšu un
izdrukāšu “Agreed”. Un elif s ir 

1200
00:54:59,435 --> 00:55:04,210
vienāds ar lielo N vai s ir vienāds
ar mazo burtu n, es iešu uz 

1201
00:55:04,210 --> 00:55:08,985
priekšu un izdrukāšu "Not agreed.".
Un es šobrīd apgalvoju, ka šī ir 

1202
00:55:08,985 --> 00:55:13,760
identiska programmai kreisajā pusē
C valodā. 

1203
00:55:08,820 --> 00:55:13,800
Bet kas atšķiras? Tātad mēs
joprojām rīkojamies ar tādu pašu loģiku: 

1204
00:55:13,800 --> 00:55:18,780
šie vienādojumi tiek vienādoti, lai
salīdzinātu vienlīdzību. 

1205
00:55:18,780 --> 00:55:27,933
izteikt loģisku un C, [ŅURD]

1206
00:55:27,933 --> 00:55:30,661
jūs varat vienkārši burtiski
uzrakstīt vārdu “and”. Tātad, šeit ir 

1207
00:55:30,661 --> 00:55:33,390
mājiens, kāpēc Python valoda mēdz
būt diezgan populāra. 

1208
00:55:33,390 --> 00:55:35,640
Cilvēkiem vienkārši patīk, ka tā ir
nedaudz tuvāka angļu valodai.

1209
00:55:35,640 --> 00:55:38,520
Šeit ir nedaudz mazāk sarežģītas
sintakses.

1210
00:55:38,520 --> 00:55:41,850
Tagad viss ir pareizi, jo šis kods
tagad darbosies.

1211
00:55:41,850 --> 00:55:45,710
Taču vienpēdiņu vietā esmu
izmantojis arī dubultpēdiņas, kā arī pirms 

1212
00:55:45,710 --> 00:55:49,570
dažām minūtēm savā Python datu tipu
sarakstā izlaidu vārdu “char”. 

1213
00:55:49,570 --> 00:55:53,430
Python valodā nav char. 

1214
00:55:53,430 --> 00:55:55,320
Nav atsevišķu rakstzīmju.

1215
00:55:55,320 --> 00:55:58,500
Ja vēlaties manipulēt ar atsevišķu
rakstzīmi, izmantojiet virkni ar 

1216
00:55:58,500 --> 00:56:01,680
izmēru 1, tas ir - str. 

1217
00:56:01,680 --> 00:56:04,930
Tagad Python valodā varat izmantot
vienpēdiņas vai dubultpēdiņas.

1218
00:56:04,930 --> 00:56:07,322
Es apzināti visur izmantoju
dubultpēdiņas, lai nodrošinātu atbilstību 

1219
00:56:07,322 --> 00:56:09,715
tam, kā mēs apstrādājam virknes C
valodā. 

1220
00:56:09,715 --> 00:56:13,017
Tomēr ir diezgan izplatīti tagad
lietot vienpēdiņas, kaut vai tāpēc, 

1221
00:56:13,017 --> 00:56:16,320
ka uz lielāko daļu tastatūru vairs
nav jātur Shift taustiņš. 

1222
00:56:16,320 --> 00:56:19,830
Cilvēki patiešām ir sākuši
optimizēt, cik ātri viņi vēlas kodēt.

1223
00:56:19,830 --> 00:56:22,050
Tāpēc vienpēdiņu izmantošana mēdz
būt diezgan populāra arī Python un 

1224
00:56:22,050 --> 00:56:24,270
citās valodās. 

1225
00:56:24,270 --> 00:56:27,420
Tās būtībā ir vienādas, vienpēdiņas
vai dubultpēdiņas, atšķirībā no C 

1226
00:56:27,420 --> 00:56:30,570
valodas, kur tām ir nozīme. 

1227
00:56:30,570 --> 00:56:33,120
Tātad viss ir pareizi, es
apgalvoju.

1228
00:56:33,120 --> 00:56:34,830
Un, patiesībā, ļaujiet man to ātri
palaist.

1229
00:56:34,830 --> 00:56:37,090
Šeit es atvēršu savu termināļa
logu.

1230
00:56:37,090 --> 00:56:38,660
Ļaujiet man atbrīvoties no versijas
C valodā un palaist python no 

1231
00:56:38,660 --> 00:56:40,230
agree.py. 

1232
00:56:40,230 --> 00:56:42,420
Un es ierakstīšu Y.

1233
00:56:40,230 --> 00:56:44,220
OK. Es palaidīšu to vēlreiz un
ierakstīšu mazo y.

1234
00:56:44,220 --> 00:56:46,780
Un es noteikšu, ka tas darbosies
arī ar “nē”.

1235
00:56:46,780 --> 00:56:49,840
Bet tas ne vienmēr ir vienīgais
veids, kā mēs to varam izdarīt.

1236
00:56:49,840 --> 00:56:52,350
Ir arī citi veidi, kā īstenot to
pašu ideju.

1237
00:56:52,350 --> 00:56:57,630
Un patiesībā es varu to izdarīt
tādā veidā.

1238
00:56:57,630 --> 00:56:59,910
Ļaujiet man atgriezties pie sava
koda šeit.

1239
00:56:59,910 --> 00:57:03,240
Un mēs iepriekš redzējām mājienu uz
to.

1240
00:57:03,240 --> 00:57:05,640
Mēs zinām, ka Python valodā pastāv
saraksti, un jūs varat tos 

1241
00:57:05,640 --> 00:57:08,040
izveidot, vienkārši izmantojot
kvadrātiekavas. 

1242
00:57:08,040 --> 00:57:12,945
Ko darīt, ja es mazliet vienkāršotu
kodu un vienkārši pateiktu, ja s 

1243
00:57:12,945 --> 00:57:17,850
ir šajā vērtību sarakstā — lielais
Y vai mazais y. 

1244
00:57:17,850 --> 00:57:21,090
Loģiski, ka tas viss nav tik
savādāks, bet tas ir nedaudz skaidrāks.

1245
00:57:21,090 --> 00:57:22,440
Tas ir daudz kompaktāks.

1246
00:57:22,440 --> 00:57:25,740
Tātad, ja elif s ir ar lielo N vai
mazo n, es tik un tā varu izteikt 

1247
00:57:25,740 --> 00:57:29,040
to pašu domu. 

1248
00:57:29,040 --> 00:57:32,220
Tātad šeit atkal kļūst mazliet
patīkamāk rakstīt kodu.

1249
00:57:32,220 --> 00:57:33,960
Ir mazāk sitienu pa tastatūru.

1250
00:57:33,960 --> 00:57:36,090
Jūs varat izteikties kodolīgāk.

1251
00:57:36,090 --> 00:57:40,230
Un, izmantojot atslēgvārdu in,
Python izdomās, kā meklēt visā 

1252
00:57:40,230 --> 00:57:44,370
sarakstā neatkarīgi no s vērtības. 

1253
00:57:44,370 --> 00:57:47,010
Un, ja tas to atradīs, tas
automātiski atgriezīs True.

1254
00:57:47,010 --> 00:57:48,230
Citādi tas atgriezīs False.

1255
00:57:48,230 --> 00:57:51,962
Tātad, ja es vēlreiz palaižu
agree.py un ierakstu lielo Y vai mazo y, 

1256
00:57:51,962 --> 00:57:55,695
tas joprojām darbojas. 

1257
00:57:55,695 --> 00:58:00,330
Ja vēlos pievienot papildu
funkcijas, es varu to uzlabot.

1258
00:58:00,330 --> 00:58:05,200
Nu, ko darīt, ja es vēlos atbalstīt
ne tikai lielo Y un mazo y, bet 

1259
00:58:05,200 --> 00:58:10,070
arī "Yes" vai "yes", vai gadījumā,
ja lietotājs kliedz vai kāds, 

1260
00:58:10,070 --> 00:58:14,940
kuram nepatīk CapsLock ieraksta
“YES”? Uzgaidiet mirklīti. 

1261
00:58:14,940 --> 00:58:16,020
Bet tas varētu būt dīvaini.

1262
00:58:16,020 --> 00:58:20,850
Vai mēs gribam atbalstīt šo vai to?

1263
00:58:20,850 --> 00:58:23,280
Tas ātri, kombinatoriski kļūst ļoti
nogurdinoši, ja ņemat vērā visas 

1264
00:58:23,280 --> 00:58:25,710
šīs iespējamās variācijas. 

1265
00:58:25,710 --> 00:58:29,640
Gudrākais būtu darīt kaut ko
līdzīgu šim, ja vēlaties vienkārši 

1266
00:58:29,640 --> 00:58:33,570
paciest “yes” jebkādā lielo burtu
formātā? 

1267
00:58:33,570 --> 00:58:35,370
Loģiski, kas būtu jauki?

1268
00:58:35,370 --> 00:58:37,032
Mērķauditorija: Varbūt, lai kāda
būtu ievade, jūs vienkārši pārsūtiet 

1269
00:58:37,032 --> 00:58:38,694
to uz visiem mazajiem burtiem, bet
ar lielajiem burtiem, un pēc tam 

1270
00:58:38,694 --> 00:58:40,357
atkārtojiet to? 

1271
00:58:40,357 --> 00:58:41,125
DEIVIDS MALANS: Tieši tā.

1272
00:58:41,125 --> 00:58:42,042
Super izplatīta paradigma.

1273
00:58:42,042 --> 00:58:44,539
Kāpēc gan mēs vienkārši
neizmantojam lietotāja ievades burtus ar 

1274
00:58:44,539 --> 00:58:47,036
visiem mazajiem vai lielajiem
burtiem — tam nav nozīmes, ja vien esam 

1275
00:58:47,036 --> 00:58:49,533
konsekventi — un vienkārši
nesalīdzinām ar visiem lielajiem vai 

1276
00:58:49,533 --> 00:58:52,030
mazajiem burtiem. 

1277
00:58:52,030 --> 00:58:55,760
Un pretējā gadījumā tas atbrīvos no
visām iespējamām variācijām.

1278
00:58:55,760 --> 00:58:58,510
Tagad valodā C mēs, iespējams, būtu
izdarījuši kaut ko līdzīgu šim.

1279
00:58:58,510 --> 00:59:02,365
Mēs varētu būt vienkāršojuši visu
šo sarakstu un vienkārši teikuši — 

1280
00:59:02,365 --> 00:59:06,220
pieņemsim, ka darīsim — kā būtu ar
mazajiem burtiem? 

1281
00:59:06,220 --> 00:59:10,490
Tātad, y vai yes, un mēs to tā
atstāsim.

1282
00:59:10,490 --> 00:59:12,370
Bet tagad mums ir jāpiespiež s
lietot mazos burtus.

1283
00:59:12,370 --> 00:59:15,970
Nu, C valodā mēs būtu izmantojuši C
veida bibliotēku.

1284
00:59:15,970 --> 00:59:19,660
Mēs būtu izdarījuši to.lower un
izsauktu šo funkciju, nododot to.

1285
00:59:19,660 --> 00:59:22,765
Lai gan ne īsti tāpēc, ka C tipa
gadījumā tās darbojas ar atsevišķām 

1286
00:59:22,765 --> 00:59:25,870
rakstzīmēm vai char, nevis veselām
virknēm. 

1287
00:59:25,870 --> 00:59:28,450
Mēs faktiski neredzējām funkciju,
kas varētu C valodā pārvērst visu 

1288
00:59:28,450 --> 00:59:31,030
virkni mazajos burtos. 

1289
00:59:31,030 --> 00:59:34,910
Bet Python valodā mēs gūsim labumu
arī no dažām citām funkcijām.

1290
00:59:34,910 --> 00:59:39,330
Izrādās, ka Python atbalsta tā
saukto objektorientēto programmēšanu.

1291
00:59:39,330 --> 00:59:41,830
Un CS50 mēs tai pieskarsimies tikai
virspusīgi.

1292
00:59:41,830 --> 00:59:44,290
Bet, ja apgūstat augstāka līmeņa
programmēšanas C kursu vai CS, jūs 

1293
00:59:44,290 --> 00:59:46,750
to izpētāt kā citu paradigmu. 

1294
00:59:46,750 --> 00:59:48,887
Līdz šim C valodā mēs esam
koncentrējušies uz to, ko patiešām sauc 

1295
00:59:48,887 --> 00:59:51,025
par procesuālo programmēšanu. 

1296
00:59:51,025 --> 00:59:52,210
Jūs rakstāt procedūras.

1297
00:59:52,210 --> 00:59:55,250
Jūs rakstāt funkcijas no augšas uz
leju, no kreisās uz labo.

1298
00:59:55,250 --> 00:59:57,900
Un, kad vēlaties mainīt kādu
vērtību, mums bija ieradums izmantot 

1299
00:59:57,900 --> 01:00:00,550
procedūru, tas ir - funkciju. 

1300
01:00:00,550 --> 01:00:04,075
Jūs nodotu kaut ko - piemēram,
mainīgo - funkcijai, teiksim, toupper 

1301
01:00:04,075 --> 01:00:07,600
vai tolower, un tā darītu savu
uzdevumu un atgrieztu jums vērtību. 

1302
01:00:07,600 --> 01:00:11,425
Izrādās, ka programmēšanas ziņā
būtu jaukāk, ja dažiem datu tipiem 

1303
01:00:11,425 --> 01:00:15,250
tomēr būtu iebūvēta
funkcionalitāte. 

1304
01:00:15,250 --> 01:00:17,720
Kāpēc mums šeit ir mūsu mainīgie un
visas mūsu palīgfunkcijas, 

1305
01:00:17,720 --> 01:00:20,190
piemēram, toupper un tolower šeit,
tā, ka mums pastāvīgi ir jānodod 

1306
01:00:20,190 --> 01:00:22,660
viens otram. 

1307
01:00:22,660 --> 01:00:26,390
Būtu jauki mūsu datu tipā iekļaut
kādu iebūvētu funkcionalitāti, lai 

1308
01:00:26,390 --> 01:00:30,120
jūs varētu mainīt mainīgos,
izmantojot to noklusējuma iebūvēto 

1309
01:00:30,120 --> 01:00:33,850
funkcionalitāti. 

1310
01:00:33,850 --> 01:00:39,007
Un tā, objektorientētā
programmēšana, citādi pazīstama kā OOP, ir 

1311
01:00:39,007 --> 01:00:44,165
paņēmiens, kurā noteikta veida
vērtībās, piemēram, virknē — t.s. str 

1312
01:00:44,165 --> 01:00:49,322
- ir ne tikai iebūvētas īpašības —
atribūti, tādi kā struct C 

1313
01:00:49,322 --> 01:00:54,480
valodā – jūsu datos var būt arī
iebūvētas funkcijas. 

1314
01:00:54,480 --> 01:00:57,955
Tātad, lai gan C valodā, kas nav
orientēta uz objektu, jums ir struct.

1315
01:00:57,955 --> 01:01:00,287
Un struct var saglabāt tikai datus,
piemēram, vārdu un numuru, 

1316
01:01:00,287 --> 01:01:02,620
ieviešot personu. 

1317
01:01:02,620 --> 01:01:06,775
Piemēram, valodā Python var būt ne
tikai struktūra — citādi pazīstama 

1318
01:01:06,775 --> 01:01:10,930
kā klase - kas glabā vārdu un
numuru. 

1319
01:01:10,930 --> 01:01:13,790
Varat iestatīt, lai funkcija
izsauktu šo personu vai nosūtītu tai 

1320
01:01:13,790 --> 01:01:16,650
e-pasta ziņojumu, vai faktiskos
darbības vārdus vai darbības, kas 

1321
01:01:16,650 --> 01:01:19,510
saistītas ar šo datu daļu. 

1322
01:01:19,510 --> 01:01:22,037
Tagad virkņu kontekstā izrādās, ka
virknēm ir daudz noderīgas 

1323
01:01:22,037 --> 01:01:24,565
funkcionalitātes. 

1324
01:01:24,565 --> 01:01:28,461
Un patiesībā šajā vietrādī URL, kas
atrodas vietnē docs.python.org, 

1325
01:01:28,461 --> 01:01:32,357
kas ir oficiālā Python
dokumentācija, jūs redzēsiet visu metožu 

1326
01:01:32,357 --> 01:01:36,253
sarakstu, tas ir - funkcijas , kas
nāk ar virknēm, kuras varat 

1327
01:01:36,253 --> 01:01:40,150
izmantot, lai mainītu to vērtības. 

1328
01:01:40,150 --> 01:01:42,440
Un es ar to domāju sekojošo.

1329
01:01:42,440 --> 01:01:45,301
Ja mēs izejam cauri dokumentācijai,
paskatamies apkārt, izrādās, ka 

1330
01:01:45,301 --> 01:01:48,163
virknēm ir funkcija, ko sauc par
lower. 

1331
01:01:48,163 --> 01:01:51,506
Un, ja vēlaties izmantot šo
funkciju, jums vienkārši ir jāizmanto 

1332
01:01:51,506 --> 01:01:54,850
nedaudz atšķirīga sintakse nekā
valodā C. 

1333
01:01:50,080 --> 01:01:55,615
Jūs neizpildiet tolower un
neizpildiet, kā es tikko izdarīju, lower, 

1334
01:01:55,615 --> 01:02:01,150
jo šī funkcija ir iebūvēta pašā s. 

1335
01:02:01,150 --> 01:02:05,616
Un tāpat kā C valodā, kad vēlaties
iekļūt mainīgajā, piemēram, 

1336
01:02:05,616 --> 01:02:10,082
struktūrā, un piekļūt tajā
esošajiem datiem, piemēram, vārdam vai 

1337
01:02:10,082 --> 01:02:14,548
numuram, ja datu tipos ir arī
iebūvētas funkcijas — t.s. metodes; 

1338
01:02:14,548 --> 01:02:19,014
metode ir tikai funkcija, kas ir
iebūvēta datos — šajā gadījumā varat 

1339
01:02:19,014 --> 01:02:23,480
norādīt s, punkts, lower atvērt
iekavas, aizvērt iekavas. 

1340
01:02:23,480 --> 01:02:25,480
Un es to varu izdarīt arī šeit.

1341
01:02:25,480 --> 01:02:30,467
Ja ir s.lower, pēdiņās “n” vai
“no”, viss, es varu piespiest visu šo 

1342
01:02:30,467 --> 01:02:35,455
rakstīt ar mazajiem burtiem. 

1343
01:02:35,455 --> 01:02:38,940
Tātad vienīgā atšķirība tagad ir
objektorientēta programmēšana, tā 

1344
01:02:38,940 --> 01:02:42,425
vietā, lai pastāvīgi nodotu vērtību
funkcijai, jūs vienkārši 

1345
01:02:42,425 --> 01:02:45,910
piekļūstat funkcijai, kas atrodas
vērtības iekšpusē. 

1346
01:02:45,910 --> 01:02:48,928
Tas darbojas tikai tāpēc, ka pati
valoda ir definēta.

1347
01:02:48,928 --> 01:02:52,211
Un vienīgais veids, kā uzzināt, vai
šīs funkcijas pastāv, ir 

1348
01:02:52,211 --> 01:02:55,495
dokumentācija — klase, grāmata,
vietne vai tamlīdzīgi. 

1349
01:02:55,495 --> 01:03:00,490
Vai jums ir jautājumi par šo
tehniku?

1350
01:03:00,490 --> 01:03:01,070
Labi.

1351
01:03:01,070 --> 01:03:02,513
Es apgalvoju, ka tas ir pareizi.

1352
01:03:02,513 --> 01:03:05,084
Tagad, lai gan jūs nekad iepriekš
neesat programmējuši Python valodā, 

1353
01:03:05,084 --> 01:03:07,655
lielākā daļa no jums, tā nav īpaši
labi izstrādāta. 

1354
01:03:07,655 --> 01:03:12,140
Tagad 3. un 5. rindā ir neliela
neefektivitāte.

1355
01:03:12,140 --> 01:03:18,150
Kas ir stulbs tajā, kā es izmantoju
lower, kā jūs domājat?

1356
01:03:18,150 --> 01:03:18,720
Jā?

1357
01:03:18,720 --> 01:03:21,975
Jūs vienkārši gribat citu [?
mainīgo. ?]

1358
01:03:21,975 --> 01:03:22,440
DEIVIDS MALANS: Jā.

1359
01:03:22,440 --> 01:03:24,709
Ja jūs plānojat izmantot vienu un
to pašu funkciju divas reizes un 

1360
01:03:24,709 --> 01:03:26,978
uzdot vienu un to pašu jautājumu,
gaidot to pašu atbildi, kāpēc jūs 

1361
01:03:26,978 --> 01:03:29,248
divreiz izsaucat vienu un to pašu
funkciju? 

1362
01:03:29,248 --> 01:03:31,415
Varbūt mums vajadzētu vienkārši
saglabāt rezultātu mainīgajā.

1363
01:03:31,415 --> 01:03:33,030
Tāpēc mēs to varētu izdarīt dažādos
veidos.

1364
01:03:33,030 --> 01:03:35,535
Mēs, piemēram, varētu uzkāpt šeit
un izveidot citu mainīgo ar 

1365
01:03:35,535 --> 01:03:38,040
nosaukumu t un iestatīt, ka tas ir
vienāds ar s.lower. 

1366
01:03:38,040 --> 01:03:41,330
Un tad mēs varētu vienkārši mainīt
to uz t, šeit.

1367
01:03:41,330 --> 01:03:45,480
Bet godīgi, es nedomāju, ka mums
tehniski ir vajadzīgs cits mainīgais.

1368
01:03:45,480 --> 01:03:47,410
Es varētu izdarīt kaut ko līdzīgu
šim.

1369
01:03:47,410 --> 01:03:52,360
Mainīsim s vērtību, lai tā būtu tā
mazo burtu versija.

1370
01:03:52,360 --> 01:03:54,955
Un tāpēc tagad es varu gluži
vienkārši atsaukties uz s atkal un atkal 

1371
01:03:54,955 --> 01:03:57,550
šādi, atkārtoti izmantojot to pašu
vērtību. 

1372
01:03:57,550 --> 01:03:59,465
Tagad, lai pārliecinātos, es tikko
pazaudēju lietotāja sākotnējo 

1373
01:03:59,465 --> 01:04:01,380
ievadi. 

1374
01:04:01,380 --> 01:04:03,405
Un, ja man tas rūp — ja tie bija
rakstīti ar lielajiem burtiem, man 

1375
01:04:03,405 --> 01:04:05,430
vairs nav ne jausmas. 

1376
01:04:05,430 --> 01:04:08,070
Tāpēc, iespējams, es vēlos izmantot
atsevišķu mainīgo.

1377
01:04:08,070 --> 01:04:11,855
Taču arī šeit ir jāņem vērā tas, ka
Python virknes tehniski sauc par 

1378
01:04:11,855 --> 01:04:15,640
nemainīgajām, tas ir - tās nevar
mainīt. 

1379
01:04:15,640 --> 01:04:19,830
Tā tas nebija C valodā.

1380
01:04:15,640 --> 01:04:18,620
Kad mēs bijām iedevuši jums masīvus
otrajā nedēļā vai atmiņu 

1381
01:04:18,620 --> 01:04:21,600
ceturtajā nedēļā, jūs varējāt
baudīt virkni un mainīt jebkuru no 

1382
01:04:21,600 --> 01:04:24,580
vēlamajām rakstzīmēm — lielos,
mazos burtus, mainīt tos, saīsināt un 

1383
01:04:24,580 --> 01:04:27,560
tā tālāk. 

1384
01:04:27,560 --> 01:04:30,625
Bet šajā gadījumā tiek atgriezta s
kopija, kas ir spiesta lietot 

1385
01:04:30,625 --> 01:04:33,690
mazos burtus. 

1386
01:04:33,690 --> 01:04:38,700
Tas nemaina sākotnējo virkni, tas
ir - baitus datora atmiņā.

1387
01:04:38,700 --> 01:04:43,703
Piešķirot to atpakaļ s, jūs būtībā
aizmirstat par veco s versiju.

1388
01:04:43,703 --> 01:04:47,385
Taču, tā kā Python valoda veic
atmiņas pārvaldību jūsu vietā — te nav 

1389
01:04:47,385 --> 01:04:51,067
malloc, te nav free — Python
automātiski atbrīvo sākotnējos baitus, 

1390
01:04:51,067 --> 01:04:54,750
piemēram, YES, un nodod tos atpakaļ
operētājsistēmai jūsu vietā. 

1391
01:04:54,750 --> 01:04:55,340
Labi.

1392
01:04:55,340 --> 01:04:59,640
Vai jums ir jautājumi par šo
tehniku?

1393
01:04:59,640 --> 01:05:02,310
Jautājumi par šo?

1394
01:05:02,310 --> 01:05:05,910
Kopumā es uzsvēršu — Python
dokumentācija kļūs par jūsu draugu, jo 

1395
01:05:05,910 --> 01:05:09,510
klasē mēs virspusīgi pieskaramies
tikai dažām no šīm lietām. 

1396
01:05:09,510 --> 01:05:13,822
Bet, piemēram, vietnē
docs.python.org ir atsauce uz visām iebūvētām 

1397
01:05:13,822 --> 01:05:18,135
funkcijām, kas nāk ar valodu, kā
arī, piemēram, tām, kurām ir virkne. 

1398
01:05:18,135 --> 01:05:19,620
Labi.

1399
01:05:19,620 --> 01:05:23,325
Pirms aizejam pārtraukumā,
paturpināsim un izveidosim kaut ko 

1400
01:05:23,325 --> 01:05:27,030
pazīstamu, pamatojoties uz mūsu
nedēļām šeit - valodā C. 

1401
01:05:23,205 --> 01:05:26,947
Ļaujiet man ierosināt pārskatīt šos
piemērus, kas ir saistīti ar 

1402
01:05:26,947 --> 01:05:30,690
dažiem ņaudieniem. 

1403
01:05:30,690 --> 01:05:34,446
Tā, piemēram, kad mūsu kaķis C
valodā ņaudēja pirmajā nedēļā un pēc 

1404
01:05:34,446 --> 01:05:38,203
tam otrajā, mēs izdarījām kaut ko,
kas sākumā bija nedaudz muļķīgi - 

1405
01:05:38,203 --> 01:05:41,960
izveidojām datni, kā es to izdarīšu
šeit. Šoreiz to sauc par meow.py. 

1406
01:05:41,960 --> 01:05:44,575
Un, ja es gribu, lai kaķis ņaud
trīs reizes, es varētu to palaist 

1407
01:05:44,575 --> 01:05:47,190
vienu reizi, piemēram, šādi,
neliels kopēt-ielīmēt. 

1408
01:05:47,190 --> 01:05:50,580
Un tagad, python no meow.py, un es
esmu pabeidzis.

1409
01:05:50,580 --> 01:05:52,635
Tagad mēs esam apskatījuši šo
piemēru vismaz divas reizes, tagad 

1410
01:05:52,635 --> 01:05:54,690
Scratch un C valodā. 

1411
01:05:54,690 --> 01:05:57,385
Tas ir pareizi, es apgalvošu, bet
kas, acīmredzot, ir slikti 

1412
01:05:57,385 --> 01:06:00,080
izstrādāts? 

1413
01:06:00,080 --> 01:06:01,655
Kas te par vainu?

1414
01:06:01,655 --> 01:06:02,212
Jā?

1415
01:06:02,212 --> 01:06:03,670
Mērķauditorija: Tam vajadzētu būt
tikai cilpai.

1416
01:06:03,670 --> 01:06:04,990
DEIVIDS MALANS: Tam vajadzētu būt
tikai cilpai, vai ne?

1417
01:06:04,990 --> 01:06:05,990
Kāpēc rakstīt trīs reizes?

1418
01:06:05,990 --> 01:06:08,715
Burtiski kopēšana un ielīmēšana
gandrīz vienmēr ir slikta lieta, 

1419
01:06:08,715 --> 01:06:11,440
izņemot C, kad jums ir funkciju
prototipi, kas jums ir jāaizņemas. 

1420
01:06:11,440 --> 01:06:13,232
Bet šajā gadījumā tas ir vienkārši
neefektīvi.

1421
01:06:13,232 --> 01:06:15,652
Tātad, ko mēs varētu uzlabot šeit,
Python valodā?

1422
01:06:15,652 --> 01:06:17,131
Nu, Python valodā mēs, iespējams,
varētu to mainīt pāris dažādos 

1423
01:06:17,131 --> 01:06:18,610
veidos. 

1424
01:06:18,610 --> 01:06:21,160
Mēs varētu aizņemties kādu no
sintakses, ko iepriekš piedāvājām 

1425
01:06:21,160 --> 01:06:23,710
slaidu formā, piemēram: dodiet man
mainīgo ar nosaukumu i. 

1426
01:06:23,710 --> 01:06:26,080
Iestatiet to uz 0, bez semikola.

1427
01:06:26,080 --> 01:06:28,580
Kamēr i ir mazāks par 3 — ja es
vēlos to darīt trīs reizes - es varu 

1428
01:06:28,580 --> 01:06:31,080
iet uz priekšu un izdrukāt “meow”.
Un tad es varu izpildīt i plus ir 

1429
01:06:31,080 --> 01:06:33,580
vienāds ar 1. 

1430
01:06:33,580 --> 01:06:35,080
Un es domāju, ka tas visu
atrisinātu.

1431
01:06:35,080 --> 01:06:38,650
Python no meow.py, un mēs jau esam
atpakaļ ierindā.

1432
01:06:38,650 --> 01:06:41,515
Nu, ja es vēlētos to mainīt uz for
cilpu, labi, Python valodā, tas 

1433
01:06:41,515 --> 01:06:44,380
būtu nedaudz skaidrāk, taču šī
nebūtu labākā pieeja. 

1434
01:06:44,380 --> 01:06:48,445
Tātad, ja i ir 0, 1, 2, es varētu
vienkārši izdrukāt "meow", šādā 

1435
01:06:48,445 --> 01:06:52,510
veidā. 

1436
01:06:52,510 --> 01:06:54,250
Un tas arī padarītu darbu.

1437
01:06:54,250 --> 01:06:57,610
Bet, atgriežoties pie mūsu
diskusijas iepriekš, tas diezgan ātri 

1438
01:06:57,610 --> 01:07:00,970
kļūtu muļķīgi, ja jums būtu
jāturpina uzskaitīt visas šīs vērtības. 

1439
01:07:00,970 --> 01:07:03,880
Ko mēs tā vietā ieviesām?

1440
01:07:03,880 --> 01:07:04,940
Diapazona funkciju.

1441
01:07:04,940 --> 01:07:05,440
Tieši tā.

1442
01:07:05,440 --> 01:07:08,037
Tā man daudz efektīvāk atdod tikai
tās vērtības, kuras es vēlos, 

1443
01:07:08,037 --> 01:07:10,635
patiešām, pa vienai. 

1444
01:07:10,635 --> 01:07:12,690
Tātad, pat ja es to palaižu trešo
vai ceturto reizi, mums ir tāds 

1445
01:07:12,690 --> 01:07:14,745
pats rezultāts. 

1446
01:07:14,745 --> 01:07:18,220
Bet tagad pāriesim tur, uz kurieni
mēs savulaik ar to devāmies.

1447
01:07:18,220 --> 01:07:20,650
Kā mēs varam sākt to modulēt?

1448
01:07:20,650 --> 01:07:24,100
Es apgalvoju, ka būtu jauki, ja MIT
mums būtu devusii ņau funkciju.

1449
01:07:24,100 --> 01:07:27,370
Vai nebūtu jauki, ja Python mums
būtu devusi ņau funkciju?

1450
01:07:27,370 --> 01:07:28,975
Varbūt Python valodā tas ir mazāk
neatvairāmi, bet kā es varu 

1451
01:07:28,975 --> 01:07:30,580
izveidot savu funkciju? 

1452
01:07:30,580 --> 01:07:33,813
Es to darīju īsi ar pareizrakstības
pārbaudītāju iepriekš, bet 

1453
01:07:33,813 --> 01:07:37,046
ļaujiet man iet uz priekšu un
ierosināt, ka mēs tagad varētu ieviest 

1454
01:07:37,046 --> 01:07:40,280
mūsu pašu versiju Python valodā, kā
norādīts tālāk. 

1455
01:07:40,280 --> 01:07:44,050
Ļaujiet man sākt no jauna un
izmantot atslēgvārdu def.

1456
01:07:44,050 --> 01:07:47,860
Tātad tas nepastāvēja C valodā.

1457
01:07:44,050 --> 01:07:48,850
Jums bija atgriešanas vērtība,
funkcijas nosaukums, argumenti.

1458
01:07:48,850 --> 01:07:52,120
Valodā Python jūs burtiski sakāt
def, lai definētu funkciju.

1459
01:07:52,120 --> 01:07:54,757
Jūs piešķirat tai nosaukumu,
piemēram, - ņau.

1460
01:07:54,757 --> 01:07:56,298
Un tagad es iešu uz priekšu un,
izmantojot šo funkciju, vienkārši 

1461
01:07:56,298 --> 01:07:57,840
izdrukāšu ņau. 

1462
01:07:57,840 --> 01:08:01,460
Un tas ļauj man to mainīt uz jebko
citu, ko es vēlos nākotnē.

1463
01:08:01,460 --> 01:08:03,400
Bet pagaidām tā ir abstrakcija.

1464
01:08:03,400 --> 01:08:05,895
Un patiesībā es varu to pabīdīt no
acīm prom, no sirds ārā — 

1465
01:08:05,895 --> 01:08:08,391
vienkārši vairākas reizes nospiežot
ievadīšanas taustiņu Enter, lai 

1466
01:08:08,391 --> 01:08:10,886
izliktos, ka tagad tas pastāv, bet
man ir vienalga, kā tas tiek 

1467
01:08:10,886 --> 01:08:13,382
īstenots. 

1468
01:08:13,382 --> 01:08:15,340
Un šeit, tagad, es varu darīt kaut
ko līdzīgu šim.

1469
01:08:15,340 --> 01:08:17,965
Attiecībā uz i diapazonā 3, ļaujiet
man turpināt un vairs nedrukāt 

1470
01:08:17,965 --> 01:08:20,590
“meow”;. 

1471
01:08:20,590 --> 01:08:25,359
Ļaujiet man vienkārši izsaukt ņau
un vēl vairāk nostiprināt savu kodu.

1472
01:08:25,359 --> 01:08:25,960
Paskatīsimies.

1473
01:08:25,960 --> 01:08:26,859
Python no meow.py.

1474
01:08:26,859 --> 01:08:31,240
Es domāju, ka šī būs pirmā reize,
kad tas nedarbosies pareizi.

1475
01:08:31,240 --> 01:08:32,680
Labi.

1476
01:08:32,680 --> 01:08:36,310
Diemžēl šeit ir mūsu pirmā Python
kļūda.

1477
01:08:36,310 --> 01:08:37,569
Un paskatīsimies.

1478
01:08:37,569 --> 01:08:40,300
Sintakse atšķirsies no C valodas
vai Clangs izvades.

1479
01:08:40,300 --> 01:08:41,920
Izsekošana (traceback) šeit ir
mākslas termins.

1480
01:08:41,920 --> 01:08:44,740
Tas ir kā visu tikko izpildīto koda
rindu vai, patiesībā, izsaukto 

1481
01:08:44,740 --> 01:08:47,560
funkciju izsekošana. 

1482
01:08:47,560 --> 01:08:49,090
Datnes nosaukums ir neinteresants.

1483
01:08:49,090 --> 01:08:51,490
Konkrēti, šī ir mana koda telpa,
taču šeit svarīgs ir datnes 

1484
01:08:51,490 --> 01:08:53,890
nosaukums — meow.py. 

1485
01:08:53,890 --> 01:08:56,680
Mūsu 2. rindiņa ir problēma — labi,
es netiku ļoti tālu, pirms 

1486
01:08:56,680 --> 01:08:59,470
izgāzos, un tad te ir nosaukuma
kļūda. 

1487
01:08:59,470 --> 01:09:02,410
Un jūs redzēsiet, ka valodā Python
parasti ir šie atslēgvārdi ar 

1488
01:09:02,410 --> 01:09:05,350
lielo burtu, kas norāda uz
problēmu. 

1489
01:09:05,350 --> 01:09:09,260
Tas ir kaut kas saistīts ar mainīgo
nosaukumiem.

1490
01:09:05,350 --> 01:09:09,760
“meow” nav definēts. Labi.

1491
01:09:09,760 --> 01:09:11,635
Jūs programmējat Python pirmo
reizi.

1492
01:09:11,635 --> 01:09:12,399
Jūs salaidāt grīstē.

1493
01:09:12,399 --> 01:09:14,560
Jūs sekojat kādai tiešsaistes
apmācībai.

1494
01:09:14,560 --> 01:09:16,149
Jūs redzat šo.

1495
01:09:16,149 --> 01:09:18,010
Prātojat.

1496
01:09:18,010 --> 01:09:20,680
Kāpēc “meow” nav definēta?

1497
01:09:20,680 --> 01:09:24,779
Ko mēs varam secināt par Python?

1498
01:09:24,779 --> 01:09:27,240
Kā loģiski novērst problēmas?

1499
01:09:27,240 --> 01:09:29,147
Mērķauditorija: [Nesadzirdami]

1500
01:09:29,147 --> 01:09:29,939
DEIVIDS MALANS: Varbūt.

1501
01:09:29,939 --> 01:09:32,520
Vai tas ir tāpēc, ka “meow” tiek
definēta vēlāk?

1502
01:09:32,520 --> 01:09:34,787
Lai arī cik gudrs šķiet Python
salīdzinājumā ar C, tām ir dažas 

1503
01:09:34,787 --> 01:09:37,055
līdzīgas dizaina īpašības. 

1504
01:09:37,055 --> 01:09:37,920
Tāpēc izmēģināsim šo.

1505
01:09:37,920 --> 01:09:39,824
Tāpēc ļaujiet man atritināt atpakaļ
līdz tai vietai, kur to pārcēlu 

1506
01:09:39,824 --> 01:09:41,729
iepriekš. 

1507
01:09:41,729 --> 01:09:44,279
Ļaujiet man tikt no tā vaļā… - tur
lejā.

1508
01:09:44,279 --> 01:09:46,410
Es to nokopēšu savā starpliktuvē.

1509
01:09:46,410 --> 01:09:48,180
Un ļaujiet man vienkārši kaut ko
uzlauzt.

1510
01:09:48,180 --> 01:09:49,963
Ļaujiet man to vienkārši ievietot
šeit.

1511
01:09:49,963 --> 01:09:51,130
Un redzēsim, vai tas darbosies.

1512
01:09:51,130 --> 01:09:54,120
Tagad ļaujiet man notīrīt savu
termināli, palaist python no meow.py.

1513
01:09:54,120 --> 01:09:55,110
Labi.

1514
01:09:55,110 --> 01:09:56,198
Mēs esam atkal ierindā.

1515
01:09:56,198 --> 01:09:57,990
Tātad intuīcija patiešām
nostrādāja.

1516
01:09:57,990 --> 01:10:00,180
Laba atkļūdošanas tehnika, tikai
pārdomājiet to.

1517
01:10:00,180 --> 01:10:02,610
Tagad tas ir pretrunā ar to, ko es
apgalvoju pirmajā nedēļā, proti, 

1518
01:10:02,610 --> 01:10:05,040
ka jūsu programmas galvenajai daļai
ideālā gadījumā vajadzētu būt 

1519
01:10:05,040 --> 01:10:07,470
tikai datnes augšdaļā. 

1520
01:10:07,470 --> 01:10:08,580
Nelieciet man to meklēt.

1521
01:10:08,580 --> 01:10:11,871
Tā nav liela problēma ar četrrindu
programmu, taču, ja jums ir 40 vai 

1522
01:10:11,871 --> 01:10:15,163
400 rindiņas, jūs nevēlaties, lai
jūsu programmas sulīgā daļa būtu 

1523
01:10:15,163 --> 01:10:18,455
šeit apakšā un visas šīs funkcijas
būtu augšā. 

1524
01:10:18,455 --> 01:10:22,085
Tāpēc varbūt būtu jauki, ja mums
patiešām būtu galvenā funkcija.

1525
01:10:22,085 --> 01:10:24,772
Un patiesībā izrādās, ka Python
valodā vienošanās definē galveno 

1526
01:10:24,772 --> 01:10:27,460
funkciju. 

1527
01:10:27,460 --> 01:10:29,090
Tā nav īpaša funkcija, kas tiek
automātiski izsaukta kā, piemēram, 

1528
01:10:29,090 --> 01:10:30,720
valodā C. 

1529
01:10:30,720 --> 01:10:32,340
Bet cilvēki saprata, ziniet ko?

1530
01:10:32,340 --> 01:10:34,120
Tā bija diezgan noderīga funkcija.

1531
01:10:34,120 --> 01:10:36,540
Ļaujiet man definēt funkciju, ko
sauc par galveno.

1532
01:10:36,540 --> 01:10:39,000
Ļaujiet man ievilkt šīs rindas zem
tās.

1533
01:10:39,000 --> 01:10:41,145
Ļaujiet man praktizēt to, ko
sludinu, kas ir: rakstiet galveno kodu 

1534
01:10:41,145 --> 01:10:43,290
datnes augšdaļā.. 

1535
01:10:43,290 --> 01:10:45,510
Un, brīnišķīgā veidā, Python valodā
tagad jums nav nepieciešami 

1536
01:10:45,510 --> 01:10:47,730
prototipi. 

1537
01:10:47,730 --> 01:10:51,315
Nav nevienas tādas uzlauztas
funkcijas atgriešanas veida, nosaukuma 

1538
01:10:51,315 --> 01:10:54,900
un argumentu kopēšanas un
ielīmēšanas, kā tas bija vajadzīgs valodā 

1539
01:10:54,900 --> 01:10:58,485
C. 

1540
01:10:52,462 --> 01:10:58,485
Tas tagad ir kārtībā, izņemot vienu
nelielu detaļu.

1541
01:10:58,485 --> 01:11:01,290
Ļaujiet man iet uz priekšu un
palaist python no meow.py.

1542
01:11:01,290 --> 01:11:05,940
izmantojot galveno funkciju [VAID].

1543
01:11:05,940 --> 01:11:08,170
Bet tagad - nekas nav noticis.

1544
01:11:08,170 --> 01:11:08,670
Labi.

1545
01:11:08,670 --> 01:11:13,262
Pat ja jūs nekad iepriekš neesat
programmējuši Python valodā, kas 

1546
01:11:13,262 --> 01:11:17,855
varētu izskaidrot šo darbību un kā
to novērst? 

1547
01:11:17,855 --> 01:11:20,822
Atkal, kad atrodaties reālajā
pasaulē un mācāties jaunu valodu, jums 

1548
01:11:20,822 --> 01:11:23,790
ir tikai deduktīvā loģika
atkļūdošanai. 

1549
01:11:23,790 --> 01:11:24,300
Jā?

1550
01:11:24,300 --> 01:11:28,656
lai gan mēs [Nesadzirdami]..

1551
01:11:31,708 --> 01:11:32,500
DEIVIDS MALANS: Pareizi.

1552
01:11:32,500 --> 01:11:34,075
Tātad risinājums, lai būtu skaidrs,
C valodā bija tāds, ka mums šeit 

1553
01:11:34,075 --> 01:11:35,650
bija jāievieto prototips. 

1554
01:11:35,650 --> 01:11:36,790
Pretējā gadījumā mēs saņemtu kļūdas
ziņojumu.

1555
01:11:36,790 --> 01:11:39,123
Šajā gadījumā es faktiski nesaņemu
kļūdas ziņojumu.

1556
01:11:39,123 --> 01:11:42,610
Patiešām, es apgalvošu, ka Python
valodā prototipi jums nav vajadzīgi.

1557
01:11:42,610 --> 01:11:46,910
Vienkārši nav nepieciešami, jo tas
bija kaitinoši, ja nekas cits.

1558
01:11:46,910 --> 01:11:48,820
Bet kas vēl varētu izskaidrot?

1559
01:11:48,820 --> 01:11:49,570
Jā, aizmugurē?

1560
01:11:49,570 --> 01:11:51,030
Mērķauditorija: [Nesadzirdami]

1561
01:11:51,030 --> 01:11:51,780
DEIVIDS MALANS: Jā.

1562
01:11:51,780 --> 01:11:53,880
Varbūt jums ir jāizsauc pati
galvenā funkcija.

1563
01:11:53,880 --> 01:11:56,460
Ja galvenajai funkcijai Python
valodā nav kāda īpaša statusa, varbūt 

1564
01:11:56,460 --> 01:11:59,040
nepietiek ar to, ka tā vienkārši
eksistē. 

1565
01:11:59,040 --> 01:12:01,810
Un patiešām, ja vēlaties izsaukt
galveno funkciju, jaunā vienošanās 

1566
01:12:01,810 --> 01:12:04,580
faktiski būs — kā jūsu programmas
pēdējā rinda, parasti — burtiski 

1567
01:12:04,580 --> 01:12:07,350
izsaukt galveno funkciju. 

1568
01:12:07,350 --> 01:12:10,950
Tas izskatās nedaudz muļķīgi, taču
viņi pieņēma dizaina lēmumu.

1569
01:12:10,950 --> 01:12:13,200
Un tagad mēs to apstrādājam šādi.

1570
01:12:13,200 --> 01:12:14,610
Python no meow.py.

1571
01:12:14,610 --> 01:12:16,890
Tagad mēs esam atpakaļ ierindā.

1572
01:12:16,890 --> 01:12:19,560
Bet tagad, loģiski, kāpēc tas
darbojas tā, kā tas darbojas?

1573
01:12:19,560 --> 01:12:22,260
Šajā gadījumā — no augšas uz leju —
1. rindiņa liek Python definēt 

1574
01:12:22,260 --> 01:12:24,960
funkciju, ko sauc par galveno, un
pēc tam definēt to šādi, 2. un 

1575
01:12:24,960 --> 01:12:27,660
3. rindiņa. 

1576
01:12:27,660 --> 01:12:29,610
Bet tā vēl nav galvenā funkcija.

1577
01:12:29,610 --> 01:12:32,595
6. rindiņa norāda Python, kā
definēt funkciju, ko sauc par meow, taču 

1578
01:12:32,595 --> 01:12:35,580
tā vēl neizsauc šīs rindas. 

1579
01:12:35,580 --> 01:12:38,730
Tagad 10. rindā jūs sakāt Python:
izsauc galveno funkciju.

1580
01:12:38,730 --> 01:12:42,060
Un tajā brīdī Python ir apmācīta,
ja vēlaties, zināt, kas ir galvenā 

1581
01:12:42,060 --> 01:12:45,390
funkcija 1. rindā, lai zinātu, kas
ir meow 6. rindā. 

1582
01:12:45,390 --> 01:12:48,270
Tagad ir pilnīgi ok, ja galvenā ir
augstāk par meow, jo jūs vēl 

1583
01:12:48,270 --> 01:12:51,150
neesat tās izsaukuši. 

1584
01:12:51,150 --> 01:12:54,340
Jūs definējāt, definējāt un pēc tam
izsaucāt.

1585
01:12:54,340 --> 01:12:56,380
Un tāda ir šī loģika.

1586
01:12:56,380 --> 01:13:01,250
Vai jums ir jautājumi par šīs
tehnikas struktūru?

1587
01:13:01,250 --> 01:13:03,000
Tagad izpildīsim vēl vienu.

1588
01:13:03,000 --> 01:13:06,970
Atcerieties, ka pēdējā lieta, ko
mēs darījām valodās Scratch un C, 

1589
01:13:06,970 --> 01:13:10,940
faktiski bija šo pašu funkciju
parametrizēšana. 

1590
01:13:10,940 --> 01:13:12,505
Tātad pieņemsim, ka nevēlaties, lai
galvenā funkcija būtu atbildīga 

1591
01:13:12,505 --> 01:13:14,070
par cilpu šeit. 

1592
01:13:14,070 --> 01:13:16,365
Tā vietā jūs vēlaties, ļoti
vienkārši, izdarīt kaut ko, piemēram, kā 

1593
01:13:16,365 --> 01:13:18,660
“meow” trīs reizes un beigt ar to. 

1594
01:13:18,660 --> 01:13:21,427
Nu, Python valodā, tas pēc būtības
būs līdzīgi kā valodā C.

1595
01:13:21,427 --> 01:13:23,760
Taču mums nav jāturpina pieminēt
datu tipi.

1596
01:13:23,760 --> 01:13:27,276
Ja vēlaties, lai "meow" pieņemtu
kādu argumentu, piemēram, skaitli n, 

1597
01:13:27,276 --> 01:13:30,792
kā šī argumenta nosaukumu varat
norādīt n. 

1598
01:13:30,792 --> 01:13:33,250
Vai arī varat to nosaukt kā citādi,
protams, kā vēlaties.

1599
01:13:33,250 --> 01:13:35,700
Jums nav jānorāda int vai kaut kas
cits.

1600
01:13:35,700 --> 01:13:39,330
Savā kodā tagad, meow iekšpusē,
varat darīt kaut ko līdzīgu, 

1601
01:13:39,330 --> 01:13:42,960
piemēram, i in, teiksim — es
noteikti tagad nevaru to izdarīt, jo tas 

1602
01:13:42,960 --> 01:13:46,590
būtu dīvaini sākt sarakstu un beigt
to ar n. 

1603
01:13:46,590 --> 01:13:49,360
Tātad, ja es varu atgriezties šeit,
kāds ir risinājums?

1604
01:13:49,360 --> 01:13:51,270
Kā es varu kaut ko darīt n reizes?

1605
01:13:51,270 --> 01:13:52,410
Mērķauditorija: [Nesadzirdami]

1606
01:13:52,410 --> 01:13:53,160
DEIVIDS MALANS: Jā.

1607
01:13:53,160 --> 01:13:54,340
Izmantojot diapazonu.

1608
01:13:54,340 --> 01:13:58,140
Tātad diapazons ir jauks, jo tagad
varu nodot šo mainīgo n.

1609
01:13:58,140 --> 01:13:59,940
Un tagad es varu ņaudēt - ak.

1610
01:13:59,940 --> 01:14:02,880
Tagad es varu izdrukāt, pēdiņās,
meow. Tātad tas ir gandrīz tāpat kā 

1611
01:14:02,880 --> 01:14:05,820
Scratch, gandrīz tāpat kā C valodā.


1612
01:14:05,820 --> 01:14:06,903
Bet tas ir nedaudz vienkāršāk.

1613
01:14:06,903 --> 01:14:13,110
Un, ja es tagad palaistu meow.py,
man būs iespēja to izdarīt arī šeit.

1614
01:14:13,110 --> 01:14:13,770
Labi.

1615
01:14:13,770 --> 01:14:16,590
Jautājumi par kādu no šiem
tematiem?

1616
01:14:16,590 --> 01:14:19,800
Šobrīd mēs ejam cauri pirmajai
nedēļai.

1617
01:14:19,800 --> 01:14:22,840
Mēs īslaicīgi pakāpināsim lietas,
lai aplūkotu ne tikai dažus no šiem 

1618
01:14:22,840 --> 01:14:25,880
pamatiem, bet arī citas funkcijas,
piemēram, ar sejas atpazīšanu ar 

1619
01:14:25,880 --> 01:14:28,920
pareizrakstības programmu vai
tamlīdzīgi. 

1620
01:14:28,920 --> 01:14:32,670
Tā kā mūsu šeit ir daudz, mums
vestibilā ir milzīgs daudzums konfekšu.

1621
01:14:32,670 --> 01:14:34,440
Kāpēc gan mums nepaņemt 10 minūšu
pārtraukumu?

1622
01:14:34,440 --> 01:14:36,517
Un, kad atgriezīsimies, mēs darīsim
vēl brīnišķīgākas, jaudīgākas 

1623
01:14:36,517 --> 01:14:38,595
lietas ar Python 10. versiju. 

1624
01:14:38,595 --> 01:14:40,020
Labi.

1625
01:14:40,020 --> 01:14:41,730
Tātad esam atpakaļ.

1626
01:14:41,730 --> 01:14:44,340
Viens no mūsu mērķiem tagad ir
ieviest vēl dažus blokus, lai mēs 

1627
01:14:44,340 --> 01:14:46,950
beigās varētu atrisināt
interesantākas problēmas, līdzīgi tām, ar 

1628
01:14:46,950 --> 01:14:49,560
kurām mēs sākām. 

1629
01:14:49,560 --> 01:14:51,615
Jūs atceraties, ka pirms dažām
nedēļām mēs spēlējām ar šo 

1630
01:14:51,615 --> 01:14:53,670
divdimensiju Super Mario pasauli? 

1631
01:14:53,670 --> 01:14:55,525
Un mēs mēģinājām izdrukāt vertikālu
kolonnu no trīs vai vairāk 

1632
01:14:55,525 --> 01:14:57,380
ķieģeļiem. 

1633
01:14:57,380 --> 01:15:00,925
Ļaujiet man ieteikt izmantot to kā
iespēju, lai tagad arī izmantotu 

1634
01:15:00,925 --> 01:15:04,470
dažas no Python noderīgākām un
lietotājam draudzīgākām funkcijām. 

1635
01:15:04,470 --> 01:15:07,680
Tāpēc ļaujiet man iekodēt datni ar
nosaukumu mario.py, un tad 

1636
01:15:07,680 --> 01:15:10,890
izdrukāsim šīs vertikālās kolonnas
ekvivalentu. 

1637
01:15:10,890 --> 01:15:12,690
Tātad tā augstums ir 3.

1638
01:15:12,690 --> 01:15:15,645
Katrs no tiem ir numura zīme, tāpēc
sākotnēji izmantosim i diapazonā 

1639
01:15:15,645 --> 01:15:18,600
no 3 un izdrukāsim vienu numura
zīmi. 

1640
01:15:18,600 --> 01:15:22,290
Un es domāju, ka tagad python no
mario.py — voilà!

1641
01:15:22,290 --> 01:15:27,480
Mēs esam ierindā, izdrukājot tikai
to pašu kolonnu.

1642
01:15:27,480 --> 01:15:30,495
Ko darīt, ja mēs vēlamies izdrukāt
mainīga augstuma kolonnu, kurā 

1643
01:15:30,495 --> 01:15:33,510
lietotājs norāda, cik augstu viņš
to vēlas? 

1644
01:15:33,510 --> 01:15:37,215
Nu, ļaujiet man, piemēram, uzkāpt
šeit, un tā vietā, kā būtu... 

1645
01:15:37,215 --> 01:15:40,920
izdarīsim šādi. 

1646
01:15:40,920 --> 01:15:45,210
Kā būtu ar cs50 import?

1647
01:15:45,210 --> 01:15:47,620
Kā ar funkciju get_int, tāpat kā
iepriekš?

1648
01:15:47,620 --> 01:15:50,430
Tādējādi tiks nodrošināts, ka
lietotājs mums sniedz veselu skaitli.

1649
01:15:50,430 --> 01:15:53,605
Un tagad, agrāk, kad vēlējāmies
saņemt numuru no lietotāja, mēs 

1650
01:15:53,605 --> 01:15:56,780
faktiski esam sekojuši noteiktai
paradigmai. 

1651
01:15:56,780 --> 01:16:04,105
Patiesībā, ja es šeit, piemēram,
atveru, teiksim, mario1.c pirms kāda 

1652
01:16:04,105 --> 01:16:11,430
laika, jūs varētu atcerēties, ka
mums bija šāds kods. 

1653
01:16:11,430 --> 01:16:13,906
Un mēs izmantojam tieši do while
cilpu valodā C ikreiz, kad vēlamies 

1654
01:16:13,906 --> 01:16:16,382
kaut ko iegūt no lietotāja,
iespējams, atkal un atkal un atkal, līdz 

1655
01:16:16,382 --> 01:16:18,858
viņš sadarbojas. 

1656
01:16:18,858 --> 01:16:20,900
Tajā brīdī mēs beidzot izkļūstam no
cilpas.

1657
01:16:20,900 --> 01:16:23,299
Izrādās, Python ir while cilpas, ir
for cilpas, un nav do while 

1658
01:16:23,299 --> 01:16:25,698
cilpas. 

1659
01:16:25,698 --> 01:16:27,899
Un tomēr gandrīz jebkad, kad esat
saņēmuši lietotāja ievadi, jūs, 

1660
01:16:27,899 --> 01:16:30,100
iespējams, esat izmantojuši šo
paradigmu. 

1661
01:16:30,100 --> 01:16:33,275
Tātad izrādās, ka Python valodā
ekvivalents tam ir darīt, pēc būtības 

1662
01:16:33,275 --> 01:16:36,450
līdzīgi, bet izmantojot tikai while
cilpu. 

1663
01:16:36,450 --> 01:16:40,260
Un Python izplatīta paradigma, kā
jau minēju iepriekš, ir apzināti 

1664
01:16:40,260 --> 01:16:44,070
izraisīt bezgalīgu cilpu while
True — lielais T — un pēc tam darīt 

1665
01:16:44,070 --> 01:16:47,880
to, ko vēlaties, piemēram, saņemt
int no lietotāja un pamudināt viņu 

1666
01:16:47,880 --> 01:16:51,690
izmantot, piemēram, attiecīgo
augstumu. 

1667
01:16:51,690 --> 01:16:54,893
Un tad, ja esat pārliecināti, ka
lietotājs ir devis jums to, ko 

1668
01:16:54,893 --> 01:16:58,097
vēlaties, piemēram, n ir lielāks
par 0, ko es vēlos šajā gadījumā, jo 

1669
01:16:58,097 --> 01:17:01,301
es vēlos pozitīvu veselu skaitli;
pretējā gadījumā tur nav ko 

1670
01:17:01,301 --> 01:17:04,505
drukāt — jūs burtiski vienkārši
izkļūstat no cilpas. 

1671
01:17:04,505 --> 01:17:08,070
Un tāpēc mēs faktiski varētu
izmantot šo paņēmienu valodā C.

1672
01:17:04,505 --> 01:17:10,260
Tas vienkārši nav izdarīts valodā
C.

1673
01:17:08,070 --> 01:17:10,830
Jūs noteikti varētu C valodā kādu
laiku veikt while True cilpu ar 

1674
01:17:10,830 --> 01:17:13,590
iekavām, true mazajiem burtiem. 

1675
01:17:13,590 --> 01:17:15,670
Jūs varētu izlauzties no tās, un tā
tālāk.

1676
01:17:15,670 --> 01:17:18,312
Bet Python valodā - šis ir Python
veids.

1677
01:17:18,312 --> 01:17:19,770
Un tas patiesībā ir mākslas
termins.

1678
01:17:19,770 --> 01:17:22,185
Šis Python veids ir pitonisks. Tas
ir pēdiņās “veids, kā visi to 

1679
01:17:22,185 --> 01:17:24,600
dara”. 

1680
01:17:24,600 --> 01:17:27,935
Tas nenozīmē, ka jums tas ir
jādara, bet tas ir veids, kā foršie 

1681
01:17:27,935 --> 01:17:31,271
Python programmētāji īstenotu šādu
ideju — mēģinātu kaut ko darīt 

1682
01:17:31,271 --> 01:17:34,607
atkal un atkal un atkal, līdz
lietotājs patiešām sadarbojas. 

1683
01:17:34,607 --> 01:17:36,690
Bet viss, ko esam paveikuši, ir
atņemt do while cilpu.

1684
01:17:36,690 --> 01:17:39,790
Bet tomēr, loģiski, mēs varam
īstenot to pašu ideju.

1685
01:17:39,790 --> 01:17:43,580
Tagad, zem šī, ļaujiet man
izdrukāt, jo šoreiz i ir diapazonā n — jo 

1686
01:17:43,580 --> 01:17:47,370
es vēlos, lai tas būtu mainīgais,
nevis 3. 

1687
01:17:47,370 --> 01:17:50,220
Es varu turpināt un izdrukāt hash —
ļaujiet man atbrīvoties no C 

1688
01:17:50,220 --> 01:17:53,070
versijas šeit — atveršu termināļa
logu un atkal palaidīšu Python no 

1689
01:17:53,070 --> 01:17:55,920
mario.py. 

1690
01:17:55,920 --> 01:17:58,530
Es ievadīšu 3 un atgūšu šīs trīs
numura zīmes.

1691
01:17:58,530 --> 01:18:00,582
Bet, ja es tā vietā ierakstu 4, tā
vietā tagad saņemu četras numura 

1692
01:18:00,582 --> 01:18:02,635
zīmes. 

1693
01:18:02,635 --> 01:18:06,143
Tātad svarīgākais šeit ir tas,
pavisam vienkārši, ka šādā veidā, 

1694
01:18:06,143 --> 01:18:09,651
piemēram, faktiski var atgūt
vērtību Python valodā, kas atbilst kādam 

1695
01:18:09,651 --> 01:18:13,160
parametram, piemēram, lielākam par
0. 

1696
01:18:13,160 --> 01:18:13,950
Kā būtu ar šo?

1697
01:18:13,950 --> 01:18:16,890
Praktizēsim to, ko pirms brīža
sludinājām ar saviem ņaudošajiem 

1698
01:18:16,890 --> 01:18:19,830
piemēriem un to visu ņemsim vērā. 

1699
01:18:19,830 --> 01:18:23,220
Ļaujiet man turpināt un definēt
galveno funkciju, tāpat kā iepriekš.

1700
01:18:23,220 --> 01:18:25,946
Ļaujiet man šobrīd pieņemt, ka
pastāv funkcija get_height, kas Python 

1701
01:18:25,946 --> 01:18:28,673
valodā nav paredzēta. 

1702
01:18:28,673 --> 01:18:30,340
Es to izgudrošu pēc mirkļa.

1703
01:18:30,340 --> 01:18:33,620
Un tagad es iešu uz priekšu un
izdarīšu kaut ko līdzīgu šim.

1704
01:18:30,340 --> 01:18:34,905
i šī augstuma diapazonā, ejam uz
priekšu un izdrukāsim tās numura 

1705
01:18:34,905 --> 01:18:39,470
zīmes. 

1706
01:18:39,470 --> 01:18:41,760
Tāpēc es pieņemu, ka get_height
pastāv.

1707
01:18:41,760 --> 01:18:43,930
Ļaujiet man turpināt un ieviest šo
abstrakciju, tāpēc tagad 

1708
01:18:43,930 --> 01:18:46,100
definējiet funkciju, ko sauc par
get_height. 

1709
01:18:46,100 --> 01:18:48,830
Šajā dizainā nav nepieciešami
nekādi argumenti.

1710
01:18:48,830 --> 01:18:51,933
While True, es varu turpināt un
darīt to pašu, ko iepriekš — piešķirt 

1711
01:18:51,933 --> 01:18:55,036
mainīgo n, get_int atgriešanas
vērtība liek lietotājam norādīt šo 

1712
01:18:55,036 --> 01:18:58,140
augstumu. 

1713
01:18:58,140 --> 01:19:03,980
Un tad, ja n ir lielāks par 0, es
varu iet uz priekšu un pārtraukt.

1714
01:19:03,980 --> 01:19:07,670
Bet, ja es šeit pārtraucu, es
loģiski — tāpat kā valodā C — izpildu 

1715
01:19:07,670 --> 01:19:11,360
zem attiecīgās cilpas. 

1716
01:19:11,360 --> 01:19:12,690
Bet tur nekā nav.

1717
01:19:12,690 --> 01:19:15,670
Bet, ja es gribu, lai get_height
atgrieztu augstumu, kas man 

1718
01:19:15,670 --> 01:19:18,650
jāieraksta šeit 14. rindā, loģiski?


1719
01:19:21,580 --> 01:19:23,380
Ko es gribu atgriezt, lai būtu
skaidrs?

1720
01:19:23,380 --> 01:19:23,995
Mērķauditorija: [Nesadzirdami]

1721
01:19:23,995 --> 01:19:24,745
DEIVIDS MALANS: Jā.

1722
01:19:24,745 --> 01:19:26,890
Tāpēc es patiesībā vēlos atgriezt
n.

1723
01:19:26,890 --> 01:19:28,885
Un šeit ir vēl viens Python
interesants moments salīdzinājumā ar 

1724
01:19:28,885 --> 01:19:30,880
valodu C. 

1725
01:19:30,880 --> 01:19:32,275
Šķiet, ka vairs nav jautājumu par
darbības redzamības apgabalu, vai 

1726
01:19:32,275 --> 01:19:33,670
ne? 

1727
01:19:33,670 --> 01:19:37,435
C valodā bija ļoti svarīgi ne tikai
deklarēt savus mainīgos ar datu 

1728
01:19:37,435 --> 01:19:41,200
tipiem, bet arī ņemt vērā to
atrašanās vietu — šajās figūriekavās. 

1729
01:19:41,200 --> 01:19:43,490
Python valodā, izrādās, jūs varat
būt nedaudz brīvāki, uz labu vai 

1730
01:19:43,490 --> 01:19:45,780
sliktu. 

1731
01:19:45,780 --> 01:19:51,475
Un tā, 11. rindā, ja es izveidoju
mainīgo ar nosaukumu n, tas pastāv 

1732
01:19:51,475 --> 01:19:57,170
11., 12. un pat 13. rindā ārpus
cilpas while. 

1733
01:19:57,170 --> 01:20:00,105
Skaidrības labad jāsaka, ka C
valodā ar while cilpumums parasti 

1734
01:20:00,105 --> 01:20:03,040
nebūtu kola. 

1735
01:20:03,040 --> 01:20:05,920
Mums būtu bijušas figūriekavas,
piemēram, šeit un šeit.

1736
01:20:05,920 --> 01:20:09,025
Un pirms nedēļas es būtu
apgalvojis, ka C valodā n neeksistē ārpus 

1737
01:20:09,025 --> 01:20:12,130
cilpas while, pēc figūriekavu
jēgas. 

1738
01:20:12,130 --> 01:20:16,407
Pat ja figūriekavu vairs nav,
Python faktiski ļauj izmantot mainīgo 

1739
01:20:16,407 --> 01:20:20,685
jebkurā laikā pēc tam, kad tam ir
piešķirta vērtība. 

1740
01:20:20,685 --> 01:20:23,625
Tātad nedaudz jaudīgāk pēc būtības.

1741
01:20:23,625 --> 01:20:26,830
Tomēr loģiski, es varu to nedaudz
pastiprināt.

1742
01:20:26,830 --> 01:20:30,700
Un tā ir taisnība valodā C.

1743
01:20:26,830 --> 01:20:29,425
Man tiešām nav nepieciešams
izlauzties no cilpas, izmantojot 

1744
01:20:29,425 --> 01:20:32,020
pārtraukumu. 

1745
01:20:32,020 --> 01:20:36,025
Atcerieties to vai ziniet, ka es
tiešām varu — kad esmu gatavs, es 

1746
01:20:36,025 --> 01:20:40,030
varu atgriezt man nepieciešamo
vērtību, pat cilpas ietvaros. 

1747
01:20:40,030 --> 01:20:43,310
Un tam būs blakus efekts, proti,
mani izraus no cilpas, kā arī 

1748
01:20:43,310 --> 01:20:46,590
izslēgs mani un atgriezīs no visas
funkcijas. 

1749
01:20:46,590 --> 01:20:49,040
Tātad šeit nav nekā jauna attiecībā
uz C pret Python, izņemot šo 

1750
01:20:49,040 --> 01:20:51,490
problēmu ar redzamības apgabalu. 

1751
01:20:51,490 --> 01:20:53,925
Un es tiešām tur apakšā atgriezu n,
lai būtu skaidrs, ka n joprojām 

1752
01:20:53,925 --> 01:20:56,360
pastāvēs. 

1753
01:20:56,360 --> 01:20:58,170
Tātad jebkurš no tiem ir pareizs.

1754
01:20:58,170 --> 01:21:01,880
Tagad man ir tikai Python
programma, kas, manuprāt, ļaus man īstenot 

1755
01:21:01,880 --> 01:21:05,590
šo pašu Mario ideju. 

1756
01:21:05,590 --> 01:21:07,450
Palaidīsim python no mario.py.

1757
01:21:07,450 --> 01:21:09,820
Un... Labi, nekas nenotika.

1758
01:21:09,820 --> 01:21:13,390
Python no mario.py.

1759
01:21:13,390 --> 01:21:14,260
Ko es izdarīju nepareizi?

1760
01:21:14,260 --> 01:21:14,965
Mērķauditorija: [Nesadzirdami]

1761
01:21:14,965 --> 01:21:16,590
DEIVIDS MALANS: Jā, man jāizsauc
galvenā funkcija.

1762
01:21:16,590 --> 01:21:19,720
Tātad mana koda apakšā man šeit ir
jāizsauc galvenā funkcija.

1763
01:21:19,720 --> 01:21:22,720
Un šī ir stilistiska detaļa, kas ir
bijusi grūti satverama.

1764
01:21:22,720 --> 01:21:25,540
Vispārīgi runājot, rakstot Python
valodā, CS50 stila rokasgrāmata 

1765
01:21:25,540 --> 01:21:28,360
pati par sevi nepastāv. 

1766
01:21:28,360 --> 01:21:31,030
Patiesībā ir arī Python stila
rokasgrāmata, kurai lielākā daļa 

1767
01:21:31,030 --> 01:21:33,700
cilvēku seko. 

1768
01:21:33,700 --> 01:21:37,480
Un šajā gadījumā dubultās tukšas
rindas starp funkcijām ir norma.

1769
01:21:37,480 --> 01:21:39,685
Es to daru apzināti, lai gan
pretējā gadījumā tas varētu nebūt 

1770
01:21:39,685 --> 01:21:41,890
acīmredzami. 

1771
01:21:41,890 --> 01:21:43,510
Bet tagad, kad esmu izsaucis
galveno funkciju 16. līnijā, vēlreiz 

1772
01:21:43,510 --> 01:21:45,130
palaidīsim mario.py. 

1773
01:21:45,130 --> 01:21:46,690
Aha.

1774
01:21:46,690 --> 01:21:47,560
Tagad mēs to redzam.

1775
01:21:47,560 --> 01:21:51,730
Ierakstiet 3, un es atkal sāku
darboties, izdrukājot vērtības.

1776
01:21:51,730 --> 01:21:52,330
Jā?

1777
01:21:52,330 --> 01:21:54,146
AUDITORIJA: Kāpēc jūs
[Nesasdzirdami]?

1778
01:21:54,146 --> 01:21:56,120
Kāpēc nevar [Nesadzirdami]?

1779
01:21:56,120 --> 01:21:56,870
DEIVIDS MALANS: Protams.

1780
01:21:56,870 --> 01:21:58,453
Kāpēc man vispār ir vajadzīgs if
nosacījums?

1781
01:21:58,453 --> 01:22:02,390
Kāpēc es nevaru vienkārši atgriezt
n šeit, veicot n atgriešanu.

1782
01:22:02,390 --> 01:22:04,640
Vai arī, ja es patiešām vēlos būt
īss, es varētu tehniski vienkārši 

1783
01:22:04,640 --> 01:22:06,890
izdarīt šo. 

1784
01:22:06,890 --> 01:22:09,210
Vienīgais iemesls, kāpēc pievienoju
nosacījumu if, ir tāpēc, ka, ja 

1785
01:22:09,210 --> 01:22:11,530
lietotājs ieraksta negatīvu 1,
negatīvu 2, es vēlējos to prasīt atkal 

1786
01:22:11,530 --> 01:22:13,850
un atkal. 

1787
01:22:13,850 --> 01:22:14,390
Tas arī viss.

1788
01:22:14,390 --> 01:22:18,630
Bet arī tas būtu pilnīgi pieņemami,
ja jums derētu šis rezultāts.

1789
01:22:18,630 --> 01:22:21,250
Ļaujiet man izdarīt vēl vienu
lietu, lai norādītu, kāpēc mēs tik 

1790
01:22:21,250 --> 01:22:23,870
bieži lietojam get_int. 

1791
01:22:23,870 --> 01:22:26,030
Šis jaunais palīgritenis, lai arī
uz laiku.

1792
01:22:26,030 --> 01:22:29,270
Tāpēc ļaujiet man atgriezties pie
tā, kā tas bija pirms brīža, un 

1793
01:22:29,270 --> 01:22:32,510
ļaujiet man ierosināt tagad noņemt
get_int. 

1794
01:22:32,510 --> 01:22:36,455
Iepriekš es apgalvoju, ka, ja
neizmantojat get_int, varat vienkārši 

1795
01:22:36,455 --> 01:22:40,400
izmantot pašu ievades funkciju no
Python. 

1796
01:22:40,400 --> 01:22:43,250
Bet tas vienmēr atgriež virkni vai
str.

1797
01:22:43,250 --> 01:22:47,590
Tāpēc atcerieties, ka ievades
funkcijas izvade ir jānodod int, vai nu 

1798
01:22:47,590 --> 01:22:51,930
tajā pašā rindā, vai, ja vēlaties,
citā rindā. 

1799
01:22:51,930 --> 01:22:55,590
Bet izrādās tas, ko es nedarīju,
bija parādījis, kas notiek, ja 

1800
01:22:55,590 --> 01:22:59,250
nesadarbojaties ar programmu. 

1801
01:22:59,250 --> 01:23:01,751
Tātad, ja es tagad palaižu python
no mario.py, tas darbojas lieliski 

1802
01:23:01,751 --> 01:23:04,252
pat bez get_int funkcijas. 

1803
01:23:04,252 --> 01:23:05,210
Un es to varu izdarīt ar 4.

1804
01:23:05,210 --> 01:23:06,575
Joprojām darbojas lieliski.

1805
01:23:06,575 --> 01:23:08,952
Bet ļaujiet man notīrīt savu
termināli un būt sarežģītam tagad kā 

1806
01:23:08,952 --> 01:23:11,330
lietotājam, un tad tā vietā
ierakstīt "cat" augstumam. 

1807
01:23:11,330 --> 01:23:12,560
Enter.

1808
01:23:12,560 --> 01:23:14,540
Tagad mēs atkal redzam vienu no šīm
izsekošanām.

1809
01:23:14,540 --> 01:23:15,900
Šī ir savādāka.

1810
01:23:15,900 --> 01:23:18,780
Tā nav nosaukuma kļūda, bet, šķiet,
vērtības kļūda.

1811
01:23:18,780 --> 01:23:22,400
Un, ja es ignorēju lietas, ko es
nesaprotu, es redzu "invalid literal 

1812
01:23:22,400 --> 01:23:26,020
for int with base 10-- "cat."". Tas
ir ļoti noslēpumains veids, kā 

1813
01:23:26,020 --> 01:23:29,640
pateikt, ka CAT nav skaitlis
decimāldaļās. 

1814
01:23:29,640 --> 01:23:32,600
Un tāpēc man šķiet, ka šī lieta ir
kaut kā jārisina.

1815
01:23:32,600 --> 01:23:34,475
Un, ja vēlaties būt ziņkārīgāki,
jūs redzēsiet, ka šī patiešām ir 

1816
01:23:34,475 --> 01:23:36,350
izsekošana. 

1817
01:23:36,350 --> 01:23:38,225
Un arī C valoda mēdz to darīt, vai
arī atkļūdotājs to darītu jūsu 

1818
01:23:38,225 --> 01:23:40,100
vietā. 

1819
01:23:40,100 --> 01:23:41,801
Jūs varat redzēt visas funkcijas,
kas ir izsauktas, lai nokļūtu šajā 

1820
01:23:41,801 --> 01:23:43,502
punktā. 

1821
01:23:43,502 --> 01:23:48,170
Tātad acīmredzot mana problēma
sākotnēji ir 14. rindā.

1822
01:23:48,170 --> 01:23:50,375
Bet 14. rindiņa, ja turpinu
ritināt, ir neinteresanta.

1823
01:23:50,375 --> 01:23:51,410
Tā ir galvenā.

1824
01:23:51,410 --> 01:23:53,615
Bet 14. rinda liek man izpildīt 2.
rindu, kas patiešām ir rakstīta 

1825
01:23:53,615 --> 01:23:55,820
galvenajā funkcijā. 

1826
01:23:55,820 --> 01:23:59,225
Tas liek man izpildīt 9. rindu, kas
ir rakstīta get_height funkcijā.

1827
01:23:59,225 --> 01:24:00,880
Un tā, labi, šeit ir problēma.

1828
01:24:00,880 --> 01:24:03,120
Tāpēc kļūdas ziņojumam tuvākais
rindas numurs, iespējams, atklāj 

1829
01:24:03,120 --> 01:24:05,360
visvairāk. 

1830
01:24:05,360 --> 01:24:06,950
9. rindā ir mana problēma.

1831
01:24:06,950 --> 01:24:09,785
Tāpēc es nevaru vienkārši akli lūgt
lietotājam ievadi un pēc tam 

1832
01:24:09,785 --> 01:24:12,620
pārvērst to par int, ja viņš
nevēlas man dot int. 

1833
01:24:12,620 --> 01:24:13,870
Tagad, kā mēs ar to tiksim galā?

1834
01:24:13,870 --> 01:24:15,867
Atgriežoties pie otrās problēmu
kopas, jūs varētu atcerēties, ka esat 

1835
01:24:15,867 --> 01:24:17,864
apstiprinājuši, ka lietotājs ir
ievadījis skaitli, izmantojot cilpu 

1836
01:24:17,864 --> 01:24:19,862
for un tamlīdzīgi. 

1837
01:24:19,862 --> 01:24:22,346
Izrādās, Python valodā ir labāks
veids, kā to izdarīt, un semantika 

1838
01:24:22,346 --> 01:24:24,830
ir tur. 

1839
01:24:24,830 --> 01:24:28,240
Ja vēlaties mēģināt pārvērst kaut
ko par skaitli, kas patiesībā 

1840
01:24:28,240 --> 01:24:31,650
varētu nebūt skaitlis, izrādās,
Python un dažās citās valodās 

1841
01:24:31,650 --> 01:24:35,060
burtiski ir atslēgvārds, ko sauc
par try. 

1842
01:24:35,060 --> 01:24:37,820
Un, ja vien tas būtu pēdējās
nedēļās, es zinu.

1843
01:24:37,820 --> 01:24:40,583
Bet ar savu kodu varat mēģināt
veikt tālāk norādītās darbības.

1844
01:24:40,583 --> 01:24:41,750
Ko es vēlos mēģināt izdarīt?

1845
01:24:41,750 --> 01:24:44,365
Nu, es vēlos mēģināt izpildīt šīs
dažas rindiņas, izņemot, ja tur ir 

1846
01:24:44,365 --> 01:24:46,980
kļūda. 

1847
01:24:46,980 --> 01:24:50,022
Tāpēc es varu teikt, izņemot
gadījumus, kad ir vērtības kļūda — 

1848
01:24:50,022 --> 01:24:53,065
konkrēti tā, kuru es salaidu grīstē
un izveidoju pirms brīža. 

1849
01:24:53,065 --> 01:24:56,992
Un, ja ir vērtības kļūda, es varu
izdrukāt lietotājam informatīvu 

1850
01:24:56,992 --> 01:25:00,920
ziņojumu, piemēram, "not an
integer" vai kaut ko tamlīdzīgu. 

1851
01:25:00,920 --> 01:25:03,095
Un tas, kas notiek šeit, tagad, ir
burtiski šis operatīvais vārds - 

1852
01:25:03,095 --> 01:25:05,270
try. 

1853
01:25:05,270 --> 01:25:08,430
Python mēģinās iegūt ievadi un
mēģināt to pārveidot par int, un tā 

1854
01:25:08,430 --> 01:25:11,590
mēģinās pārbaudīt, vai tas ir
lielāks par 0, un pēc tam mēģinās to 

1855
01:25:11,590 --> 01:25:14,750
atgriezt. 

1856
01:25:14,750 --> 01:25:15,467
Kāpēc?

1857
01:25:15,467 --> 01:25:18,158
Trīs no šīm rindām ir iekšpusē,
ievilktas zem mēģinājuma bloka, 

1858
01:25:18,158 --> 01:25:20,849
izņemot gadījumus, ja kaut kas
noiet greizi — konkrēti, notiek 

1859
01:25:20,849 --> 01:25:23,540
vērtības kļūda. 

1860
01:25:23,540 --> 01:25:24,560
Pēc tam tas izdrukā šo.

1861
01:25:24,560 --> 01:25:26,110
Bet tas neko neatdod.

1862
01:25:26,110 --> 01:25:30,735
Un tā kā es esmu cilpā, tas nozīmē,
ka tas to darīs atkal un atkal un 

1863
01:25:30,735 --> 01:25:35,360
atkal, līdz cilvēks patiešām
sadarbojas un iedod man reālu skaitli. 

1864
01:25:35,360 --> 01:25:38,210
Un tā, arī to pasaule sauktu par
pitonisku.

1865
01:25:38,210 --> 01:25:41,075
Izmantojot Python, jūs noteikti
nemēģināt stingri pārbaudīt lietotāja 

1866
01:25:41,075 --> 01:25:43,940
ievadi, pārliecinoties, vai viņi
nav pieļāvuši kļūdas. 

1867
01:25:43,940 --> 01:25:47,120
Jūs, godīgi sakot, izmantojat daudz
vājprātīgāku pieeju un vienkārši 

1868
01:25:47,120 --> 01:25:50,300
mēģināt kaut ko darīt, bet, ja tā
notiek - noķerat kļūdu. 

1869
01:25:50,300 --> 01:25:53,720
Tātad noķert ir arī mākslas
termins, lai gan tas šeit nav atslēgvārds.

1870
01:25:53,720 --> 01:25:55,760
Izņemot gadījumus, kad kaut kas
notiek, jūs ar to tiekat galā.

1871
01:25:55,760 --> 01:25:57,470
Tātad jūs mēģināt un tiekat galā.

1872
01:25:57,470 --> 01:25:59,480
Ja vēlaties, programmējiet pēc
iespējas labāk.

1873
01:25:59,480 --> 01:26:04,200
Bet tas ir iekļauts Python
programmēšanas kopienas domāšanā.

1874
01:26:04,200 --> 01:26:06,415
Tātad tagad, ja es veicu mario.py
python un sadarbojos, tas darbojas 

1875
01:26:06,415 --> 01:26:08,630
tikpat lieliski kā iepriekš. 

1876
01:26:08,630 --> 01:26:09,830
Mēģiniet un gūsties panākumus.

1877
01:26:09,830 --> 01:26:10,670
3 der.

1878
01:26:10,670 --> 01:26:11,345
4 der.

1879
01:26:11,345 --> 01:26:14,294
Tomēr, ja es mēģinu un man
neizdodas, ierakstot “cat”, tas pats par 

1880
01:26:14,294 --> 01:26:17,243
sevi nesabrūk. 

1881
01:26:17,243 --> 01:26:18,410
Tas man neuzrāda kļūdu.

1882
01:26:18,410 --> 01:26:20,600
Tas man parāda kaut ko lietotājam
draudzīgāku, piemēram, "not an 

1883
01:26:20,600 --> 01:26:22,790
integer." Un tad es varu mēģināt
vēlreiz ar “dog”. "Not an integer." 

1884
01:26:22,790 --> 01:26:24,980
Es varu mēģināt vēlreiz ar 5. 

1885
01:26:24,980 --> 01:26:26,240
Un tagad tas darbojas.

1886
01:26:26,240 --> 01:26:29,660
Tāpēc mēs parasti nerakstīsim daudz
par šiem mēģinājuma-izņēmuma 

1887
01:26:29,660 --> 01:26:33,080
blokiem, jo tie ātri kļūst nedaudz
sarežģīti. 

1888
01:26:33,080 --> 01:26:35,777
Bet tas ir, lai atklātu, ko dara
funkcija get_int.

1889
01:26:35,777 --> 01:26:37,848
Tāpēc mēs piedāvājam jums
palīgriteņus, lai, ja vēlaties iegūt int, 

1890
01:26:37,848 --> 01:26:39,919
jums nav jālec cauri visiem šiem
kaitinošajiem riņķiem, lai to 

1891
01:26:39,919 --> 01:26:41,990
izdarītu. 

1892
01:26:41,990 --> 01:26:43,977
Bet tas ir viss, ko bibliotēka
patiešām dara jūsu labā, tas ir - 

1893
01:26:43,977 --> 01:26:45,965
tikai mēģina un veic izņēmumus. 

1894
01:26:45,965 --> 01:26:48,980
Galu galā jūs nepaliksiet ar
palīgriteņiem.

1895
01:26:48,980 --> 01:26:50,870
Vai jums ir jautājumi par to, kā
iegūt informāciju un mēģināt šādā 

1896
01:26:50,870 --> 01:26:52,760
veidā? 

1897
01:26:55,433 --> 01:26:56,100
Jebkas?

1898
01:26:56,100 --> 01:26:56,610
Jā?

1899
01:26:56,610 --> 01:27:03,643
[Nesadzirdami] mēģinājuma bloks.

1900
01:27:03,643 --> 01:27:05,101
DEIVIDS MALANS: Vai jūs varētu šo
nosacījumu iekļaut ārpus mēģinājuma 

1901
01:27:05,101 --> 01:27:06,560
bloka? 

1902
01:27:06,560 --> 01:27:07,310
Īsa atbilde - jā.

1903
01:27:07,310 --> 01:27:09,530
Un patiesībā es cīnījos ar to
pagājušajā naktī, kad pielāgoju šo 

1904
01:27:09,530 --> 01:27:11,750
piemēru, lai parādītu vienkāršāko
versiju. 

1905
01:27:11,750 --> 01:27:15,110
Es noliegšu, ka patiesībā man
vajadzētu tikai burtiski mēģināt 

1906
01:27:15,110 --> 01:27:18,470
paveikt trauslo daļu. 

1907
01:27:18,470 --> 01:27:21,425
Un tad, šeit, lejā, man patiešām
vajadzētu darīt to, ko jūs 

1908
01:27:21,425 --> 01:27:24,380
piedāvājat, proti, izpildīt
nosacījumus šeit. 

1909
01:27:24,380 --> 01:27:25,880
Tomēr problēma ir tāda, ka,
loģiski, tas viss ātri kļūst ļoti 

1910
01:27:25,880 --> 01:27:27,380
nekārtīgs, vai ne? 

1911
01:27:27,380 --> 01:27:30,170
Jo, izņemot, ja ir vērtības kļūda,
es vēlos izdrukāt “not an 

1912
01:27:30,170 --> 01:27:32,961
integer”. Tad es nevaru salīdzināt
n ar 0, jo n neeksistē, jo bija 

1913
01:27:32,961 --> 01:27:35,752
kļūda. 

1914
01:27:35,752 --> 01:27:38,691
Izrādās, un es jums to parādīšu; šī
tagad ir Python uzlabotā 

1915
01:27:38,691 --> 01:27:41,630
versija — patiesībā Python varat
izmantot citu atslēgvārdu, kas 

1916
01:27:41,630 --> 01:27:44,570
nepavada if vai elif. 

1917
01:27:44,570 --> 01:27:46,625
Tas pavada mēģinājumu un izņēmumu,
kas, manuprāt, ir dīvaini 

1918
01:27:46,625 --> 01:27:48,680
mulsinoši. 

1919
01:27:48,680 --> 01:27:50,640
Labāk būtu bijis cits vārds.

1920
01:27:50,640 --> 01:27:53,692
Bet, ja jūs patiešām vēlētos, es
būtu varējis to izdarīt.

1921
01:27:53,692 --> 01:27:55,296
Un šī ir viena no šīm dizaina
lietām, kurai saprātīgi cilvēki 

1922
01:27:55,296 --> 01:27:56,900
nepiekritīs. 

1923
01:27:56,900 --> 01:27:58,940
Vispārīgi runājot, jums vajadzētu
mēģināt izpildīt tikai vienu 

1924
01:27:58,940 --> 01:28:00,980
rindiņu, kas mierīgi var
neizdoties. 

1925
01:28:00,980 --> 01:28:02,420
Bet, godīgi sakot, tas izskatās
muļķīgi.

1926
01:28:02,420 --> 01:28:04,850
Nē, tas ir vienkārši nevajadzīgi
sarežģīti.

1927
01:28:04,850 --> 01:28:07,224
Un tā, mana izvēle patiesībā bija
oriģināla, kas bija... jā, es 

1928
01:28:07,224 --> 01:28:09,598
mēģinu dažas papildu rindiņas, kas
tiešām matemātiski nevar 

1929
01:28:09,598 --> 01:28:11,973
neizdoties. 

1930
01:28:11,973 --> 01:28:12,890
Bet tā tas ir tikai skaidrāk.

1931
01:28:12,890 --> 01:28:14,030
Tādā veidā tas ir tīrāk.

1932
01:28:14,030 --> 01:28:16,280
Un šeit atkal ir tādi argumenti,
kurus jūs sāksiet izteikt, kad labāk 

1933
01:28:16,280 --> 01:28:18,530
iepazīsieties ar programmēšanu. 

1934
01:28:18,530 --> 01:28:19,280
Jums būs viedoklis.

1935
01:28:19,280 --> 01:28:20,488
Jūs kādam nepiekritīsiet.

1936
01:28:20,488 --> 01:28:22,844
Un, ja vien jūs varat argumentēt,
tas, iespējams, ir diezgan 

1937
01:28:22,844 --> 01:28:25,200
saprātīgi. 

1938
01:28:25,200 --> 01:28:25,700
Labi.

1939
01:28:25,700 --> 01:28:28,565
Kā būtu, ja mēs tagad atņemsim kādu
burvības pieskārienu, kas šeit ir 

1940
01:28:28,565 --> 01:28:31,430
bijis kādu laiku. 

1941
01:28:31,430 --> 01:28:33,950
Ļaujiet man turpināt un izdzēst
visu šo šeit.

1942
01:28:33,950 --> 01:28:37,010
Un ļaujiet man ierosināt pārskatīt
nevis šo vertikālo kolonnu un 

1943
01:28:37,010 --> 01:28:40,070
izņēmumus, kas varētu rasties,
saņemot ievadi, bet gan šīs 

1944
01:28:40,070 --> 01:28:43,130
horizontālās jautājuma zīmes, kuras
redzējām pirms kāda laika. 

1945
01:28:43,130 --> 01:28:44,555
Tāpēc es vēlos, lai visas šīs
jautājuma zīmes būtu uz vienas tās 

1946
01:28:44,555 --> 01:28:45,980
pašas rindiņas. 

1947
01:28:45,980 --> 01:28:48,510
Un tomēr es uztraucos, ka mūs šeit
sagaidīs izaicinājums, jo līdz šim 

1948
01:28:48,510 --> 01:28:51,040
drukāšana visur ir ievietojusi
jaunas rindas automātiski, pat bez šīm 

1949
01:28:51,040 --> 01:28:53,570
slīpsvītras n. 

1950
01:28:53,570 --> 01:28:56,360
Ļaujiet man ierosināt izdarīt šo.

1951
01:28:56,360 --> 01:28:58,130
i diapazonā 4.

1952
01:28:58,130 --> 01:29:00,147
Ja es gribu četras jautājuma zīmes,
ļaujiet man vienkārši izdrukāt 

1953
01:29:00,147 --> 01:29:02,165
četras jautājuma zīmes. 

1954
01:29:02,165 --> 01:29:04,370
Diemžēl, manuprāt, tas vēl nav
pareizi.

1955
01:29:04,370 --> 01:29:06,530
Ļaujiet man palaist python no
mario.py.

1956
01:29:06,530 --> 01:29:09,580
Un, protams, tas man dod kolonnu,
nevis vajadzīgās jautājuma zīmju 

1957
01:29:09,580 --> 01:29:12,630
līniju. 

1958
01:29:12,630 --> 01:29:13,550
Tātad, kā mēs to darām?

1959
01:29:13,550 --> 01:29:16,366
Nu, ja palasa drukāšanas funkcijas
dokumentāciju, tad izrādās, ka 

1960
01:29:16,366 --> 01:29:19,183
drukāšana, iespējams tas nav
pārsteidzoši, prasa daudz dažādu 

1961
01:29:19,183 --> 01:29:22,000
argumentu. 

1962
01:29:22,000 --> 01:29:24,895
Un patiesībā, ja apskatāt to
dokumentācijā, jūs redzēsiet, ka tam nav 

1963
01:29:24,895 --> 01:29:27,790
nepieciešami tikai pozicionālie
argumenti, tas ir - no kreisās puses 

1964
01:29:27,790 --> 01:29:30,685
uz labo, atdalīti ar komatiem. 

1965
01:29:30,685 --> 01:29:33,772
Izrādās, Python atbalsta stilīgāku
funkciju ar argumentiem, kur varat 

1966
01:29:33,772 --> 01:29:36,860
nodot argumentu nosaukumus arī
funkcijām. 

1967
01:29:36,860 --> 01:29:38,470
Tātad, ko es ar to domāju?

1968
01:29:38,470 --> 01:29:42,213
Ja es atgriežos šeit pie VS Code un
esmu izlasījis dokumentāciju, 

1969
01:29:42,213 --> 01:29:45,956
izrādās, ka - jā, tāpat kā
iepriekš, jūs varat nodot Python vairākus 

1970
01:29:45,956 --> 01:29:49,700
argumentus, piemēram, šo. 

1971
01:29:49,700 --> 01:29:53,126
Hello, komats, David, komats,
Nalan! Tas vienkārši automātiski 

1972
01:29:53,126 --> 01:29:56,553
savienos visus trīs pozicionālus
argumentus. 

1973
01:29:56,553 --> 01:29:58,895
Tie ir pozicionāli tādā nozīmē, ka
tie burtiski plūst no kreisās 

1974
01:29:58,895 --> 01:30:01,238
puses uz labo, atdalīti ar
komatiem. 

1975
01:30:01,238 --> 01:30:04,304
Bet, ja jūs nevēlaties vienkārši
nodot šādas vērtības, jūs patiešām 

1976
01:30:04,304 --> 01:30:07,370
vēlaties izdrukāt jautājuma zīmi,
kā es to darīju iepriekš. 

1977
01:30:07,370 --> 01:30:10,990
Bet jūs vēlaties ignorēt drukas
noklusējuma darbību, mainot rindiņas 

1978
01:30:10,990 --> 01:30:14,610
beigas, faktiski varat izdarīt šo. 

1979
01:30:14,610 --> 01:30:18,370
Varat izmantot argumenta nosaukumu,
par kuru zināt no dokumentācijas, 

1980
01:30:18,370 --> 01:30:22,130
ka tas pastāv, un iestatīt to
vienādu ar kādu alternatīvu vērtību. 

1981
01:30:22,130 --> 01:30:26,255
Un patiesībā, lai gan tas izskatās
sarežģīti, šādi es ignorētu katras 

1982
01:30:26,255 --> 01:30:30,380
rindiņas beigas, pēdiņās. 

1983
01:30:30,380 --> 01:30:35,090
Tas nav nekas, jo, lasot
dokumentāciju, noklusējuma vērtība šim beigu 

1984
01:30:35,090 --> 01:30:39,800
argumentam — vai kāds vēlas
uzminēt — ir — ir slīpsvītra n. 

1985
01:30:39,800 --> 01:30:43,175
Tātad, ja lasīsiet dokumentāciju,
jūs redzēsiet, ka slīpsvītra n ir 

1986
01:30:43,175 --> 01:30:46,550
šī beigu argumenta netiešā
noklusējuma vērtība. 

1987
01:30:46,550 --> 01:30:48,180
Un tāpēc, ja vēlaties to mainīt,
vienkārši sakiet, ka beigas ir 

1988
01:30:48,180 --> 01:30:49,810
vienādas ar kaut ko citu. 

1989
01:30:49,810 --> 01:30:53,433
Un tāpēc es varu to mainīt uz neko
un tagad atkārtoti palaist python 

1990
01:30:53,433 --> 01:30:57,057
no mario.py. 

1991
01:30:57,057 --> 01:30:58,640
Un tagad tie visi ir vienā rindā.

1992
01:30:58,640 --> 01:31:01,415
Tagad tas izskatās nedaudz muļķīgi,
jo tajā nedēļā es pieļāvu vienu 

1993
01:31:01,415 --> 01:31:04,190
kļūdu, kur man joprojām ir
jāpārvieto kursors uz nākamo rindiņu. 

1994
01:31:04,190 --> 01:31:05,570
Tā ir tikai cita problēma.

1995
01:31:05,570 --> 01:31:07,612
Es vienkārši došos šeit un neko
nedrukāšu.

1996
01:31:07,612 --> 01:31:10,214
Man pat nav jādrukā slīpsvītra n,
jo, ja drukāšana automātiski 

1997
01:31:10,214 --> 01:31:12,817
piešķir jums slīpsvītru n,
vienkārši izsauciet drukāšanu bez nekā, un 

1998
01:31:12,817 --> 01:31:15,420
jūs to saņemsiet par velti. 

1999
01:31:15,420 --> 01:31:16,940
Tāpēc ļaujiet man atkārtoti palaist
python no mario.py.

2000
01:31:16,940 --> 01:31:19,895
Un tagad uzvednē tas izskatās
nedaudz skaistāks .

2001
01:31:19,895 --> 01:31:22,097
Un, lai būtu ļoti skaidrs, kas
notiek, - pieņemsim, ka es šeit vēlos 

2002
01:31:22,097 --> 01:31:24,300
izteikt izsaukumu. 

2003
01:31:24,300 --> 01:31:26,490
Es varētu mainīt slīpsvītru n pēc
noklusējuma uz izsaukuma zīmi, 

2004
01:31:26,490 --> 01:31:28,680
vienkārši joka pēc. 

2005
01:31:28,680 --> 01:31:32,671
Un, ja es palaižu python of
mario.py. Atkal, tagad es saņemu šo 

2006
01:31:32,671 --> 01:31:36,662
izsaukumu ar jautājuma zīmēm un
izsaukuma zīmēm. 

2007
01:31:36,662 --> 01:31:38,120
Tātad tas ir viss, kas šeit notiek.

2008
01:31:38,120 --> 01:31:40,670
Un tas ir tas, ko sauc par nosaukto
argumentu.

2009
01:31:40,670 --> 01:31:43,670
Tam burtiski ir nosaukums, kuru
varat norādīt, izsaucot.

2010
01:31:43,670 --> 01:31:45,728
Un tas atšķiras no pozicionālā ar
to, ka jūs burtiski izmantojat 

2011
01:31:45,728 --> 01:31:47,787
vārdu. 

2012
01:31:47,787 --> 01:31:49,370
Ļaujiet man tomēr piedāvāt kaut ko
citu.

2013
01:31:49,370 --> 01:31:50,828
Un tāpēc cilvēkiem patīk Python.

2014
01:31:50,828 --> 01:31:52,550
Ir vienkārši lieliski veidi, kā
rīkoties.

2015
01:31:55,724 --> 01:31:58,232
Tas ir trīs rindiņu, detalizēts
veids, kā izdrukāt četras jautājuma 

2016
01:31:58,232 --> 01:32:00,740
zīmes. 

2017
01:32:00,740 --> 01:32:04,002
Es noteikti varētu izmantot īsceļu
un vienkārši izdarīt to.

2018
01:32:04,002 --> 01:32:06,361
Bet tas nevienam nav tik
interesanti, it īpaši, ja es vēlos to darīt 

2019
01:32:06,361 --> 01:32:08,720
neskaitāmas reizes. 

2020
01:32:08,720 --> 01:32:10,390
Bet Python ļauj to izdarīt.

2021
01:32:10,390 --> 01:32:14,355
Ja vēlaties reizināt rakstzīmi
vairākas reizes, varat ne tikai 

2022
01:32:14,355 --> 01:32:18,320
izmantot plus konkatenācijai, bet
arī zvaigznīti vai zvaigznīti 

2023
01:32:18,320 --> 01:32:22,285
reizināšanai, ja vēlaties, tas ir -
konkatenācija atkal un atkal un 

2024
01:32:22,285 --> 01:32:26,250
atkal. 

2025
01:32:26,250 --> 01:32:29,506
Tātad, ja es tikai izdrukāju,
pēdiņās “?” reizinātu ar 4, tas 

2026
01:32:29,506 --> 01:32:32,763
patiesībā būs vieglākais veids,
visizteiktākais veids, kā savādāk 

2027
01:32:32,763 --> 01:32:36,020
varu izdrukāt četras jautājuma
zīmes. 

2028
01:32:36,020 --> 01:32:39,095
Un, ja es neizmantoju 4, es
izmantoju n, kur es saņemu n no lietotāja.

2029
01:32:39,095 --> 01:32:39,830
Bums!

2030
01:32:39,830 --> 01:32:43,915
Tagad esmu pilnībā atbrīvojies no
for cilpas, un tā vietā izmantoju 

2031
01:32:43,915 --> 01:32:48,000
operatoru - zvaigzni, lai ar to
manipulētu. 

2032
01:32:48,000 --> 01:32:52,030
Un, lai būtu ļoti skaidrs, ciktāl
Python nav malloc vai free vai 

2033
01:32:52,030 --> 01:32:56,060
atmiņas pārvaldības, kas jums
jādara, uzminiet, kā vēl nav Python. 

2034
01:32:59,760 --> 01:33:03,110
Vai kaut kas ir jūsu prātā pēdējās
pāris nedēļās?

2035
01:33:03,110 --> 01:33:04,853
Nav... AUDITORIJA: Rādītāji.

2036
01:33:04,853 --> 01:33:06,020
DEIVIDS MALANS: Rādītāji, jā.

2037
01:33:06,020 --> 01:33:08,730
Tātad Python valodā nav rādītāju,
kas nozīmē tikai to, ka tas viss 

2038
01:33:08,730 --> 01:33:11,440
notiek automātiski zem pārsega,
izmantojot kodu, ko uzrakstījis kāds 

2039
01:33:11,440 --> 01:33:14,150
cits. 

2040
01:33:14,150 --> 01:33:15,950
Kā būtu ar vēl vienu atspēlēšanos
ar Mario?

2041
01:33:15,950 --> 01:33:20,126
Mēs pirmajā nedēļā runājām par šo
divdimensiju struktūru, kur tas ir 

2042
01:33:20,126 --> 01:33:24,302
tāpat kā es apgalvoju, ka 3 reiz
3 — rūtiņu režģis, ja vēlaties. 

2043
01:33:24,302 --> 01:33:25,760
Nu, kā mēs to varam izdarīt Python
valodā?

2044
01:33:25,760 --> 01:33:27,590
Tagad mēs to varam izdarīt vairākos
veidos.

2045
01:33:27,590 --> 01:33:31,211
Ļaujiet man atgriezties pie sava
mario.py un izdarīt kaut ko līdzīgu 

2046
01:33:31,211 --> 01:33:34,832
i diapazonā — mēs veiksim tikai 3,
lai gan es zinu, ka tagad es 

2047
01:33:34,832 --> 01:33:38,453
varētu izmantot get_int vai ievadi
un int. 

2048
01:33:38,453 --> 01:33:40,521
Un, ja es vēlos kaut ko darīt
divdimensiju veidā, tāpat kā valodā C, 

2049
01:33:40,521 --> 01:33:42,590
varat ligzdot savas for cilpas. 

2050
01:33:42,590 --> 01:33:45,980
Tātad, iespējams, es varētu darīt j
diapazonā no 3.

2051
01:33:45,980 --> 01:33:50,690
Un tad šeit es varētu izdrukāt
numura zīmes (hash) simbolu.

2052
01:33:50,690 --> 01:33:53,210
Un tad paskatīsimies, vai tas man
kopā dod 9.

2053
01:33:53,210 --> 01:33:55,917
Tātad, ja man ir šāda ligzdota
cilpa, mario.py python, cerams, man 

2054
01:33:55,917 --> 01:33:58,625
iedos režģi. 

2055
01:33:58,625 --> 01:34:01,710
Nē, tas man deva kolonnu no 9.

2056
01:34:01,710 --> 01:34:09,280
Kāpēc, loģiski, lai gan man ir sava
rinda un kolonnas?

2057
01:34:09,280 --> 01:34:10,210
Jā.

2058
01:34:10,210 --> 01:34:11,542
Mērķauditorija: [Nesadzirdami]

2059
01:34:11,542 --> 01:34:13,000
DEIVIDS MALANS: Jā, rindas beigas.

2060
01:34:13,000 --> 01:34:15,190
Tāpēc savā rindā es nevaru ļaut
drukai turpināt pievienot jaunas un 

2061
01:34:15,190 --> 01:34:17,380
jaunas rindiņas. 

2062
01:34:17,380 --> 01:34:19,060
Tāpēc man vienkārši ir jāignorē tas
šeit un jāļauj man nesalaist visu 

2063
01:34:19,060 --> 01:34:20,740
grīstē kā iepriekš. 

2064
01:34:20,740 --> 01:34:22,495
Ļaujiet man izdrukāt vienu visas
rindas beigās, lai pārvietotu 

2065
01:34:22,495 --> 01:34:24,250
kursoru uz leju. 

2066
01:34:24,250 --> 01:34:28,090
Un es domāju, ka tagad mēs kopā
esam ieguvuši 3 reiz 3.

2067
01:34:28,090 --> 01:34:29,950
Protams, mēs varētu to vēl vairāk
noprecizēt.

2068
01:34:29,950 --> 01:34:33,962
Ja man nepatīk ligzdotā cilpa, es
droši vien varētu ieiet šeit un 

2069
01:34:33,962 --> 01:34:37,975
vienkārši izdrukāt, piemēram,
rūtiņa reiz 3. 

2070
01:34:37,975 --> 01:34:39,515
Vai arī es varētu mainīt 3 uz
mainīgo, ja esmu to saņēmis no 

2071
01:34:39,515 --> 01:34:41,055
lietotāja. 

2072
01:34:41,055 --> 01:34:42,582
Tāpēc es varu to vēl vairāk
noprecizēt.

2073
01:34:42,582 --> 01:34:44,246
Tātad, atkal tikai dažādi veidi, kā
atrisināt vienu un to pašu 

2074
01:34:44,246 --> 01:34:45,910
problēmu, un atkal pierādījumi tam,
kāpēc daudziem cilvēkiem patīk 

2075
01:34:45,910 --> 01:34:47,575
Python. 

2076
01:34:47,575 --> 01:34:50,665
Ir tikai daži patīkamāki veidi, kā
atrisināt problēmas, nepārtraukti 

2077
01:34:50,665 --> 01:34:53,755
neiekulties nepatikšanās, piemēram,
kā tas bezgalīgi ir ar for cilpām 

2078
01:34:53,755 --> 01:34:56,845
un while cilpām. 

2079
01:34:56,845 --> 01:34:57,430
Labi.

2080
01:34:57,430 --> 01:34:59,222
Nu, kā ar dažiem citiem būvēšanas
blokiem?

2081
01:34:59,222 --> 01:35:02,061
Saraksti būs tik neticami noderīgi
Python valodā, tāpat kā masīvi C 

2082
01:35:02,061 --> 01:35:04,900
valodā. 

2083
01:35:02,983 --> 01:35:06,410
Bet masīvi ir kaitinoši, jo jums
pašiem jāpārvalda atmiņa.

2084
01:35:06,410 --> 01:35:08,925
Lai mainītu to izmērus, jums ir
iepriekš jānosaka to lielums vai arī 

2085
01:35:08,925 --> 01:35:11,440
jāizmanto rādītājus un malloc vai
realloc. 

2086
01:35:11,440 --> 01:35:12,100
Ak, dievs.

2087
01:35:12,100 --> 01:35:14,267
Pēdējās divas nedēļas šajā ziņā ir
bijušas sāpīgas.

2088
01:35:14,267 --> 01:35:17,298
Bet Python to visu dara jūsu vietā
tāpat vien.

2089
01:35:17,298 --> 01:35:21,855
Faktiski Python komplektā ir
iekļauta vesela virkne funkciju, kas 

2090
01:35:21,855 --> 01:35:26,412
ietver sarakstus, un galu galā tie
ļaus mums darīt lietas atkal un 

2091
01:35:26,412 --> 01:35:30,970
atkal un atkal tajā pašā datu
struktūrā. 

2092
01:35:30,970 --> 01:35:33,220
Un, piemēram, mēs varēsim iegūt
saraksta garumu.

2093
01:35:33,220 --> 01:35:35,560
Jums pašiem tas nav jāatceras
mainīgajā.

2094
01:35:35,560 --> 01:35:37,322
Varat vienkārši pajautāt Python
valodai, cik elementu ir šajā 

2095
01:35:37,322 --> 01:35:39,085
sarakstā. 

2096
01:35:39,085 --> 01:35:42,850
Un ar to es domāju, ka mēs varam
atrisināt arī dažas vecas problēmas.

2097
01:35:42,850 --> 01:35:45,250
Tāpēc ļaujiet man atgriezties šeit,
pie VS Code.

2098
01:35:45,250 --> 01:35:48,070
Ļaujiet man aizvērt mario un
piedāvāt mums jaunu programmu ar 

2099
01:35:48,070 --> 01:35:50,890
nosaukumu scores.py. 

2100
01:35:50,890 --> 01:35:52,712
Un tā vietā, lai tagad rādītu C un
Python, pievērsīsimies tikai 

2101
01:35:52,712 --> 01:35:54,535
Python valodai. 

2102
01:35:54,535 --> 01:35:57,433
Un iekš scores.c pirms dažām
nedēļām mēs tikai rēķinājām trīs 

2103
01:35:57,433 --> 01:36:00,331
pārbaudes rezultātu vai kuat kā
līdzīga - 72, 73 un 33 - vidējo 

2104
01:36:00,331 --> 01:36:03,230
vērtību. 

2105
01:36:03,230 --> 01:36:06,225
Tātad, ja es vēlos izveidot
sarakstu no 72, 73, 33 šajā Python 

2106
01:36:06,225 --> 01:36:09,220
versijā, es vienkārši izmantoju
savas kvadrātiekavas. 

2107
01:36:09,220 --> 01:36:11,695
C valoda ļauj izmantot
figūriekavas, ja iepriekš zināt vērtības, taču 

2108
01:36:11,695 --> 01:36:14,170
Python valodā ir tikai šis. 

2109
01:36:14,170 --> 01:36:16,765
Un tagad, ja es vēlos aprēķināt
vidējo — C valodā, atceraties, es 

2110
01:36:16,765 --> 01:36:19,360
kaut ko darīju ar cilpu. 

2111
01:36:19,360 --> 01:36:21,140
Es saskaitīju visas vērtības kopā.

2112
01:36:21,140 --> 01:36:23,625
Tad es to sadalīju ar kopējo
vērtību skaitu, tāpat kā jūs to darītu 

2113
01:36:23,625 --> 01:36:26,110
pamatskolā, un tas man deva vidējo.


2114
01:36:26,110 --> 01:36:28,752
Python ir aprīkota ar daudzām īpaši
parocīgām funkcijām — ne tikai 

2115
01:36:28,752 --> 01:36:31,395
garumu, bet arī citām. 

2116
01:36:31,395 --> 01:36:35,702
Tātad, ja vēlaties aprēķināt
vidējo, varat ņemt visu šo rezultātu 

2117
01:36:35,702 --> 01:36:40,010
summu un dalīt to ar visu šo
rezultātu garumu. 

2118
01:36:40,010 --> 01:36:42,490
Tātad Python valoda nāk ar garumu,
nāk ar summu.

2119
01:36:42,490 --> 01:36:45,040
Varat vienkārši nodot visu jebkura
izmēra sarakstu un ļaut tam 

2120
01:36:45,040 --> 01:36:47,590
atrisināt šo problēmu jūsu vietā. 

2121
01:36:47,590 --> 01:36:50,250
Tātad, ja es vēlos tagad izdrukāt
šo vidējo vērtību, es varu izdrukāt 

2122
01:36:50,250 --> 01:36:52,910
Average, kols, un tad es pievienošu
savu vidējo mainīgo 

2123
01:36:52,910 --> 01:36:55,570
interpolācijai. 

2124
01:36:55,570 --> 01:36:58,550
Ļaujiet man izveidot šo fstring,
lai tā tiktu formatēta, un ļaujiet 

2125
01:36:58,550 --> 01:37:01,530
man vienkārši palaist python no
scores.py. 

2126
01:37:01,530 --> 01:37:02,800
Un tur ir mans vidējais.

2127
01:37:02,800 --> 01:37:05,882
Tas ir dīvaini, jo mēs joprojām
esam neaizsargāti no dažām peldošā 

2128
01:37:05,882 --> 01:37:08,965
komata neprecizitātēm, taču man
vismaz nebija vajadzīgas cilpas un 

2129
01:37:08,965 --> 01:37:12,047
man nebija jāraksta viss šis
drausmīgais kods, lai izdarītu kaut ko 

2130
01:37:12,047 --> 01:37:15,130
tādu, ko var mierīgi var izdarīt
Excel un Google izklājlapas. 

2131
01:37:15,130 --> 01:37:18,460
Python valoda ir tuvāka šiem
rīkiem, taču jaudīgākais tajā ir tas, ka 

2132
01:37:18,460 --> 01:37:21,790
jūs paši varat manipulēt ar datiem.


2133
01:37:21,790 --> 01:37:24,535
Tomēr kā būtu, ja es vēlos manuāli
iegūt virkni rezultātu no 

2134
01:37:24,535 --> 01:37:27,280
lietotāja un pēc tam tos summēt. 

2135
01:37:27,280 --> 01:37:28,920
Nu, apvienosim šeit dažas idejas.

2136
01:37:28,920 --> 01:37:29,830
Kā būtu ar šo?

2137
01:37:29,830 --> 01:37:34,585
Pirmkārt, ļaujiet man importēt
funkciju get_int no CS50 bibliotēkas, 

2138
01:37:34,585 --> 01:37:39,340
lai mums nebūtu jāstrādā ar to
visu. 

2139
01:37:39,340 --> 01:37:42,340
Un ļaujiet man iet uz priekšu un
izveidot sev tukšu sarakstu.

2140
01:37:42,340 --> 01:37:44,410
Un tas ir spēcīgi.

2141
01:37:44,410 --> 01:37:48,068
C valodā [Nopūšas] nav

2142
01:37:48,068 --> 01:37:50,334
norādes uz tukšu masīvu, jo, ja
izveidojat tukšu masīvu ar 

2143
01:37:50,334 --> 01:37:52,600
kvadrātiekavām, tas nekam nebūs
derīgs. 

2144
01:37:52,600 --> 01:37:54,930
Bet valodā Python varat to izveidot
tukšu, jo Python automātiski 

2145
01:37:54,930 --> 01:37:57,260
paplašinās un samazinās sarakstu
jūsu vietā, kamēr jūs pievienojat 

2146
01:37:57,260 --> 01:37:59,590
tam informāciju. 

2147
01:37:59,590 --> 01:38:02,215
Tātad, ja es vēlos saņemt trīs
rezultātus no lietotāja, es varētu 

2148
01:38:02,215 --> 01:38:04,840
darīt kaut ko līdzīgu šim — i
diapazonā no 3. 

2149
01:38:04,840 --> 01:38:08,680
Un tad es varu paķert mainīgo, ko
sauc par “score” vai jebko citu.

2150
01:38:08,680 --> 01:38:10,615
Es varētu izsaukt get_int, likt
cilvēkam ievadīt rezultātu, kuru viņš 

2151
01:38:10,615 --> 01:38:12,550
vēlas ievadīt. 

2152
01:38:12,550 --> 01:38:15,060
Un tad, kad viņi to izdarīs, es
varu izdarīt šo.

2153
01:38:15,060 --> 01:38:19,709
Tagad, domājot par mūsu
objektorientētās programmēšanas iespējām, es 

2154
01:38:19,709 --> 01:38:24,358
varētu veikt scores.append, un es
varu tai pievienot šo rezultātu. 

2155
01:38:24,358 --> 01:38:27,340
Un jūs to zinātu tikai pēc tam, kad
esat izlasījis dokumentāciju, 

2156
01:38:27,340 --> 01:38:30,322
dzirdējis to klasē, grāmatā vai kas
cits, bet izrādās, ka, tāpat kā 

2157
01:38:30,322 --> 01:38:33,304
virknēm ir tādas funkcijas kā
zemāka, sarakstos ir iebūvētas 

2158
01:38:33,304 --> 01:38:36,286
funkcijas, piemēram, pievienot, kas
vienkārši burtiski pievieno 

2159
01:38:36,286 --> 01:38:39,268
saraksta beigām jūsu vietā, un
Python to palielinās vai samazinās pēc 

2160
01:38:39,268 --> 01:38:42,250
vajadzības. 

2161
01:38:42,250 --> 01:38:44,760
Vairs nav malloc vai realloc vai
kaut kā tamlīdzīga.

2162
01:38:44,760 --> 01:38:49,120
Tātad tas tikai pievieno rezultātu
sarakstam.

2163
01:38:49,120 --> 01:38:51,740
To rezultātu, un tad atkal un atkal
un atkal.

2164
01:38:51,740 --> 01:38:54,266
Tātad masīvs sākas ar —
atvainojiet, saraksts sākas ar 0 lielumu, pēc 

2165
01:38:54,266 --> 01:38:56,793
tam palielinās līdz 1, pēc tam — 2,
pēc tam — 3, jums nav jādara 

2166
01:38:56,793 --> 01:38:59,320
nekas cits. 

2167
01:38:59,320 --> 01:39:03,387
Un tāpēc tagad, šeit, es varu
aprēķināt vidējo, šo rezultātu summu 

2168
01:39:03,387 --> 01:39:07,455
dalītu ar kopējā rezultāta skaita
garumu. 

2169
01:39:07,455 --> 01:39:11,830
Un, lai būtu skaidrs, garums - ir
kopējais elementu skaits sarakstā.

2170
01:39:11,830 --> 01:39:14,200
Nav svarīgi, cik lielas ir pašas
vērtības.

2171
01:39:14,200 --> 01:39:18,150
Tagad es varu izdrukāt fstring ar
kaut ko līdzīgu Average, kols, 

2172
01:39:18,150 --> 01:39:22,100
average, figūriekavās. 

2173
01:39:22,100 --> 01:39:25,770
Un, ja es palaižu python no
scores.py– - diskusijas labad ievadīšu 

2174
01:39:25,770 --> 01:39:29,440
trīs vērtības - es joprojām saņemu
to pašu atbildi. 

2175
01:39:29,440 --> 01:39:33,265
Bet būtusāpīgi to darīt C valodā,
ja vien iepriekš jūs nebūtu 

2176
01:39:33,265 --> 01:39:37,090
apņēmušies izmantot fiksēta izmēra
masīvu — par ko mēs jau nolēmām, 

2177
01:39:37,090 --> 01:39:40,915
pirms dažām nedēļām, tas bija
kaitinoši — vai arī jūs to dinamiski 

2178
01:39:40,915 --> 01:39:44,740
attīstījāt, izmantojot malloc vai
realloc vai tamlīdzīgus līdzekļus. 

2179
01:39:44,740 --> 01:39:45,400
Labi.

2180
01:39:45,400 --> 01:39:46,240
Ko vēl es varu darīt?

2181
01:39:46,240 --> 01:39:49,990
Ir dažas jaukas lietas, par kurām
jūs tikpat labi būtu vērtszināt.

2182
01:39:49,990 --> 01:39:54,340
Scores.append vietā varat veikt
šādu vieglu izdomu.

2183
01:39:54,340 --> 01:39:58,107
Ja vēlaties kaut ko pievienot
sarakstam, faktiski varat izdarīt plus 

2184
01:39:58,107 --> 01:40:01,875
vienāds un pēc tam ievietot šo
lietu savā pagaidu sarakstā un 

2185
01:40:01,875 --> 01:40:05,642
vienkārši izmantot to, kas būtībā
ir konkatenācija — bet nevis virkņu 

2186
01:40:05,642 --> 01:40:09,410
konkatenācija, bet gan sarakstu
konkatenācija. 

2187
01:40:09,410 --> 01:40:12,163
Tātad šī jaunā 6. rindiņa tiek
pievienota rezultātu sarakstam — šis 

2188
01:40:12,163 --> 01:40:14,916
mazais, mazais saraksts, kuru es
īslaicīgi veidoju, izmantojot tikai 

2189
01:40:14,916 --> 01:40:17,670
pašreizējo jauno rezultātu. 

2190
01:40:17,670 --> 01:40:20,480
Tātad tikai vēl viens sintakses
fragments, ko ir vērts redzēt, kas 

2191
01:40:20,480 --> 01:40:23,290
ļauj jums darīt arī kaut ko
līdzīgu. 

2192
01:40:23,290 --> 01:40:23,890
Labi.

2193
01:40:23,890 --> 01:40:26,093
Kā būtu, ja mēs uz brīdi atgrieztos
pie virknēm?

2194
01:40:26,093 --> 01:40:29,260
Un visi šie piemēri, kā vienmēr,
vēlāk būs pieejami kursa vietnē.

2195
01:40:29,260 --> 01:40:31,060
Pieņemsim, ka mēs vēlamies veikt
kaut ko līdzīgu rakstzīmju 

2196
01:40:31,060 --> 01:40:32,860
pārvēršanai par lielajiem burtiem. 

2197
01:40:32,860 --> 01:40:35,170
Nu, lai būtu skaidrs, es varētu
darīt kaut ko līdzīgu šim.

2198
01:40:35,170 --> 01:40:38,080
Ļaujiet man izveidot programmu ar
nosaukumu uppercase.py.

2199
01:40:38,080 --> 01:40:41,295
Ļaujiet man prasīt lietotājam
ievadīt pirmo virkni, izmantojot 

2200
01:40:41,295 --> 01:40:44,510
ievades funkciju vai get_string,
kas ir gandrīz tas pats. 

2201
01:40:44,510 --> 01:40:47,110
Un es iepriekš palūgšu lietotājam
ievadīt virkni.

2202
01:40:47,110 --> 01:40:51,410
Pēc tam ļaujiet man izdrukāt
atslēgvārdu “After” un pēc tam jauno 

2203
01:40:51,410 --> 01:40:55,710
rindiņu pabeigt ar neko, lai es
varētu redzēt “Before” vienā rindiņā 

2204
01:40:55,710 --> 01:41:00,010
un “After” nākamajā rindā. 

2205
01:41:00,010 --> 01:41:03,710
Un tad ļaujiet man darīt šo — un
šeit ir vieta, kur Python kļūst 

2206
01:41:03,710 --> 01:41:07,410
patīkama arī ar cilpām — ar c iekš
before — izdrukāt c.upper, end, 

2207
01:41:07,410 --> 01:41:11,110
vienāds, pēdiņās. 

2208
01:41:11,110 --> 01:41:12,580
Un tad es to izdrukāšu šeit.

2209
01:41:12,580 --> 01:41:13,120
Labi.

2210
01:41:13,120 --> 01:41:15,950
Tas bija ātri, bet mēģināsim
secināt, kas notiek.

2211
01:41:15,950 --> 01:41:17,775
Tātad 1. rindiņa vienkārši saņem
ievadi no lietotāja, saglabā to 

2212
01:41:17,775 --> 01:41:19,600
mainīgajā, kas tika izsaukts
iepriekš. 

2213
01:41:19,600 --> 01:41:22,450
Otrā rinda burtiski tikai izdrukā
“After”, bet nepārvieto kursoru uz 

2214
01:41:22,450 --> 01:41:25,300
nākamo rindiņu. 

2215
01:41:25,300 --> 01:41:27,015
Ko tad tā dara, ir šis.

2216
01:41:27,015 --> 01:41:29,875
Un C valodā tas bija nedaudz
kaitinošāk.

2217
01:41:29,875 --> 01:41:31,450
Jums bija nepieciešama for cilpa ar
i.

2218
01:41:31,450 --> 01:41:34,690
Jums bija nepieciešams masīva
apzīmējums ar kvadrātiekavām.

2219
01:41:34,690 --> 01:41:38,830
Bet, Python valodā, ja sakāt
mainīgajam virknē — tātad c, rakstzīmei 

2220
01:41:38,830 --> 01:41:42,970
virknē, Python automātiski piešķirs
c pirmajam lietotāja ievadītajam 

2221
01:41:42,970 --> 01:41:47,110
burtam. 

2222
01:41:47,110 --> 01:41:48,427
Pēc tam nākamajā atkārtojumā -
otrais burts, trešais burts un 

2223
01:41:48,427 --> 01:41:49,745
ceturtais. 

2224
01:41:49,745 --> 01:41:52,830
Tātad jums nav nepieciešams
apzīmējums kvadrātiekavās, vienkārši 

2225
01:41:52,830 --> 01:41:55,915
izmantojiet c, un Python to izdarīs
jūsu vietā un atdos jums pa 

2226
01:41:55,915 --> 01:41:59,000
vienam katru lietotāja ievadīto
burtu. 

2227
01:41:59,000 --> 01:42:03,093
Tātad, ja es atgriezīšos šeit un
palaistu, piemēram, python no 

2228
01:42:03,093 --> 01:42:07,186
uppercase.py un ierakstīšu “david”
ar mazajiem burtiem un nospiedīšu 

2229
01:42:07,186 --> 01:42:11,279
Enter, tad jūsredzēsiet to visu
lielajiem burtiem, atkārtojot to, 

2230
01:42:11,279 --> 01:42:15,372
patiešām, pa vienai rakstzīmei. 

2231
01:42:15,372 --> 01:42:18,281
Taču mēs jau zinām, ka, pateicoties
objektorientētai programmēšanai, 

2232
01:42:18,281 --> 01:42:21,190
pašām virknēm ir iebūvēta
funkcionalitāte, kas nodrošina ne tikai 

2233
01:42:21,190 --> 01:42:24,100
atsevišķus lielos burtus, bet arī
visu virkni. 

2234
01:42:24,100 --> 01:42:26,530
Tātad, godīgi sakot, šis bija
mazliet muļķīgs vingrinājums.

2235
01:42:26,530 --> 01:42:31,360
Man vairs nav jāizmanto cilpa,
piemēram, kā valodā C.

2236
01:42:26,530 --> 01:42:31,330
Un tāpēc ir pienācis laiks lauzt
dažus no ieradumiem, kurus esat 

2237
01:42:31,330 --> 01:42:36,130
attīstījuši pēdējo nedēļu laikā,
tad, kad tie nav nepieciešami. 

2238
01:42:36,130 --> 01:42:39,865
Es varu izveidot mainīgo, ko sauc
after, iestatīt to vienādu ar 

2239
01:42:39,865 --> 01:42:43,600
before.upper — kas patiešām pastāv,
tāpat kā punkts, lower. 

2240
01:42:43,600 --> 01:42:47,033
Un tad es varu iet uz priekšu un
izdrukāt, piemēram, - atbrīvosimies 

2241
01:42:47,033 --> 01:42:50,466
no šīs drukas līnijas šeit un
izpildīsim to beigās - “After” un 

2242
01:42:50,466 --> 01:42:53,900
izdrukāsim šī mainīgā vērtību. 

2243
01:42:53,900 --> 01:42:57,175
Tātad tagad, ja es atkārtoti
palaistu uppercase.py, ierakstītu 

2244
01:42:57,175 --> 01:43:00,450
“david” mazajiem burtiem, es varu
visu uzreiz rakstīt lielajiem 

2245
01:43:00,450 --> 01:43:03,725
burtiem, jo atkal Python valodā
jums nav jāstrādā ar rakstzīmēm 

2246
01:43:03,725 --> 01:43:07,000
atsevišķi. 

2247
01:43:07,000 --> 01:43:13,310
Vai ir jautājumi par kādu no šiem
trikiem?

2248
01:43:13,310 --> 01:43:13,810
Nav?

2249
01:43:13,810 --> 01:43:14,290
Labi.

2250
01:43:14,290 --> 01:43:16,217
Kā būtu ar dažām citām metodēm,
kuras mēs redzējām valodā C, kuras 

2251
01:43:16,217 --> 01:43:18,145
mēs tagad atgriezīsim Python
valodā. 

2252
01:43:18,145 --> 01:43:21,252
Izrādās, ka valodā Python ir arī
citas bibliotēkas, kuras varat 

2253
01:43:21,252 --> 01:43:24,360
izmantot, lai atklātu vēl vairāk
funkcionalitātes. 

2254
01:43:24,360 --> 01:43:28,052
Tātad, C valodā, ja vēlaties
komandrindas argumentus, vienkārši 

2255
01:43:28,052 --> 01:43:31,745
mainiet parakstu, lai galvenā
funkcija būtu, nevis void, int, argc, 

2256
01:43:31,745 --> 01:43:35,437
komats, virkne, argv, beigās
atveriet iekavas masīvam vai char 

2257
01:43:35,437 --> 01:43:39,130
zvaigznei. 

2258
01:43:39,130 --> 01:43:42,604
Izrādās, Python valodā, ja vēlaties
piekļūt komandrindas argumentiem, 

2259
01:43:42,604 --> 01:43:46,078
tas ir nedaudz vienkāršāk, taču tie
ir ievietoti bibliotēkā — citādi 

2260
01:43:46,078 --> 01:43:49,552
pazīstamai kā modulis — ko sauc par
sys, sistēmas moduli. 

2261
01:43:49,552 --> 01:43:51,677
Tagad tas pēc būtības ir līdzīgi
CS50 bibliotēkai, un tajā ir daudz 

2262
01:43:51,677 --> 01:43:53,802
funkcionalitātes. 

2263
01:43:53,802 --> 01:43:55,725
Bet tā nāk ar pašu Python.

2264
01:43:55,725 --> 01:43:58,617
Tātad, ja es vēlos izveidot tādu
programmu kā greet.py, VS Code, 

2265
01:43:58,617 --> 01:44:01,510
šeit, ļaujiet man paturpinātun
izdarīt šo. 

2266
01:44:01,510 --> 01:44:05,785
No sys bibliotēkas importēsim argv.

2267
01:44:05,785 --> 01:44:07,850
Un tā tas arī pastāv.

2268
01:44:07,850 --> 01:44:09,255
Tas nav iebūvēts galvenajā
funkcijā, jo vairs nav galvenās funkcijas 

2269
01:44:09,255 --> 01:44:10,660
kā tādas. 

2270
01:44:10,660 --> 01:44:12,590
Tātad tas ir paslēpts tajā
bibliotēkā.

2271
01:44:12,590 --> 01:44:14,330
Un tagad es varu darīt kaut ko
līdzīgu šim.

2272
01:44:14,330 --> 01:44:17,871
Ja argv garums ir vienāds ar 2, tad
izdrukāsim kaut ko draudzīgu, 

2273
01:44:17,871 --> 01:44:21,413
piemēram, hello, komats, argv,
iekavas, 1, un pēc tam aizveriet 

2274
01:44:21,413 --> 01:44:24,955
pēdiņas. 

2275
01:44:24,955 --> 01:44:27,677
Citādi, ja argv garums nav vienāds
ar 2, tad turpināsim un izdrukāsim 

2276
01:44:27,677 --> 01:44:30,400
hello, world. 

2277
01:44:30,400 --> 01:44:32,725
Tagad, vienā acu uzmetienā, tas
varētu šķist nedaudz sarežģīti, taču 

2278
01:44:32,725 --> 01:44:35,050
tas ir identiski tam, ko mēs
darījām pirms dažām nedēļām. 

2279
01:44:35,050 --> 01:44:38,743
Kad es palaižu šo python no
greet.py, bez argumentiem, tā vienkārši 

2280
01:44:38,743 --> 01:44:42,437
saka “hello, world”. Bet, ja es tā
vietā pievienoju komandrindas 

2281
01:44:42,437 --> 01:44:46,131
argumentu, piemēram, savu vārdu, un
nospiežu taustiņu Enter, tagad 

2282
01:44:46,131 --> 01:44:49,825
argv garums vairs nav 1. 

2283
01:44:49,825 --> 01:44:51,700
Tas būs 2.

2284
01:44:51,700 --> 01:44:54,680
Tā vietā tā izdrukās “Hello,
David”.

2285
01:44:54,680 --> 01:44:58,271
Tātad šeit būtiskākais ir tas, ka C
valodā argv tehniski saturēja 

2286
01:44:58,271 --> 01:45:01,863
jūsu programmas nosaukumu,
piemēram, ./hello vai ./greet, un pēc tam 

2287
01:45:01,863 --> 01:45:05,455
visu, ko ievadīja cilvēks. 

2288
01:45:05,455 --> 01:45:09,000
Python šajā ziņā nedaudz atšķiras,
jo mēs izmantojam tulku šādā 

2289
01:45:09,000 --> 01:45:12,545
veidā — tehniski, palaižot python
no greet.py, argv garums ir tikai 

2290
01:45:12,545 --> 01:45:16,090
1. 

2291
01:45:16,090 --> 01:45:18,760
Tajā ir tikai greet.py, tātad
datnes nosaukums.

2292
01:45:18,760 --> 01:45:24,460
Tas neobligāti satur pašu Python,
jo kāda jēga tai būt visuresošai?

2293
01:45:24,460 --> 01:45:28,760
Tas satur vārdu skaitu, ko cilvēks
ierakstīja pēc pašas Python.

2294
01:45:28,760 --> 01:45:32,230
Tātad argv šeit ir garums 1.

2295
01:45:28,760 --> 01:45:32,230
argv šeit ir garums 2.

2296
01:45:32,230 --> 01:45:36,130
Un tāpēc, kad tas bija vienāds ar
2, es redzēju “Hello, David”, nevis 

2297
01:45:36,130 --> 01:45:40,030
noklusējuma “Hello, world”. Tāda
pati iespēja piekļūt komandrindas 

2298
01:45:40,030 --> 01:45:43,930
argumentiem, pievienot šāda veida
ievades savām funkcijām, taču jums 

2299
01:45:43,930 --> 01:45:47,830
tā ir jāatbloķē, tā vietā
izmantojot argv, šādā veidā. 

2300
01:45:47,830 --> 01:45:51,910
Ja vēlaties redzēt visus vārdus,
varat rīkoties šādi.

2301
01:45:51,910 --> 01:45:55,760
Tāpat kā - ja mēs apvienojam
idejas, šeit - i , kā būtu, argv garuma 

2302
01:45:55,760 --> 01:45:59,610
diapazonā. 

2303
01:45:59,610 --> 01:46:02,260
Pēc tam es varu darīt to — izdrukāt
argv, iekavas, i.

2304
01:46:02,260 --> 01:46:02,860
Labi.

2305
01:46:02,860 --> 01:46:05,635
Nedaudz sarežģīti, bet 3. rindiņa
ir tikai for cilpa, kas atkārtojas 

2306
01:46:05,635 --> 01:46:08,410
argv garuma diapazonā. 

2307
01:46:08,410 --> 01:46:12,640
Tātad, ja cilvēki raksta divos
vārdos, argv garums būs 2.

2308
01:46:12,640 --> 01:46:15,510
Tad šis ir tikai veids, kā pateikt,
atkārtojiet visus vārdus argv, 

2309
01:46:15,510 --> 01:46:18,380
izdrukājot tos pa vienam. 

2310
01:46:18,380 --> 01:46:20,595
Tātad python no greet.py, Enter
vienkārši izdrukā programmas 

2311
01:46:20,595 --> 01:46:22,810
nosaukumu. 

2312
01:46:22,810 --> 01:46:27,340
python no greet.py ar Deividu
izdrukā greet.py un pēc tam Deivids.

2313
01:46:27,340 --> 01:46:29,995
Es varu turpināt to laist ar
vairākiem vārdiem, un tie tiks izdrukāti 

2314
01:46:29,995 --> 01:46:32,650
pa vienam. 

2315
01:46:32,650 --> 01:46:35,785
Bet kas vēl ir patīkams Python
valodā — un šī ir šī uzdevuma būtība — 

2316
01:46:35,785 --> 01:46:38,920
godīgi sakot, tas izskatās diezgan
sarežģīti. 

2317
01:46:38,920 --> 01:46:40,720
Uz to nav īpaši patīkami skatīties.

2318
01:46:40,720 --> 01:46:44,200
Ja vēlaties tikai atkārtot katru
vārdu sarakstā, kas ir argv, 

2319
01:46:44,200 --> 01:46:47,680
skatieties, ko es varu izdarīt. 

2320
01:46:47,680 --> 01:46:52,090
Es to varu izdarīt arg vai jebkuram
mainīgā nosaukumam iekš argv.

2321
01:46:52,090 --> 01:46:54,147
Ļaujiet man tikai tagad izdrukāt šo
argumentu.

2322
01:46:54,147 --> 01:46:55,563
Es varētu turpināt to saukt par i,
bet i izskatās dīvaini, ja tas nav 

2323
01:46:55,563 --> 01:46:56,980
numurs. 

2324
01:46:56,980 --> 01:46:59,710
Tā vietā es pāreju uz arg kā vārdu.

2325
01:46:59,710 --> 01:47:03,970
Ja es tagad veicu python no
greet.py, tas dara šo.

2326
01:47:03,970 --> 01:47:06,460
Ja es izmantoju python no greet.py,
Deivid, tas atkal to dara.

2327
01:47:06,460 --> 01:47:08,690
Deivids Malans, tas atkal to dara.

2328
01:47:08,690 --> 01:47:10,898
Tāpēc, atkal, Python ir tik ļoti
pievilcīga.

2329
01:47:10,898 --> 01:47:13,482
Vai vēlaties kaut ko darīt vairākas
reizes, atkārtot sarakstu?

2330
01:47:13,482 --> 01:47:15,820
Vienkārši pasakiet to, un tas skan
ļoti līdzīgi angļu valodai.

2331
01:47:15,820 --> 01:47:18,130
Un, ja drīkst, tai ir arī citas
stilīgas iezīmes.

2332
01:47:18,130 --> 01:47:21,385
Tas ir nedaudz muļķīgi, ka es
pastāvīgi redzu programmas nosaukumu - 

2333
01:47:21,385 --> 01:47:24,640
greet.py, tāpēc būtu jauki, ja es
to varētu noņemt. 

2334
01:47:24,640 --> 01:47:27,490
Python atbalsta arī tā sauktās
masīvu sektorus — atvainojiet, 

2335
01:47:27,490 --> 01:47:30,340
sarakstu sektorus. 

2336
01:47:30,340 --> 01:47:32,050
Pat es jaucu terminoloģiju.

2337
01:47:32,050 --> 01:47:36,400
Ja argv ir saraksts, tad tas
izdrukās visu tajā esošo.

2338
01:47:36,400 --> 01:47:39,855
Bet, ja es vēlos sektoru no tā, kas
sākas lokācijā 1 un iet līdz 

2339
01:47:39,855 --> 01:47:43,310
galam, varat izmantot šo dīvaino
sintaksi pa vidu starp 

2340
01:47:43,310 --> 01:47:46,765
kvadrātiekavām, kuras mēs vēl
neesam redzējuši. Tas sāksies ar 

2341
01:47:46,765 --> 01:47:50,220
1. vienību un turpināsies līdz
galam. 

2342
01:47:50,220 --> 01:47:54,113
Tātad, šis ir jauks, gudrs veids,
kā nodalīt pašu pirmo elementu, jo 

2343
01:47:54,113 --> 01:47:58,006
tagad, kad es palaižu greet.py,
David Malan, man vajadzētu redzēt 

2344
01:47:58,006 --> 01:48:01,900
tikai Deividu un Malanu. 

2345
01:48:01,900 --> 01:48:04,940
Ja es vēlos tikai vienu elementu,
es varētu darīt no 1 līdz 2.

2346
01:48:04,940 --> 01:48:08,260
Ja es gribu tos visus, es turpmāk
varētu darīt 0.

2347
01:48:08,260 --> 01:48:10,900
Šādā veidā es varētu sev uzdāvināt
tikai vienu no tiem.

2348
01:48:10,900 --> 01:48:13,960
Tātad jūs varat spēlēt ar sākuma un
beigu vērtību šādā veidā, lai 

2349
01:48:13,960 --> 01:48:17,020
sadalītu šos sarakstus dažādos
veidos. 

2350
01:48:17,020 --> 01:48:21,930
Tas būtu bijis sāpīgi C valodā
tikai tāpēc, ka mums nebija tāda 

2351
01:48:21,930 --> 01:48:26,840
iebūvētā atbalsta tik tīrai
manipulēšanai ar masīviem kā šis. 

2352
01:48:26,840 --> 01:48:27,340
Labi.

2353
01:48:27,340 --> 01:48:30,406
Lai arī jūs to esat redzējuši — lai
gan šo ir ne tik aizraujoši 

2354
01:48:30,406 --> 01:48:33,473
skatīties tiešraidē — ja es turpinu
un izveidoju šeit ātru programmu, 

2355
01:48:33,473 --> 01:48:36,539
izrādās, ka sys bibliotēkā ir kaut
kas cits, iespēja iziet no 

2356
01:48:36,539 --> 01:48:39,606
programmām — iziet ar statusa kodu
1 vai 0, kā mēs to darām ikreiz, 

2357
01:48:39,606 --> 01:48:42,673
kad kaut kas noiet pareizi vai
nepareizi. 

2358
01:48:42,673 --> 01:48:46,772
Tā, piemēram, ļaujiet man izveidot
ātru programmu, kas vienkārši 

2359
01:48:46,772 --> 01:48:50,871
saka: ja sys.argv garums nav
vienāds ar 2, tad kliegsim uz lietotāju 

2360
01:48:50,871 --> 01:48:54,970
un teiksim, ka viņam trūkst
komandrindas argumenta. 

2361
01:48:54,970 --> 01:48:57,380
Pretējā gadījumā komandrindas
arguments.

2362
01:48:57,380 --> 01:49:01,360
Un tad atgriezīsim sys.exit(1).

2363
01:49:01,360 --> 01:49:05,500
Citādi, turpināsim un, loģiski,
vienkārši teiksim, lai izdrukā 

2364
01:49:05,500 --> 01:49:09,640
formatētu virkni, kas saka sveiki —
tāpat kā iepriekš — sys.argv 1. 

2365
01:49:09,640 --> 01:49:13,312
Tagad lietas pēkšņi izskatās
savādāk, bet es kaut ko daru apzināti.

2366
01:49:13,312 --> 01:49:14,870
Pirmkārt, paskatīsimies, ko tas
dara.

2367
01:49:14,870 --> 01:49:18,730
Tātad 1. rindā es importēju nevis
argv, konkrēti.

2368
01:49:18,730 --> 01:49:22,150
Es importēju visu sys bibliotēku,
un pēc brīža mēs redzēsim - kāpēc.

2369
01:49:22,150 --> 01:49:26,760
Izrādās, ka sys bibliotēkā ir ne
tikai argv saraksts, bet arī 

2370
01:49:26,760 --> 01:49:31,370
funkcija exit, kuru es arī vēlētos
izmantot. 

2371
01:49:31,370 --> 01:49:33,285
Tātad izrādās, ka, ja šādā veidā
importējat visu bibliotēku, tas ir 

2372
01:49:33,285 --> 01:49:35,200
labi. 

2373
01:49:35,200 --> 01:49:39,090
Bet jums ir jāatsaucas uz tajā
esošajām lietām, izmantojot to pašu 

2374
01:49:39,090 --> 01:49:42,980
bibliotēkas nosaukumu un punktu,
lai to, tā sakot, nosauktu. 

2375
01:49:42,980 --> 01:49:45,306
Tātad šeit es tikai saku, ja
lietotājs neievada divus vārdus, 

2376
01:49:45,306 --> 01:49:47,633
kliedziet uz viņu ar trūkstošu
komandrindas argumentu un pēc tam 

2377
01:49:47,633 --> 01:49:49,960
izejiet ar 1. 

2378
01:49:49,960 --> 01:49:51,467
Tāpat kā valodā C, izejot no 1,
vienkārši nozīmē, ka kaut kas nogāja 

2379
01:49:51,467 --> 01:49:52,975
greizi. 

2380
01:49:52,975 --> 01:49:54,785
Pretējā gadījumā izdrukājiet hello.

2381
01:49:54,785 --> 01:49:57,910
Un tas sāk izskatīties sarežģīti,
bet tas ir tikai ideju kombinācija.

2382
01:49:57,910 --> 01:50:02,080
Figūriekavas nozīmē: interpolēt šo
vērtību, ievietojot to šeit.

2383
01:50:02,080 --> 01:50:05,545
sys.argv ir tikai precīzs veids, kā
pateikt:dodieties uz sys 

2384
01:50:05,545 --> 01:50:09,010
bibliotēku un iegūstiet tajā
mainīgo argv. 

2385
01:50:09,010 --> 01:50:12,225
Un 1. iekavas, protams, tāpat kā
masīvi C valodā, ir tikai otrais 

2386
01:50:12,225 --> 01:50:15,440
elements uzvednē. 

2387
01:50:15,440 --> 01:50:18,390
Kad es palaižu šo versiju, tagad —
python no exit.py — bez 

2388
01:50:18,390 --> 01:50:21,340
argumentiem, uz mani tiek kliegts
šādā veidā. 

2389
01:50:21,340 --> 01:50:25,195
Tomēr, ja es ievadu kopā divus
argumentus — datnes nosaukumu un savu 

2390
01:50:25,195 --> 01:50:29,050
vārdu — tagad mani sveicina ar
hello, David. 

2391
01:50:29,050 --> 01:50:30,310
Un tā ir tā pati ideja iepriekš.

2392
01:50:30,310 --> 01:50:33,160
Šī bija ļoti zema līmeņa tehnika,
bet šeit tas pats.

2393
01:50:33,160 --> 01:50:36,165
Ja nospiežat atbalss, dolāra zīme,
jautājuma zīme, Enter, jūs 

2394
01:50:36,165 --> 01:50:39,170
redzēsiet savas programmas izejas
kodu. 

2395
01:50:39,170 --> 01:50:41,895
Tātad, ja es to daru nepareizi -
ļaujiet man to atkārtot bez sava 

2396
01:50:41,895 --> 01:50:44,620
vārda, Enter - uz mani kliedz. 

2397
01:50:44,620 --> 01:50:47,395
Bet, ja es izmantoju atbalss,
dolāra zīme, jautājuma zīme, tiek 

2398
01:50:47,395 --> 01:50:50,170
atgriezta slepenā zīme. 

2399
01:50:50,170 --> 01:50:54,160
Atkal, lai parādītu jums paritāti
ar valodu C, šajā gadījumā.

2400
01:50:54,160 --> 01:50:56,320
Vai jums ir jautājumi par kādu no
šīm metodēm?

2401
01:50:58,900 --> 01:50:59,400
Nav.

2402
01:50:59,400 --> 01:51:00,030
Labi.

2403
01:51:00,030 --> 01:51:02,580
Kā būtu ar kaut ko vēl, kas ir
nedaudz spēcīgāks?

2404
01:51:02,580 --> 01:51:05,205
Mēs pavadām tik daudz laika 0. un
1. nedēļā, veicot meklēšanu un pēc 

2405
01:51:05,205 --> 01:51:07,830
tam 3. nedēļā šķirošanu. 

2406
01:51:07,830 --> 01:51:10,288
Izrādās, ka Python valoda var
palīdzēt arī šajā jautājumā.

2407
01:51:10,288 --> 01:51:13,469
Ļaujiet man turpināt un izveidot
programmu names.py, kas būs tikai 

2408
01:51:13,469 --> 01:51:16,650
iespēja, iespējams, meklēt visā
vārdu kaudzē. 

2409
01:51:16,650 --> 01:51:21,060
Ļaujiet man importēt sys, lai man
būtu piekļuve iziešanai.

2410
01:51:21,060 --> 01:51:23,908
Un ļaujiet man turpināt un izveidot
mainīgo ar nosaukumu names, kas 

2411
01:51:23,908 --> 01:51:26,756
būs saraksts ar veselu kaudzi
vārdu. 

2412
01:51:26,756 --> 01:51:27,660
Kā būtu šeit?

2413
01:51:27,660 --> 01:51:31,200
Čārlijs un Freds un Džordžs un
Džinnija un Persijs un, visbeidzot, 

2414
01:51:31,200 --> 01:51:34,740
Rons. 

2415
01:51:34,740 --> 01:51:36,290
Tātad šeit vesela kaudze vārdu.

2416
01:51:36,290 --> 01:51:39,727
Un tas būtu nedaudz kaitinoši
ieviest kodu C valodā, kas atkārtojas 

2417
01:51:39,727 --> 01:51:43,165
no kreisās puses uz labo, meklējot
kādu no šiem vārdiem. 

2418
01:51:43,165 --> 01:51:43,957
Starp citu, kāds?

2419
01:51:43,957 --> 01:51:47,208
Lūgsim lietotājam ievadīt meklējamo
nosaukumu, lai mēs varētu 

2420
01:51:47,208 --> 01:51:50,460
pateikt, vai nosaukums tur ir vai
nav. 

2421
01:51:50,460 --> 01:51:52,565
Un mēs varētu darīt to, līdzīgi kā
C, Python valodā, darot kaut ko 

2422
01:51:52,565 --> 01:51:54,670
līdzīgu šim. 

2423
01:51:54,670 --> 01:51:58,586
Tātad n vārdos, kur n ir tikai
mainīgais, kas atkārtojas pār katru 

2424
01:51:58,586 --> 01:52:02,502
vārdu — ja meklētais vārds ir
vienāds ar pašreizējo vārdu sarakstā — 

2425
01:52:02,502 --> 01:52:06,418
AKA n — labi, izdrukāsim kaut ko
draudzīgu, piemēram, “Found”. Un pēc 

2426
01:52:06,418 --> 01:52:10,334
tam izpildīsim sys.exit 0, lai
norādītu, ka esam atraduši to, kurš 

2427
01:52:10,334 --> 01:52:14,250
tas ir. 

2428
01:52:14,250 --> 01:52:17,295
Pretējā gadījumā, ja mēs nonākam
līdz apakšai šeit, ārpus šīs cilpas, 

2429
01:52:17,295 --> 01:52:20,340
vienkārši izdrukāsim “Not found”,
ja mēs vēl neesam izgājuši. 

2430
01:52:20,340 --> 01:52:22,800
Un tad izejam ar 1.

2431
01:52:22,800 --> 01:52:26,280
Lai būtu skaidrs, es varu turpināt
visu sys importēšanu vai arī no 

2432
01:52:26,280 --> 01:52:29,760
sys importēšanas izejas, un tad es
varētu atbrīvoties no sys, punkts 

2433
01:52:29,760 --> 01:52:33,240
visur citur. 

2434
01:52:33,240 --> 01:52:36,540
Bet dažreiz ir noderīgi precīzi
zināt, no kurienes nāk funkcijas.

2435
01:52:36,540 --> 01:52:39,675
Tātad arī tas šajā gadījumā ir
tikai stila jautājums.

2436
01:52:39,675 --> 01:52:40,230
Labi.

2437
01:52:40,230 --> 01:52:41,522
Tāpēc iesim uz priekšu un
izpildīsim šo.

2438
01:52:41,522 --> 01:52:46,540
python no names.py, un beigās
meklēsim Ronu.

2439
01:52:46,540 --> 01:52:47,040
Labi.

2440
01:52:47,040 --> 01:52:47,910
Viņš ir atrasts.

2441
01:52:47,910 --> 01:52:51,570
Un meklēsim šeit kādu ārpus
ģimenes, piemēram, Hermioni.

2442
01:52:51,570 --> 01:52:52,700
Nav atrasts.

2443
01:52:52,700 --> 01:52:53,200
Labi.

2444
01:52:53,200 --> 01:52:54,783
Tātad šķiet, ka tas darbojas šādā
veidā.

2445
01:52:54,783 --> 01:52:58,548
Bet kādu algoritmu es būtībā esmu
ieviesis?

2446
01:52:58,548 --> 01:53:05,247
Kāds algoritms varētu būt 7. un 8.
līdz 9. un 10. rindai?

2447
01:53:05,247 --> 01:53:05,955
Mērķauditorija: Lineārs.

2448
01:53:05,955 --> 01:53:06,450
DEIVIDS MALANS: Jā.

2449
01:53:06,450 --> 01:53:07,350
Tātad tā ir tikai lineāra
meklēšana.

2450
01:53:07,350 --> 01:53:09,705
Tā ir cilpa, pat ja sintakse šodien
ir daudz īsāka, un tā tikai 

2451
01:53:09,705 --> 01:53:12,060
atkārtojas. 

2452
01:53:12,060 --> 01:53:13,650
Godīgi sakot, mēs esam redzējuši
vēl vienkāršāku veidu, kā to izdarīt 

2453
01:53:13,650 --> 01:53:15,240
Python valodā. 

2454
01:53:15,240 --> 01:53:19,230
Un tas dažreiz padara to par
patīkamāku valodu.

2455
01:53:19,230 --> 01:53:20,630
Kāpēc es to nedaru?

2456
01:53:20,630 --> 01:53:24,790
Tā vietā, lai atkārtotu pa vienam,
kāpēc es to nesaku?

2457
01:53:24,790 --> 01:53:29,030
Ļaujiet man turpināt un mainīt savu
nosacījumu uz vienkārši  — kā 

2458
01:53:29,030 --> 01:53:33,270
būtu, ja mūsu meklētais vārds ir
vārdu sarakstā, mēs esam pabeiguši. 

2459
01:53:33,270 --> 01:53:33,960
Mēs to atradām.

2460
01:53:33,960 --> 01:53:37,335
Izmantojiet beigu prievārdu, ko
esam redzējuši pāris reizes, tagad, 

2461
01:53:37,335 --> 01:53:40,710
kad tā pati uzdod jautājumu, vai
kaut kas ir kaut kas citā? 

2462
01:53:40,710 --> 01:53:44,050
Un Python valoda parūpēsies par
lineāro meklēšanu mūsu vietā.

2463
01:53:44,050 --> 01:53:46,040
Un tā darbosies tieši tāpat, ja es
veicu python no names.py, meklēju 

2464
01:53:46,040 --> 01:53:48,030
Ron. 

2465
01:53:48,030 --> 01:53:49,845
Tā joprojām viņu atradīs, un šajā
gadījumā tā joprojām darīs to 

2466
01:53:49,845 --> 01:53:51,660
lineāri. 

2467
01:53:51,660 --> 01:53:58,060
Bet šajā gadījumā man pašam nav
jāraksta viss zemākā līmeņa kods.

2468
01:53:58,060 --> 01:54:02,430
Vai tagad ir jautājumi par kādu no
šiem tematiem?

2469
01:54:02,430 --> 01:54:05,380
Kods kļūst arvien īsāks.

2470
01:54:05,380 --> 01:54:05,880
Nav?

2471
01:54:05,880 --> 01:54:07,740
Kas par... paskatīsimies.

2472
01:54:07,740 --> 01:54:09,250
Kas vēl mums šeit varētu būt?

2473
01:54:09,250 --> 01:54:10,770
Kā ar šo?

2474
01:54:10,770 --> 01:54:13,230
Dosimies uz priekšu un ieviesīsim
to tālruņu katalogu, ar kuru mēs, 

2475
01:54:13,230 --> 01:54:15,690
metaforiski, sākām kursa sākumā. 

2476
01:54:15,690 --> 01:54:17,940
Iekodēsim programmu phonebook.py.

2477
01:54:17,940 --> 01:54:22,440
Un šajā gadījumā turpināsim un
šoreiz veidosim vārdnīcu.

2478
01:54:22,440 --> 01:54:26,040
Atcerieties, ka vārdnīca ir kaut
kas tāds, kas ievieš kaut ko līdzīgu 

2479
01:54:26,040 --> 01:54:29,640
šim — divu kolonnu tabula, kurā ir
taustiņi un vērtības, vārdi un 

2480
01:54:29,640 --> 01:54:33,240
definīcijas, vārdi un numuri. 

2481
01:54:33,240 --> 01:54:36,367
Un šajā gadījumā pievērsīsimies
pēdējam no tiem, vārdiem un numuriem.

2482
01:54:36,367 --> 01:54:39,573
Es jau iepriekš apgalvoju, ka
Python valodā ir iebūvēts atbalsts 

2483
01:54:39,573 --> 01:54:42,780
vārdnīcām — dict objects — ko varat
izveidot ar vienu rindiņu. 

2484
01:54:42,780 --> 01:54:44,390
Man tas nebija vajadzīgs
pareizrakstības programmai, jo komplekts ir 

2485
01:54:44,390 --> 01:54:46,000
pietiekams, ja vēlaties tikai vienu
no taustiņiem vai vērtībām, nevis 

2486
01:54:46,000 --> 01:54:47,610
abas. 

2487
01:54:47,610 --> 01:54:49,680
Bet tagad es gribu dažus vārdus un
numurus.

2488
01:54:49,680 --> 01:54:52,680
Izrādās, ka Python var izveidot
tukšu vārdnīcu, sakot dict, atvērt 

2489
01:54:52,680 --> 01:54:55,680
iekavas, aizvērt. 

2490
01:54:55,680 --> 01:54:59,640
Un tas tikai dod jums būtībā
diagrammu, kas izskatās šādi, bez nekā.

2491
01:54:59,640 --> 01:55:01,725
Vai te ir arī precīzāka sintakse.

2492
01:55:01,725 --> 01:55:06,858
Varat arī to izdarīt ar divām
figūriekavām.

2493
01:55:06,858 --> 01:55:09,150
Un patiesībā visu šo laiku esmu
izmantojis īsceļu.

2494
01:55:09,150 --> 01:55:13,312
Kad man agrāk bija saraksts, kurā
manu mainīgo sauca par rādītājiem, 

2495
01:55:13,312 --> 01:55:17,474
un es to darīju, patiesībā tā bija
šī saīsinātā versija — hei, 

2496
01:55:17,474 --> 01:55:21,637
Python, iedod man tukšu sarakstu. 

2497
01:55:21,637 --> 01:55:23,970
Tātad viena un tā paša mērķa
sasniegšanai ir atšķirīga sintakse.

2498
01:55:23,970 --> 01:55:28,250
Šajā gadījumā, ja es vēlos
cilvēkiem paredzētu vārdnīcu, es varu 

2499
01:55:28,250 --> 01:55:32,530
izdarīt šo vai, biežāk, tikai divas
figūriekavas, lūk, šādi. 

2500
01:55:32,530 --> 01:55:33,030
Labi.

2501
01:55:33,030 --> 01:55:34,360
Nu, ko es gribu ievietot šajā?

2502
01:55:34,360 --> 01:55:36,360
Nu, ļaujiet man šajā sakarā
ievietot dažas lietas.

2503
01:55:36,360 --> 01:55:37,860
Un es vienkārši pārvietošu savas
aizvērtas figūriekavas uz jaunu 

2504
01:55:37,860 --> 01:55:39,360
rindiņu. 

2505
01:55:39,360 --> 01:55:43,290
Ja es vēlos īstenot šo ideju par
taustiņiem un vērtībām, veids, kā 

2506
01:55:43,290 --> 01:55:47,220
jūs to darāt valodā Python, ir -
atslēga, kols, vērtība, komats. 

2507
01:55:47,220 --> 01:55:48,230
Taustiņš, kols, vērtība.

2508
01:55:48,230 --> 01:55:50,410
Tātad jūs to vairāk ieviestu kodā.

2509
01:55:50,410 --> 01:55:53,926
Piemēram, ja es vēlos, lai Kārters
būtu pirmais taustiņš manā tālruņu 

2510
01:55:53,926 --> 01:55:57,443
katalogā un viņa numurs būtu
+1-617-495-1000, es varu norādīt to kā 

2511
01:55:57,443 --> 01:56:00,960
atbilstošo vērtību. 

2512
01:56:00,960 --> 01:56:02,010
Kols atrodas pa vidu.

2513
01:56:02,010 --> 01:56:05,970
Abas ir virknes vai str, tāpēc es
apzināti lieku abus pēdiņās.

2514
01:56:05,970 --> 01:56:07,762
Ja gribu pievienot sevi, varu likt
komatu.

2515
01:56:07,762 --> 01:56:09,366
Un tad, lai lietas būtu skaistas,
es pārvietoju kursoru uz nākamo 

2516
01:56:09,366 --> 01:56:10,970
rindiņu. 

2517
01:56:10,970 --> 01:56:12,990
Bet tas estētiski nav stingri
nepieciešams.

2518
01:56:12,990 --> 01:56:13,865
Tas ir vienkārši labs stils.

2519
01:56:13,865 --> 01:56:19,500
Un šeit es varētu nosūtīt
+1-949-468-2750.

2520
01:56:19,500 --> 01:56:23,411
Un tagad man ir vārdnīca, kurā
būtībā ir divas rindas — Kārters un 

2521
01:56:23,411 --> 01:56:27,322
viņa numurs, kā arī Deivids un viņa
numurs. 

2522
01:56:27,322 --> 01:56:28,863
Un, ja es to turpinātu papildināt,
šī diagramma kļūtu tikai garāka un 

2523
01:56:28,863 --> 01:56:30,405
garāka. 

2524
01:56:30,405 --> 01:56:32,430
Pieņemsim, ka es vēlos meklēt kādu
no mūsu numuriem.

2525
01:56:32,430 --> 01:56:34,950
Pieprasīsim lietotājam vārdu, kura
numuru vēlaties meklēt, iegūstot 

2526
01:56:34,950 --> 01:56:37,470
virkni. 

2527
01:56:37,470 --> 01:56:38,560
Vai arī ziniet ko?

2528
01:56:38,560 --> 01:56:39,893
Mums nav vajadzīga šī CS50
bibliotēka.

2529
01:56:39,893 --> 01:56:43,090
Vienkārši izmantosim ievadi un
prasīsim lietotājam vārdu.

2530
01:56:43,090 --> 01:56:47,780
Un tagad mēs varam izmantot šo
īpaši īso sintaksi un vienkārši 

2531
01:56:47,780 --> 01:56:52,470
pateikt, ja vārds ir cilvēkos,
izdrukāt formatētu virknes skaitli, 

2532
01:56:52,470 --> 01:56:57,160
kols un — lūk, mēs to varam izdarīt
— persona, iekavas, vārds. 

2533
01:56:57,160 --> 01:56:57,930
Labi.

2534
01:56:57,930 --> 01:57:01,800
Tāpēc tas ātri kļūst forši,
mulsinoši.

2535
01:57:01,800 --> 01:57:02,805
Tāpēc ļaujiet man to palaist.

2536
01:57:02,805 --> 01:57:06,810
python no phonebook.py. Ierakstīsim
Kārters.

2537
01:57:06,810 --> 01:57:08,910
Un patiešām es redzu viņa numuru.

2538
01:57:08,910 --> 01:57:12,910
Palaidīsim to vēlreiz ar Deividu,
un es šeit redzu savu numuru.

2539
01:57:12,910 --> 01:57:14,590
Kas tad notiek?

2540
01:57:14,590 --> 01:57:19,320
Nu, izrādās, ka vārdnīca pēc
būtības ir ļoti līdzīga sarakstam.

2541
01:57:19,320 --> 01:57:22,350
Tā patiesībā pēc būtības ir ļoti
līdzīga masīvam C valodā.

2542
01:57:22,350 --> 01:57:26,520
Taču tā vietā, lai izmantotu tikai
ciparu taustiņus, piemēram, 

2543
01:57:26,520 --> 01:57:30,690
iekavas 0, iekavas 1, iekavas 2,
jūs faktiski varat izmantot vārdus. 

2544
01:57:30,690 --> 01:57:33,060
Un tas ir viss, ko es daru šeit, 8.
rindā.

2545
01:57:33,060 --> 01:57:36,795
Ja es vēlos pārbaudīt vārdu
Kārters, kas pašlaik ir iekļauts šajā 

2546
01:57:36,795 --> 01:57:40,530
mainīgajā ar nosaukumu name, es
varu indeksēt savā cilvēku vārdnīcā, 

2547
01:57:40,530 --> 01:57:44,265
izmantojot nevis ciparus, bet
burtiski izmantojot virkni — vārdu 

2548
01:57:44,265 --> 01:57:48,000
Kārters vai Deivids vai jebkādu
citu. 

2549
01:57:48,000 --> 01:57:51,047
Lai padarītu to skaidrāku,
ievērojiet, ka šobrīd izmantoju šo formāta 

2550
01:57:51,047 --> 01:57:54,095
virkni, kas rada pārmērīgu
sarežģītību. 

2551
01:57:54,095 --> 01:57:56,220
Bet es varētu to precizēt,
iespējams, šādi.

2552
01:57:56,220 --> 01:57:58,771
Es varētu dot sev citu mainīgo, ko
sauc par numuru, iestatīt to 

2553
01:57:58,771 --> 01:58:01,323
vienādu ar cilvēku vārdnīcu,
indeksējot tajā, izmantojot pašreizējo 

2554
01:58:01,323 --> 01:58:03,875
vārdu. 

2555
01:58:03,875 --> 01:58:06,892
Un tagad es varu to saīsināt, lai
būtu skaidrāks, ka es 

2556
01:58:06,892 --> 01:58:09,910
izdrukājutikai tā vērtību. 

2557
01:58:09,910 --> 01:58:12,930
Un patiesībā es to varu izdarīt vēl
sarežģītāk.

2558
01:58:12,930 --> 01:58:16,452
Tas būtu dīvaini, bet, ja es vēlos
parādīt tikai Deivida tālruņa 

2559
01:58:16,452 --> 01:58:19,975
numuru, nevis Kārtera numuru, es
varu burtiski, pēdiņās “index into” 

2560
01:58:19,975 --> 01:58:23,497
cilvēku vārdnīcā, jo tagad, kad es
to izpildu, pat tad, ja es 

2561
01:58:23,497 --> 01:58:27,020
ierakstu Kārtera numuru, tā vietā
es atgūšu savu numuru. 

2562
01:58:27,020 --> 01:58:31,080
Bet tas ir viss, kas notiek, ja es
to atsaukšu, jo tā tagad ir kļūda.

2563
01:58:31,080 --> 01:58:35,250
Bet es to indeksēju, izmantojot
vārda vērtību.

2564
01:58:35,250 --> 01:58:39,335
Vārdnīcas ir ļoti ērtas, jo tagad
jūs varat saistīt jebko, izmantojot 

2565
01:58:39,335 --> 01:58:43,420
nevis ciparus, bet gan veselus
atslēgvārdus. 

2566
01:58:43,420 --> 01:58:46,408
Tātad, ja pareizrakstības programmā
mēs jums sniegtu ne tikai vārdus, 

2567
01:58:46,408 --> 01:58:49,396
bet arī simtiem tūkstošu
definīciju, jūs tās varētu būtībā saglabāt 

2568
01:58:49,396 --> 01:58:52,385
šādi. 

2569
01:58:52,385 --> 01:58:56,336
Un tad, kad cilvēks vēlas meklēt
definīciju pareizā vārdnīcā, nevis 

2570
01:58:56,336 --> 01:59:00,288
tikai pareizrakstības pārbaudei,
jūs varat indeksēt vārdnīcu, 

2571
01:59:00,288 --> 01:59:04,240
izmantojot kvadrātiekavas, un atgūt
definīciju arī angļu valodā. 

2572
01:59:04,240 --> 01:59:06,770
Jautājumi par šo?

2573
01:59:06,770 --> 01:59:07,280
Jā?

2574
01:59:07,280 --> 01:59:11,744
sakot, ka Python ir [Nesadzirdami]?

2575
01:59:21,390 --> 01:59:22,890
DEIVIDS MALANS: Tiešām labs
jautājums.

2576
01:59:22,890 --> 01:59:27,330
Rezumējot, kā Python valoda atrod
šo vārdu šajā vārdnīcā?

2577
01:59:27,330 --> 01:59:31,110
Šeit, godīgi sakot, galvenais
Python valodā ir speller 5. p-set.

2578
01:59:31,110 --> 01:59:33,600
Tātad jūs esat cīnījušies, cīnāties
ar savas pareizrakstības 

2579
01:59:33,600 --> 01:59:36,090
pārbaudītāja ieviešanu un savas
jaucējtabulas ieviešanu. 

2580
01:59:36,090 --> 01:59:38,640
Un atcerieties, ka pagājušajā
nedēļā jaucējtabulas mērķis bija ideālā 

2581
01:59:38,640 --> 01:59:41,190
gadījumā iegūt pastāvīgu piekļuvi
laikam. 

2582
01:59:41,190 --> 01:59:44,295
Nevis kaut kas lineārs, kas ir lēns
un pat labāks par kaut ko 

2583
01:59:44,295 --> 01:59:47,400
logaritmisku, piemēram, žurnāla
bāze 2 no n. 

2584
01:59:47,400 --> 01:59:50,217
Tātad Python un patiesi gudrie
cilvēki, kas to izgudroja, ir 

2585
01:59:50,217 --> 01:59:53,035
uzrakstījuši kodu, kas dara visu
iespējamo, lai sniegtu jums 

2586
01:59:53,035 --> 01:59:55,853
nepārtrauktu meklēšanu vārdnīcās. 

2587
01:59:55,853 --> 01:59:58,382
Un meklēšana ne vienmēr gūs
panākumus, tāpat kā jums un jūsu problēmu 

2588
01:59:58,382 --> 02:00:00,911
kopai, iespējams, ik pa laikam būs
sadursmes un sāks veidoties garu 

2589
02:00:00,911 --> 02:00:03,440
vārdu sarakstu ķēdes. 

2590
02:00:03,440 --> 02:00:05,383
Bet šeit jūs atkal uzticaties kādam
citam, kādam, kas ir gudrāks par 

2591
02:00:05,383 --> 02:00:07,326
jums, kādam, kuram ir vairāk laika,
lai atrisinātu šīs problēmas jūsu 

2592
02:00:07,326 --> 02:00:09,270
vietā. 

2593
02:00:09,270 --> 02:00:12,620
Un, ja lasīsiet Python
dokumentāciju, jūs redzēsiet, ka tā negarantē 

2594
02:00:12,620 --> 02:00:15,970
pastāvīgu laiku, bet ideālā
gadījumā optimizē datu struktūru, lai jūs 

2595
02:00:15,970 --> 02:00:19,320
būtupēc iespējas ātrāki. 

2596
02:00:19,320 --> 02:00:22,300
Un no visām datu struktūrām,
piemēram, vārdnīcas, jaucējtabulas 

2597
02:00:22,300 --> 02:00:25,280
patiešām ir kā Šveices armijas
nazis skaitļošanā, jo tā vienkārši 

2598
02:00:25,280 --> 02:00:28,260
ļauj sasaistīt lietas. 

2599
02:00:28,260 --> 02:00:30,810
Un, lai gan mēs turpinām
koncentrēties uz vārdiem un numuriem, tā ir 

2600
02:00:30,810 --> 02:00:33,360
patiešām spēcīga lieta, jo tā ir
spēcīgāka nekā saraksti un masīvi, 

2601
02:00:33,360 --> 02:00:35,910
kas ir tikai skaitļi un kaut kas
cits. 

2602
02:00:35,910 --> 02:00:38,690
Tā vietā jums var būt jebkāda veida
saistības.

2603
02:00:38,690 --> 02:00:39,270
Labi.

2604
02:00:39,270 --> 02:00:41,180
Ļaujiet man parādīt dažus citus
piemērus, pirms mēs sasniedzam 

2605
02:00:41,180 --> 02:00:43,090
kulmināciju ar dažām jaudīgākām
Python metodēm, pateicoties 

2606
02:00:43,090 --> 02:00:45,000
bibliotēkām. 

2607
02:00:45,000 --> 02:00:49,480
Kā ar šo problēmu, ar kuru mēs
saskārāmies 4. nedēļā, kas bija šī.

2608
02:00:49,480 --> 02:00:53,125
Ļaujiet man šeit iekodēt programmu,
ko atkal sauc par compare.py, bet 

2609
02:00:53,125 --> 02:00:56,770
šoreiz salīdzinot ar virknēm, nevis
cipariem. 

2610
02:00:56,770 --> 02:01:01,230
Tāpēc ļaujiet man, piemēram, iegūt
vienu virkni no lietotāja s.

2611
02:01:01,230 --> 02:01:03,430
Tikai diskusijas labad ļaujiet man
iegūt vēl vienu virkni no 

2612
02:01:03,430 --> 02:01:05,630
lietotāja, ko sauc par t, lai mēs
varētu šeit veikt kādu 

2613
02:01:05,630 --> 02:01:07,830
salīdzinājumu. 

2614
02:01:07,830 --> 02:01:10,305
Un, ja s ir vienāds ar t, ejam uz
priekšu un izdrukāsim, ka tie ir 

2615
02:01:10,305 --> 02:01:12,780
vienādi. 

2616
02:01:12,780 --> 02:01:15,640
Citādi turpināsim un izdrukāsim, ka
tie atšķiras.

2617
02:01:15,640 --> 02:01:17,910
Tātad tas ir ļoti līdzīgs tam, ko
darījām 4. nedēļā.

2618
02:01:17,910 --> 02:01:20,855
Bet 4. nedēļā atcerieties, ka mēs
to darījām tieši tāpēc, ka radās 

2619
02:01:20,855 --> 02:01:23,800
problēma. 

2620
02:01:23,800 --> 02:01:28,680
Piemēram, ja es skrienu, ak.

2621
02:01:28,680 --> 02:01:34,970
Ja es skrienu - kas notiek?

2622
02:01:34,970 --> 02:01:40,396
[Nesadzirdami] Lūdzu!

2623
02:01:40,396 --> 02:01:41,390
Ak.

2624
02:01:41,390 --> 02:01:41,890
Labi.

2625
02:01:41,890 --> 02:01:43,240
Oho, labi.

2626
02:01:43,240 --> 02:01:43,840
Gara diena.

2627
02:01:43,840 --> 02:01:44,380
Labi.

2628
02:01:44,380 --> 02:01:47,515
Ja es palaižu pareizo komandu,
python no compare.py, tad turpināsim 

2629
02:01:47,515 --> 02:01:50,650
un ierakstīsim kaut ko līdzīgu
“cat” mazajiem burtiem, “cat” mazajiem 

2630
02:01:50,650 --> 02:01:53,785
burtiem. 

2631
02:01:53,785 --> 02:01:56,110
Un tie ir vienādi.

2632
02:01:56,110 --> 02:01:57,837
Tomēr, ja es to daru vēlreiz ar
vārdiem “dog” un “dog”, tie ir 

2633
02:01:57,837 --> 02:01:59,565
vienādi. 

2634
02:01:59,565 --> 02:02:01,690
Un, protams, “cat” un “dog” nav
vienādi.

2635
02:02:01,690 --> 02:02:05,185
Bet vai kāds atceras, ka pirms
divām nedēļām es divreiz identiski 

2636
02:02:05,185 --> 02:02:08,680
ierakstīju savu vārdu lielajiem
burtiem. 

2637
02:02:08,680 --> 02:02:10,360
Kas bija teikts?

2638
02:02:10,360 --> 02:02:13,390
Ka tie patiesībā bija atšķirīgi.

2639
02:02:13,390 --> 02:02:14,110
Un kāpēc tā bija?

2640
02:02:14,110 --> 02:02:15,760
Kāpēc divas virknes C valodā bija
atšķirīgas, lai gan es burtiski 

2641
02:02:15,760 --> 02:02:17,410
ierakstīju vienu un to pašu? 

2642
02:02:20,040 --> 02:02:21,540
Divas dažādas vietas atmiņā.

2643
02:02:21,540 --> 02:02:23,696
Tāpēc katra virkne varētu
izskatīties vienādi estētiski, bet, 

2644
02:02:23,696 --> 02:02:25,852
protams, tā tika saglabāta citur
atmiņā. 

2645
02:02:25,852 --> 02:02:38,510
šīs virknes faktiskajai [?
kvalitātei. ?]

2646
02:02:38,510 --> 02:02:41,610
Tātad šī ir Python funkcija, jo to
ir vienkārši vieglāk izdarīt.

2647
02:02:41,610 --> 02:02:42,210
Un kāpēc?

2648
02:02:42,210 --> 02:02:45,630
Tas izriet no realitātes, ka Python
valodā vairs nav rādītāju.

2649
02:02:45,630 --> 02:02:47,297
Nav pamata atmiņas pārvaldības.

2650
02:02:47,297 --> 02:02:50,400
Tagad jums nav jāuztraucas par
zemāka līmeņa detaļām.

2651
02:02:50,400 --> 02:02:52,960
Valoda pati par to parūpējas jūsu
vietā.

2652
02:02:52,960 --> 02:02:56,165
Un līdzīgi, ja es to daru un
neprasu lietotājam divas virknes, bet 

2653
02:02:56,165 --> 02:02:59,370
tikai vienu, tad es daru kaut ko
līdzīgu šim. 

2654
02:02:59,370 --> 02:03:02,865
Kā būtu, ja es dotu sev otru
mainīgo t, iestatītu to vienādu ar 

2655
02:03:02,865 --> 02:03:06,360
s.capitalize, kas, ņemiet vērā, nav
tas pats, kas lielie burti; Lielo 

2656
02:03:06,360 --> 02:03:09,855
burtu rakstīšanā pēc dizaina,
saskaņā ar Python dokumentāciju, 

2657
02:03:09,855 --> 02:03:13,350
lielais burts būs tikai pirmais
burts — tagad es varu izdrukāt, 

2658
02:03:13,350 --> 02:03:16,845
teiksim, divas fstring šeit — kāda
ir s vērtība, un tad ļaujiet man 

2659
02:03:16,845 --> 02:03:20,340
izdrukāt ar citu fstring, kāda ir t
vērtība. 

2660
02:03:20,340 --> 02:03:23,450
Un atcerieties, ka valodā C tā bija
problēma, jo, ja jūs lietojāt 

2661
02:03:23,450 --> 02:03:26,560
lielos burtus s un saglabājāt to t,
mēs nejauši rakstījām lielos 

2662
02:03:26,560 --> 02:03:29,670
burtus gan s, gan t. 

2663
02:03:29,670 --> 02:03:34,040
Bet šajā gadījumā Python valodā,
kad es faktiski palaižu šo un 

2664
02:03:34,040 --> 02:03:38,410
ierakstu “cat” mazajiem burtiem,
oriģinālais s nemainās, jo, kad 3. 

2665
02:03:38,410 --> 02:03:42,780
rindā izmantoju lielos burtus, tas
patiešām ir s ar lielo burtu. 

2666
02:03:42,780 --> 02:03:47,550
Bet tas atgriež rezultāta kopiju.

2667
02:03:42,780 --> 02:03:46,582
Tas pats par sevi nevar mainīties,
jo atkal šim tehniskajam terminam 

2668
02:03:46,582 --> 02:03:50,385
s ir nemainīgs. 

2669
02:03:50,385 --> 02:03:53,265
Virknes, ja tās pastāv, nevar pašas
mainīties.

2670
02:03:53,265 --> 02:03:55,927
Bet jūs varat atgriezt kopijas un
modificēt šo pašu virkņu mutācijas 

2671
02:03:55,927 --> 02:03:58,590
kopijas. 

2672
02:03:58,590 --> 02:04:01,830
Tātad, īsi sakot, visas šīs
galvassāpes, ar kurām saskārāmies 4. 

2673
02:04:01,830 --> 02:04:05,070
nedēļā, tagad patiešām ir
atrisinātas tā, kā jūs varētu to sagaidīt. 

2674
02:04:05,070 --> 02:04:07,365
Un šeit ir vēl viens, pie kura mēs
kavējāmies 4. nedēļā, ar krāsaino 

2675
02:04:07,365 --> 02:04:09,660
šķidrumu glāzēs. 

2676
02:04:09,660 --> 02:04:12,150
Ļaujiet man iekodēt programmu ar
nosaukumu swap.py.

2677
02:04:12,150 --> 02:04:16,690
Un swap.py ļaujiet man iestatīt x
vienādu ar 1, y vienādu ar 2.

2678
02:04:16,690 --> 02:04:18,690
Un tad ļaujiet man šeit izdrukāt
fstring.

2679
02:04:18,690 --> 02:04:24,360
Tātad, kā ja x ir šis komats, y ir
tas.

2680
02:04:24,360 --> 02:04:27,735
Un tad ļaujiet man to izdarīt divas
reizes, tikai pierādījuma labad.

2681
02:04:27,735 --> 02:04:31,005
Un šeit atcerieties, ka mums bija
jāizveido mijmaiņas funkcija.

2682
02:04:31,005 --> 02:04:33,630
Bet tad mums tā bija jānodod ar
atsauci ar & zīmi.

2683
02:04:33,630 --> 02:04:38,460
Un ak, dievs, tas bija vislielākais
sarežģītības līmenis C valodā.

2684
02:04:33,630 --> 02:04:38,730
Ja vēlaties Python valodā mainīt
vietām x un y, varat izdarīt: x, 

2685
02:04:38,730 --> 02:04:43,830
komats, y, ir vienāds ar y, komats,
x. 

2686
02:04:43,830 --> 02:04:49,020
Un tagad, python no swap.py.

2687
02:04:49,020 --> 02:04:50,130
Un te mēs esam.

2688
02:04:50,130 --> 02:04:51,840
Tas viss ir nokārtots jūsu vietā.

2689
02:04:51,840 --> 02:04:56,350
Tā ir kā uzpirksteņu spēle,
nedomājot pat par pagaidu mainīgo.

2690
02:04:56,350 --> 02:04:58,290
Tātad, ko mēs šeit vēl varam
izdarīt?

2691
02:04:58,290 --> 02:05:00,870
Kā būtu ar dažiem pēdējiem
būvniecības blokiem?

2692
02:05:00,870 --> 02:05:03,330
Un tie tagad ir saistīti ar datnēm
no šīs 4. nedēļas.

2693
02:05:03,330 --> 02:05:07,205
Pieņemsim, ka es vēlos saglabāt
dažus vārdus un numurus CSV datnē — 

2694
02:05:07,205 --> 02:05:11,080
komatatdalītās vērtības, kas ir kā
ļoti viegla izklājlapa. 

2695
02:05:11,080 --> 02:05:15,269
Vispirms ļaujiet man izveidot datni
phonebook.csv, kuras pirmajā 

2696
02:05:15,269 --> 02:05:19,458
rindā ir vārds, komats, numurs. 

2697
02:05:19,458 --> 02:05:23,249
Bet pēc tam es turpināšu un tagad
iekodēšu programmu phonebook.py, 

2698
02:05:23,249 --> 02:05:27,040
kas faktiski ļauj man pievienot
datus šim tālruņu katalogam. 

2699
02:05:27,040 --> 02:05:29,030
Tāpēc ļaujiet man šeit sadalīt
ekrānu, lai mēs varētu redzēt veco un 

2700
02:05:29,030 --> 02:05:31,020
jauno. 

2701
02:05:31,020 --> 02:05:34,020
Un šeit, manā phonebook.py kodā,
šajā jaunajā un uzlabotajā versijā 

2702
02:05:34,020 --> 02:05:37,020
es faktiski importēšu pavisam citu
bibliotēku, šo bibliotēku ar 

2703
02:05:37,020 --> 02:05:40,020
nosaukumu CSV. 

2704
02:05:40,020 --> 02:05:42,892
Un arī šeit, jo īpaši cilvēkiem,
kas nodarbojas ar datu zinātni un 

2705
02:05:42,892 --> 02:05:45,765
tamlīdzīgi, ļoti patīk manipulēt ar
datnēm un datiem, kas var ļoti 

2706
02:05:45,765 --> 02:05:48,637
labi tikt glabāti izklājlapās vai
CSV — komatatdalītās vērtības, 

2707
02:05:48,637 --> 02:05:51,510
kuras mēs īsi redzējām 4. nedēļā. 

2708
02:05:51,510 --> 02:05:55,056
Tādējādi vietnē phonebook.py
pietiek tikai importēt CSV pēc 

2709
02:05:55,056 --> 02:05:58,603
dokumentācijas izlasīšanas, jo tas
man nodrošinās funkcionalitāti 

2710
02:05:58,603 --> 02:06:02,150
kodā, kas saistīts ar CSV datnēm. 

2711
02:06:02,150 --> 02:06:04,950
Tātad, lūk, kā es varu atvērt datni
Python valodā.

2712
02:06:04,950 --> 02:06:07,905
Es burtiski izsaucu open — tagad
tas nav fopen; tas ir tikai open — 

2713
02:06:07,905 --> 02:06:10,860
un es atveru šo datni ar nosaukumu
phonebook.csv. 

2714
02:06:10,860 --> 02:06:13,395
Un tāpat kā C valodā, es to atvēršu
pievienošanas režīmā — tas nav 

2715
02:06:13,395 --> 02:06:15,930
pareizi, jo tas mainītu visu. 

2716
02:06:15,930 --> 02:06:18,660
Es vēlos vienlaikus pievienot jaunu
rindu.

2717
02:06:18,660 --> 02:06:21,750
Pēc tam es vēlos, iespējams, iegūt
vārdu no lietotāja.

2718
02:06:21,750 --> 02:06:25,350
Tāpēc liksim lietotājam ievadīt
savu vārdu.

2719
02:06:25,350 --> 02:06:28,205
Un tad lūgsim lietotājam ievadīt
arī numuru, izmantojot numura 

2720
02:06:28,205 --> 02:06:31,060
ievades uzvedni. 

2721
02:06:31,060 --> 02:06:31,560
Labi.

2722
02:06:31,560 --> 02:06:33,305
Un tagad tas ir nedaudz sarežģīti,
un jūs to zināt tikai no 

2723
02:06:33,305 --> 02:06:35,050
dokumentācijas. 

2724
02:06:35,050 --> 02:06:37,552
Bet, ja vēlaties rakstīt rindas CSV
datnē, ko varat vēlāk skatīt 

2725
02:06:37,552 --> 02:06:40,055
programmā Excel vai tamlīdzīgā
veidā, varat to izdarīt — iedodiet man 

2726
02:06:40,055 --> 02:06:42,557
mainīgo, ko sauc par rakstītāju —
bet es to varētu saukt kā vien 

2727
02:06:42,557 --> 02:06:45,060
vēlos. 

2728
02:06:45,060 --> 02:06:48,472
Ļaujiet man izmantot funkciju
csv.writer, kas iekļauta šajā CSV 

2729
02:06:48,472 --> 02:06:51,885
bibliotēkā, nododot datnē. 

2730
02:06:51,885 --> 02:06:54,761
Tas ir tāpat kā teikt: Ei, Python,
apstrādā šo atvērto datni kā CSV 

2731
02:06:54,761 --> 02:06:57,638
datni, lai viss būtu atdalīts ar
komatiem un jauki formatēts rindās 

2732
02:06:57,638 --> 02:07:00,515
un kolonnās. 

2733
02:07:00,515 --> 02:07:04,030
Tagad es izdarīšu šo — izmantošu šo
rakstītāju, lai uzrakstītu rindu.

2734
02:07:04,030 --> 02:07:05,280
Nu, ko es gribu uzrakstīt?

2735
02:07:05,280 --> 02:07:09,000
Es vēlos šai datnei uzrakstīt īsu
sarakstu, proti, pašreizējo 

2736
02:07:09,000 --> 02:07:12,720
nosaukumu un pašreizējo numuru, bet
es nevēlos izmantot fprintf un % 

2737
02:07:12,720 --> 02:07:16,440
un visas šīs lietas, kas mums
varēja būt agrāk. 

2738
02:07:16,440 --> 02:07:19,030
Un tagad es vēlos tikai aizvērt
datni.

2739
02:07:19,030 --> 02:07:20,410
Ļaujiet man atkārtoti atvērt savu
termināli.

2740
02:07:20,410 --> 02:07:24,750
Ļaujiet man palaist python no
phonebook.py un ļaujiet man ierakstīt 

2741
02:07:24,750 --> 02:07:29,090
David un pēc tam +1-949-468-2750
un, turot īkšķus, paskatīties uz 

2742
02:07:29,090 --> 02:07:33,430
faktisko CSV datni augšējā kreisajā
stūrī. 

2743
02:07:33,430 --> 02:07:35,737
Mans kods mani tikko pievienoja
datnei.

2744
02:07:35,737 --> 02:07:39,278
Un, ja es to palaistu vēlreiz,
piemēram, ar Kārteru un 

2745
02:07:39,278 --> 02:07:42,820
+1-617-495-1000, vēlreiz turot
īkšķus, mēs esam atjauninājuši datni. 

2746
02:07:42,820 --> 02:07:46,150
Un izrādās, ka tagad ir kods, caur
kuru es pat varu nolasīt šo datni.

2747
02:07:46,150 --> 02:07:48,850
Bet es varu vispirms to
nostiprināt, lai jūs to redzētu.

2748
02:07:48,850 --> 02:07:52,720
Izrādās, Python valodā ir tik
ierasts atvērt datnes un tās aizvērt.

2749
02:07:52,720 --> 02:07:55,598
Cilvēki pieļauj kļūdas un bieži
aizmirst aizvērt datnes, kā rezultātā 

2750
02:07:55,598 --> 02:07:58,477
var tikt izmantots vairāk atmiņas,
nekā jūs plānojat. 

2751
02:07:58,477 --> 02:08:00,893
Varat arī šo izdarīt valodā Python,
lai jums nebūtu jāuztraucas par 

2752
02:08:00,893 --> 02:08:03,310
datņu aizvēršanu. 

2753
02:08:03,310 --> 02:08:05,920
Tā vietā varat izmantot šo
atslēgvārdu.

2754
02:08:05,920 --> 02:08:09,670
Varat teikt, atverot šo datni kā
mainīgo, ko sauc par file, veiciet 

2755
02:08:09,670 --> 02:08:13,420
tālāk norādītās darbības. 

2756
02:08:13,420 --> 02:08:15,470
Tāpēc es izgriežu lielāko daļu sava
koda.

2757
02:08:15,470 --> 02:08:16,950
Es izmantoju šo jauno, Python
specifisko atslēgvārdu, ko sauc par 

2758
02:08:16,950 --> 02:08:18,430
width. 

2759
02:08:18,430 --> 02:08:21,410
Un tas ir tikai valodas jautājums,
ka ar nākamo datnes atvēršanu 

2760
02:08:21,410 --> 02:08:24,390
veiciet šīs četras koda rindiņas un
pēc tam automātiski aizveriet to 

2761
02:08:24,390 --> 02:08:27,370
manā vietā ievilkuma beigās. 

2762
02:08:27,370 --> 02:08:30,310
Tā ir neliela optimizācija, taču
tas atkal ir pitoniskais veids, kā 

2763
02:08:30,310 --> 02:08:33,250
rīkoties. 

2764
02:08:33,250 --> 02:08:34,720
Kā vēl es to varētu izdarīt?

2765
02:08:34,720 --> 02:08:37,675
Nu, izrādās, ka kods, ko esmu
uzrakstījis šeit, īpaši 9. rindā, ir 

2766
02:08:37,675 --> 02:08:40,630
pavājš. 

2767
02:08:40,630 --> 02:08:43,550
Ja kāds cilvēks atver šo
izklājlapu — CSV datni programmā Excel, 

2768
02:08:43,550 --> 02:08:46,470
Google Spreadsheets, Apple
Numbers — un, iespējams, pārvieto kolonnas 

2769
02:08:46,470 --> 02:08:49,390
tikai tāpēc, ka, iespējams, tās
jūk. 

2770
02:08:49,390 --> 02:08:51,090
Cilvēks to saglabāja, un viņš
neapzinās, ka tagad ir mainījis manus 

2771
02:08:51,090 --> 02:08:52,790
pieņēmumus. 

2772
02:08:52,790 --> 02:08:55,540
Es nevēlos, lai vārdu un numuru
vienmēr rakstītu šādā secībā, jo kā 

2773
02:08:55,540 --> 02:08:58,290
būtu, ja kāds salaiž grīstē un
maina šīs divas kolonnas vietām, 

2774
02:08:58,290 --> 02:09:01,040
burtiski velkot un nometot? 

2775
02:09:01,040 --> 02:09:03,965
Tātad izrādās, ka tā vietā, lai
šeit izmantotu sarakstu, mēs varam 

2776
02:09:03,965 --> 02:09:06,890
izmantot citu šīs bibliotēkas
līdzekli, kā norādīts tālāk. 

2777
02:09:06,890 --> 02:09:09,786
Tā vietā, lai izmantotu rakstītāju,
ir kaut kas, ko sauc par vārdnīcu 

2778
02:09:09,786 --> 02:09:12,683
vai dict rakstītāju, kas izmanto to
pašu argumentu kā ievadi — datni, 

2779
02:09:12,683 --> 02:09:15,580
kas ir atvērta. 

2780
02:09:15,580 --> 02:09:20,305
Bet tagad viena atšķirība šeit ir
tāda, ka jums ir jāpasaka šim 

2781
02:09:20,305 --> 02:09:25,030
vārdnīcas rakstītājam, ka jūsu
lauku nosaukumi ir vārds un numurs. 

2782
02:09:25,030 --> 02:09:27,370
Un ļaujiet man aizvērt CSV datni
šeit.

2783
02:09:27,370 --> 02:09:32,140
Vārds un numurs ir šajā CSV datnē
esošo lauku un kolonnu nosaukumi.

2784
02:09:32,140 --> 02:09:34,945
Un, kad pienāks laiks rakstīt jaunu
rindu, sintakse šeit būs nedaudz 

2785
02:09:34,945 --> 02:09:37,750
neglītāka, bet tā ir tikai
vārdnīca. 

2786
02:09:37,750 --> 02:09:40,030
Vārds, ko es vēlos ierakstīt
vārdnīcā, būs tas, ko cilvēks ir 

2787
02:09:40,030 --> 02:09:42,310
ievadījis. 

2788
02:09:42,310 --> 02:09:45,430
Numurs, ko es vēlos ierakstīt CSV
datnē, būs neatkarīgs no cilvēka 

2789
02:09:45,430 --> 02:09:48,550
ievadītā numura. 

2790
02:09:48,550 --> 02:09:52,580
Bet tagad šajā kodā atšķiras tas,
ka, vienkārši izmantojot vārdnīcas 

2791
02:09:52,580 --> 02:09:56,610
rakstītāju, nevis vispārīgo
rakstītāju, tagad kolonnas var būt šādā 

2792
02:09:56,610 --> 02:10:00,640
secībā vai šādā secībā vai jebkurā
secībā. 

2793
02:10:00,640 --> 02:10:04,015
Un vārdnīcas autors, pamatojoties
uz CSV teksta pirmo rindiņu, 

2794
02:10:04,015 --> 02:10:07,390
izdomās, kur likt vārdu, kur
ievietot numuru. 

2795
02:10:07,390 --> 02:10:08,883
Tātad, ja jūs tos maināt vietām, tā
nebūs liela problēma.

2796
02:10:08,883 --> 02:10:11,050
Tā pamanīs: ak, pagaidiet, kolonnas
mainījās.

2797
02:10:11,050 --> 02:10:14,330
Un pareizi ievietos kolonnas.

2798
02:10:14,330 --> 02:10:18,636
Tātad, atkal, tā ir vēl viena
jaudīga funkcija, kas ļauj 

2799
02:10:18,636 --> 02:10:22,943
koncentrēties uz reālu darbu,
nevis, pretējā gadījumā, faktiski 

2800
02:10:22,943 --> 02:10:27,250
apmaldīties koda rakstīšanā. 

2801
02:10:27,250 --> 02:10:30,440
Vēl jautājumi par šo?

2802
02:10:30,440 --> 02:10:33,963
Bet tas, ko mēs tagad darīsim, ir
daži no sarežģītākajiem piemēriem, 

2803
02:10:33,963 --> 02:10:37,486
ar kuriem mēs sākām, un es
atgriezīšos pie sava Mac klēpjdatora, kur 

2804
02:10:37,486 --> 02:10:41,009
man ir atvērts un palaists mans
termināļa logs. Es tikko gatavojos 

2805
02:10:41,009 --> 02:10:44,533
iepazīstināt ar dažām pēdējām
bibliotēkām, kas patiešām runā par to, 

2806
02:10:44,533 --> 02:10:48,056
cik spēcīga var būt Python valoda
un cik ātri jūs varat sākt izmantot 

2807
02:10:48,056 --> 02:10:51,580
šo valodu. 

2808
02:10:51,580 --> 02:10:53,860
Godīgi sakot, visas šīs darbības
nevar veikt mākonī, piemēram, koda 

2809
02:10:53,860 --> 02:10:56,140
telpās, jo jums ir nepieciešama
piekļuve saviem skaļruņiem, 

2810
02:10:56,140 --> 02:10:58,420
mikrofonam vai tamlīdzīgiem
līdzekļiem. 

2811
02:10:58,420 --> 02:11:01,090
Tāpēc es to daru savā Mac datorā,
šeit.

2812
02:11:01,090 --> 02:11:05,680
Bet ļaujiet man iet uz priekšu un
atvērt programmu speech.py.

2813
02:11:05,680 --> 02:11:07,300
Un es šeit neizmantoju VS kodu.

2814
02:11:07,300 --> 02:11:08,725
Es izmantoju programmu VI, kas
pilnībā ir balstīta uz termināļa 

2815
02:11:08,725 --> 02:11:10,150
logiem. 

2816
02:11:10,150 --> 02:11:13,135
Bet tas ļaus man, piemēram,
importēt Python tekstu uz runas 

2817
02:11:13,135 --> 02:11:16,120
3. versijas bibliotēku. 

2818
02:11:16,120 --> 02:11:19,112
Es došu sev mainīgo, ko sauc par
dzinēju (engine), kas tiks iestatīts 

2819
02:11:19,112 --> 02:11:22,105
vienāds ar Python valodas teksta
pārvēršanas runā 3 bibliotēku init 

2820
02:11:22,105 --> 02:11:25,097
metodi, kas tikai inicializēs šo
bibliotēku, kas ir saistīta ar 

2821
02:11:25,097 --> 02:11:28,090
teksta pārvēršanu runā. 

2822
02:11:28,090 --> 02:11:31,675
Pēc tam es izmantošu dzinēja
izteikšanas funkciju, lai pateiktu kaut 

2823
02:11:31,675 --> 02:11:35,260
ko, teiksim, hello, komats, world. 

2824
02:11:35,260 --> 02:11:38,403
Un pēc tam kā savu pēdējo rindiņu
es teikšu engine.runAndWait, 

2825
02:11:38,403 --> 02:11:41,546
rakstīts lieliem burtiem, lai
pateiktu savai programmai tagad palaist 

2826
02:11:41,546 --> 02:11:44,690
šo runu un gaidīt, līdz viss ir
izdarīts. 

2827
02:11:44,690 --> 02:11:45,190
Labi.

2828
02:11:45,190 --> 02:11:46,540
Es saglabāšu šo datni.

2829
02:11:46,540 --> 02:11:49,110
Es palaidīšu python of speech.py.

2830
02:11:49,110 --> 02:11:53,440
Un es kā vienmēr turu īkšķi, un...
TULKS: Hello, world.

2831
02:11:53,440 --> 02:11:54,398
DEIVIDS MALANS: Labi.

2832
02:11:54,398 --> 02:11:56,484
Tāpēc tagad man ir programma, kas
faktiski sintezē runu, izmantojot 

2833
02:11:56,484 --> 02:11:58,570
šādu bibliotēku. 

2834
02:11:58,570 --> 02:12:01,285
Kā es varu tagad to pārveidot, lai
tā būtu nedaudz interesantāka?

2835
02:12:01,285 --> 02:12:02,690
Nu, kā ar šo?

2836
02:12:02,690 --> 02:12:04,686
Ļaujiet man iet uz priekšu un lūgt
lietotājam ievadīt viņa vārdu, kā 

2837
02:12:04,686 --> 02:12:06,683
mēs to esam darījuši vairākas
reizes, izmantojot Python valodā 

2838
02:12:06,683 --> 02:12:08,680
iebūvēto vārdu funkciju. 

2839
02:12:08,680 --> 02:12:11,830
Un tagad ļaujiet man turpināt un
izmantot formāta virkni kopā ar šo 

2840
02:12:11,830 --> 02:12:14,980
bibliotēku, interpolējot vārda
vērtību. 

2841
02:12:14,980 --> 02:12:18,210
Un vismaz, ja mans vārds ir kaut
cik fonētiski izrunājams, iesim uz 

2842
02:12:18,210 --> 02:12:21,440
priekšu un palaidīsim python no
speech.py, ierakstīsim manu vārdu 

2843
02:12:21,440 --> 02:12:24,670
un... TULKS: Hello, David. 

2844
02:12:24,670 --> 02:12:25,445
DEIVIDS MALANS: Labi.

2845
02:12:25,445 --> 02:12:27,646
Tā ir dīvaina locījuma izvēle, taču
mēs sākam sintezēt balsi, 

2846
02:12:27,646 --> 02:12:29,848
atšķirībā no Siri vai Google
Assistant vai Alexa vai tamlīdzīgām 

2847
02:12:29,848 --> 02:12:32,050
programmām. 

2848
02:12:32,050 --> 02:12:36,130
Tagad mēs, iespējams, varam izdarīt
arī kaut ko nedaudz sarežģītāku.

2849
02:12:36,130 --> 02:12:39,700
Papildus runas sintezēšanai šādā
veidā mēs varētu sintezēt, piemēram, 

2850
02:12:39,700 --> 02:12:43,270
faktisku grafiku. 

2851
02:12:43,270 --> 02:12:45,740
Ļaujiet man iet uz priekšu un
izdarīt kaut ko līdzīgu šim.

2852
02:12:45,740 --> 02:12:48,760
Ļaujiet man izveidot programmu ar
nosaukumu qr.py.

2853
02:12:48,760 --> 02:12:51,810
Es importēšu bibliotēku ar
nosaukumu OS, kas nodrošina piekļuvi ar 

2854
02:12:51,810 --> 02:12:54,860
operētājsistēmu saistītajām Python
funkcijām. 

2855
02:12:54,860 --> 02:12:57,006
Es importēšu bibliotēku, ko esmu
iepriekš instalējis ar nosaukumu 

2856
02:12:57,006 --> 02:12:59,153
qrcode, kas ir divdimensiju
svītrkods, ko, iespējams, esat redzējuši 

2857
02:12:59,153 --> 02:13:01,300
reālajā pasaulē. 

2858
02:13:01,300 --> 02:13:04,321
Es turpināšu izveidot attēla
mainīgo, izmantojot šo kvadrātkoda 

2859
02:13:04,321 --> 02:13:07,343
bibliotēkas make funkciju, kas
saskaņā ar tās dokumentāciju aizņem 

2860
02:13:07,343 --> 02:13:10,365
URL, piemēram, vienu no CS50
videoklipiem. 

2861
02:13:10,365 --> 02:13:23,003
Tāpēc mēs to darīsim ar
youtu.be/xvF2joSPgG0.

2862
02:13:23,003 --> 02:13:24,670
Tātad, cerams, šī ir īstā lekcija.

2863
02:13:24,670 --> 02:13:27,400
Un tagad mums ir img.save, kas ļaus
man izveidot datni ar nosaukumu 

2864
02:13:27,400 --> 02:13:30,130
qr.ping. 

2865
02:13:30,130 --> 02:13:31,795
Padomājiet par 4. problēmu kopu un
to, cik sāpīga bija datņu 

2866
02:13:31,795 --> 02:13:33,460
saglabāšana. 

2867
02:13:33,460 --> 02:13:35,860
Mēs tagad izmantosim saglabāšanas
funkciju Python valodā un 

2868
02:13:35,860 --> 02:13:38,260
saglabāsim to kā PNG datni —
Portable Network Graphic. 

2869
02:13:38,260 --> 02:13:42,190
Un tad, visbeidzot, ejam uz priekšu
un atveram ar komandu open qr.png 

2870
02:13:42,190 --> 02:13:46,120
manā Mac datorā, lai, cerams, tā
tiktu automātiski atvērta. 

2871
02:13:46,120 --> 02:13:46,660
Labi.

2872
02:13:46,660 --> 02:13:48,970
Es turpināšu un vēlreiz pārbaudīšu
savu sintaksi šeit, lai es nebūtu 

2873
02:13:48,970 --> 02:13:51,280
pieļāvis nekādas kļūdas. 

2874
02:13:51,280 --> 02:13:54,235
Es iešu uz priekšu un palaidīšu
python no qr.py.

2875
02:13:54,235 --> 02:13:55,810
Enter.

2876
02:13:55,810 --> 02:13:57,223
Tas to paver.

2877
02:13:57,223 --> 02:13:58,390
Ļaujiet man turpināt un pietuvināt.

2878
02:13:58,390 --> 02:14:03,242
Ja jums ir pieejams tālrunis un
vēlaties noskenēt šo kodu šeit, 

2879
02:14:03,242 --> 02:14:08,095
klātienē vai tiešsaistē, - es
atvainojos. 

2880
02:14:08,095 --> 02:14:09,130
Jūs to nenovērtēsiet.

2881
02:14:11,640 --> 02:14:12,140
Apbrīnojami!

2882
02:14:12,140 --> 02:14:13,600
Labi.

2883
02:14:13,600 --> 02:14:17,500
Un, visbeidzot, ļaujiet man
atgriezties pie mūsu runas piemēra šeit, 

2884
02:14:17,500 --> 02:14:21,400
izveidot fināla nobeigumu šeit mūsu
pēdējos brīžos. 

2885
02:14:21,400 --> 02:14:23,730
Un kā būtu, ja mēs vienkārši
pateiktu kaut ko līdzīgu “This was 

2886
02:14:23,730 --> 02:14:26,060
CS50”, piemēram, šādi. 

2887
02:14:26,060 --> 02:14:27,087
Ejam uz priekšu, lūk.

2888
02:14:27,087 --> 02:14:28,795
Salabosim manu lielo burtu
lietojumu, lai būtu tīrība.

2889
02:14:28,795 --> 02:14:29,878
Atbrīvosimies no vārda.

2890
02:14:29,878 --> 02:14:33,206
Un tagad, ar mūsu pēdējo uzplaukumu
un jūsu iepazīstināšanu ar Python 

2891
02:14:33,206 --> 02:14:36,535
valodu — lūk, te tas ir: TULKS:
This was CS50. 

2892
02:14:36,535 --> 02:14:37,000
DEIVIDS MALANS: Labi.

2893
02:14:37,000 --> 02:14:38,000
Tiekamies nākamreiz.

2894
02:14:38,000 --> 02:14:39,460
[APLAUSI]

2895
02:14:39,460 --> 02:14:41,860
[SKAN MŪZIKA]