1
00:00:00,000 --> 00:00:05,426

2
00:00:05,426 --> 00:00:06,800
ROSS RHEINGANS-YOO: Здравейте, аз съм Ross.

3
00:00:06,800 --> 00:00:08,570
И това е CS50 семинар.

4
00:00:08,570 --> 00:00:12,100
Тя ще ви отведе от програмиране
в C програмирането в Python.

5
00:00:12,100 --> 00:00:15,120
>> Python е скриптов език.

6
00:00:15,120 --> 00:00:17,870
Това е до голяма степен като C
в синтаксиса, въпреки че някои

7
00:00:17,870 --> 00:00:20,390
на техническите подробности
колко получава изпълнена, че синтаксиса

8
00:00:20,390 --> 00:00:22,240
са малко по-различен.

9
00:00:22,240 --> 00:00:24,780
Тя е по-мощен от C в някои отношения.

10
00:00:24,780 --> 00:00:28,130
Тя е по-изразителен за
къде точно във вашия компютър

11
00:00:28,130 --> 00:00:30,030
памет получава изложени,
как той се изложи,

12
00:00:30,030 --> 00:00:32,030
когато тя стане свобода, и
тези различни неща.

13
00:00:32,030 --> 00:00:36,150
>> Това е по-полезен от C в някои отношения,
защото е по-лесно да програмирате инча

14
00:00:36,150 --> 00:00:39,920
Езикът е, до известна
хора, по-интуитивен.

15
00:00:39,920 --> 00:00:44,820
И наистина, като целта е за
тя да бъде по-бързо, за да програмирате

16
00:00:44,820 --> 00:00:46,490
и потенциално по-бавно, за да се изпълни.

17
00:00:46,490 --> 00:00:48,198
>> Сега, ако мислите, че за
размера на времето

18
00:00:48,198 --> 00:00:50,514
сте прекарали на вашия последен
проблем зададете писане

19
00:00:50,514 --> 00:00:52,430
Код си срещу
период от време, което прекарвате

20
00:00:52,430 --> 00:00:55,310
в последния си проблем
зададете изпълняващата кода си,

21
00:00:55,310 --> 00:00:58,300
бихте си представим, че на езика
което беше два пъти по-бързо, за да пиша,

22
00:00:58,300 --> 00:01:02,170
и два пъти по-бавно, за да се изпълни, може да
бъде подобрение в сравнение с C в някои отношения.

23
00:01:02,170 --> 00:01:05,730
Разбира се, когато се опитвате да напише
малки програми, които да правят малки неща,

24
00:01:05,730 --> 00:01:08,520
Python е полезен език на избор.

25
00:01:08,520 --> 00:01:10,620
>> И в края на тази
семинар, се надявам да

26
00:01:10,620 --> 00:01:12,950
да бъде в състояние да направи
избор в бъдещи проекти

27
00:01:12,950 --> 00:01:17,710
за кой език е
правилно да се използва, а не на идеята

28
00:01:17,710 --> 00:01:21,405
че един език е по-
коригира цялото време.

29
00:01:21,405 --> 00:01:23,030
Няколко неща за това, което семинара е.

30
00:01:23,030 --> 00:01:25,910
Този семинар не е предназначена да
ви научи Python от нулата.

31
00:01:25,910 --> 00:01:28,310
Python е много сходна
до C, и аз съм се предположи

32
00:01:28,310 --> 00:01:34,056
че сте студент CS50, или някой,
с подобна познаване C.

33
00:01:34,056 --> 00:01:36,700
>> Ако сте студент CS50
около проблем зададете 6,

34
00:01:36,700 --> 00:01:38,866
Така че сте въвели много
неща в C, аз ще ви дам

35
00:01:38,866 --> 00:01:40,740
основните разлики,
и някои от нещата,

36
00:01:40,740 --> 00:01:42,840
които правят Python различно
и специална и полезна,

37
00:01:42,840 --> 00:01:45,256
но аз няма да отида за
какъв език за програмиране е

38
00:01:45,256 --> 00:01:46,920
и как да се пишат програми.

39
00:01:46,920 --> 00:01:49,820
Въпреки това, този семинар ще преподават
можете да напиша Python програми

40
00:01:49,820 --> 00:01:52,310
ако сте един от тези няколко групи.

41
00:01:52,310 --> 00:01:54,820
Отново ние ще разгледаме как
бихте приложи psets--

42
00:01:54,820 --> 00:01:57,550
че трябва да бъде 1-6 в
Python-- и осигуряват указатели

43
00:01:57,550 --> 00:02:00,322
до официална документация
за справка в бъдеще.

44
00:02:00,322 --> 00:02:03,030
Другото нещо, което е важно
за това как са разпределени тези разговори,

45
00:02:03,030 --> 00:02:05,360
това видео ще бъде
онлайн, с любезното съдействие на CS50,

46
00:02:05,360 --> 00:02:07,550
така че не трябва да се чувстват като
трябва да си водят бележки.

47
00:02:07,550 --> 00:02:11,180
Винаги можете да се върнете и да погледнем
при това по-късно като отправна точка.

48
00:02:11,180 --> 00:02:13,340
Допълнително слайдовете
са на разположение в момента

49
00:02:13,340 --> 00:02:16,480
в този сайт, който трябва да
вземат ти направя док Google.

50
00:02:16,480 --> 00:02:21,010
Това е малко по-съкратен вариант
от това, което аз съм се показва на екрана.

51
00:02:21,010 --> 00:02:24,850
>> Един внимателен протест пред
ние скочи, Python 3

52
00:02:24,850 --> 00:02:26,700
е друг език от Python 2.

53
00:02:26,700 --> 00:02:30,020
Те изглеждат много по същия начин; има
съвсем незначителни технически различия

54
00:02:30,020 --> 00:02:32,530
че ще доведе програми
написан на Python 2

55
00:02:32,530 --> 00:02:37,140
да не бъде в състояние да се изпълни
в Python 3 околната среда.

56
00:02:37,140 --> 00:02:41,969
>> Уредът идва с The CS50
Python, по подразбиране той използва Python 2.

57
00:02:41,969 --> 00:02:44,010
Можете да проверите това, като
пишете във вашия команден ред

58
00:02:44,010 --> 00:02:51,310
питон --version, която трябва да изведе
2.7.6 по текущата уреда.

59
00:02:51,310 --> 00:02:53,580
Опитайте Python 3, което прави
работят в уреда,

60
00:02:53,580 --> 00:02:58,500
ако Python подразбиране 2.X.Y, или по
уреда или на вашата собствена машина.

61
00:02:58,500 --> 00:03:03,730
Трябва да замените Python 3 по всяко време
в тези приказки, че аз пиша Python.

62
00:03:03,730 --> 00:03:05,760
Ако вашата машина е
използвате 2 по подразбиране, тип

63
00:03:05,760 --> 00:03:09,770
Python 3, за да може действително да
следват заедно и да изпълни тези неща.

64
00:03:09,770 --> 00:03:12,280
>> Освен това, аз ще ви посоча
по време на официални източници в момента.

65
00:03:12,280 --> 00:03:16,082
docs.python.org/3--~~V внимателни
че това е 3, а не 2--

66
00:03:16,082 --> 00:03:17,030
има полезни препратки.

67
00:03:17,030 --> 00:03:19,280
Инструкция ще ви преведе през
много от същите неща

68
00:03:19,280 --> 00:03:21,460
че правя сега, освен в текстова форма.

69
00:03:21,460 --> 00:03:23,725
Референтен е полезно като
справки за езика,

70
00:03:23,725 --> 00:03:26,100
и Standard библиотека дава
ви някои от разширения

71
00:03:26,100 --> 00:03:27,770
с допълнителна функционалност.

72
00:03:27,770 --> 00:03:31,300
>> Така че много първата програма Python.

73
00:03:31,300 --> 00:03:34,410
От ляво имаме стандарт C,
отдясно, имаме Python.

74
00:03:34,410 --> 00:03:36,780
Може би сте признати
този проблем, това е

75
00:03:36,780 --> 00:03:40,760
един от първия проблем
залязва в CS50, и те

76
00:03:40,760 --> 00:03:42,677
го решим с помощта на същия разтвор.

77
00:03:42,677 --> 00:03:45,010
Сега, поради причината, че ние сме
погледнете в тях рамо до рамо

78
00:03:45,010 --> 00:03:46,830
е за да можем да погледнем
синтактични различия.

79
00:03:46,830 --> 00:03:49,580
Един от слоновете в стаята
че може би сте забелязали полето

80
00:03:49,580 --> 00:03:56,350
разстояние бухалката, е, че не разполага с Python
Основната функция обвиване около кода.

81
00:03:56,350 --> 00:03:59,170
Така че в C, пишете куп
файлове, като ги свързват заедно,

82
00:03:59,170 --> 00:04:02,590
и програмата започва изпълняващата
в това нещо, наречено инт главната.

83
00:04:02,590 --> 00:04:04,930
>> В Python, пишете
картотекирате, изпълнява файла,

84
00:04:04,930 --> 00:04:07,882
програмата започва изпълняващата
в горната част на файла.

85
00:04:07,882 --> 00:04:09,590
Така че това ще започне
в горната част на файл

86
00:04:09,590 --> 00:04:11,280
отидете надолу, докато се намери нещо друго.

87
00:04:11,280 --> 00:04:14,440
Ако установи, дефиниция на функция,
той всъщност няма да се изпълни този код,

88
00:04:14,440 --> 00:04:15,940
то просто ще определи функцията.

89
00:04:15,940 --> 00:04:18,459
Но тук, когато първият
програма е п е равно на 10,

90
00:04:18,459 --> 00:04:21,273
първото нещо, което тази програма
ще направим, е да се възползвам от тази стойност от 10

91
00:04:21,273 --> 00:04:24,120
и да го настроите в променлива наречена п.

92
00:04:24,120 --> 00:04:27,690
>> Говорейки за тази линия, един от
друга things-- sorry-- това

93
00:04:27,690 --> 00:04:31,040
означава, че програмите на С,
ще ги напиша,

94
00:04:31,040 --> 00:04:34,899
ще ги направи, което ще
позове някои звън команди,

95
00:04:34,899 --> 00:04:36,690
и тогава ще изпълните
Получената изпълним.

96
00:04:36,690 --> 00:04:41,030
Python програми, можете да стартирате
текст file-- този mario.py мощ

97
00:04:41,030 --> 00:04:44,900
бъде този файл, че аз просто показа
you-- ще тече този файл

98
00:04:44,900 --> 00:04:47,450
и ще се изпълни,
и съдържанието на това

99
00:04:47,450 --> 00:04:50,390
ще бъде изпълнен от
интерпретатора на Питон.

100
00:04:50,390 --> 00:04:52,470
Можете да направите това във вашия IDE.

101
00:04:52,470 --> 00:05:02,260
>> Така че, ако имам файл Здравейте,
който просто има това съдържание.

102
00:05:02,260 --> 00:05:04,840
Това всъщност е Python
2, не Python 3, така че не го правят

103
00:05:04,840 --> 00:05:06,600
притеснявате за синтаксиса за сега.

104
00:05:06,600 --> 00:05:14,230
Но аз ще тичам Python, за
hello.py, и той работи.

105
00:05:14,230 --> 00:05:18,890
>> Друг начин, по който мога да използвам, че Python
Аз няма да се справи с толкова много в този разговор,

106
00:05:18,890 --> 00:05:21,840
е, ако аз просто напишете Python, тя
ми падне в една среда, където

107
00:05:21,840 --> 00:05:24,370
Мога да я храня Python ред по ред.

108
00:05:24,370 --> 00:05:31,260
Така че тук, ако напишете в
принт пространство "Hello, World".

109
00:05:31,260 --> 00:05:32,360
Въведете влиза.

110
00:05:32,360 --> 00:05:37,430
Тя ще ме плюят, че подкрепят резултатите
това лице линия веднага.

111
00:05:37,430 --> 00:05:38,470
>> Това може да бъде полезно.

112
00:05:38,470 --> 00:05:40,700
В този разговор аз ще направя нещата по предметни стъкла.

113
00:05:40,700 --> 00:05:43,940
И така, вие ще бъдете в състояние да следват
заедно или тук, или като пишете

114
00:05:43,940 --> 00:05:45,725
действителните файлове и след това да ги изпълнява.

115
00:05:45,725 --> 00:05:48,340

116
00:05:48,340 --> 00:05:50,995
>> Но, да се върна към това
код, още нещо

117
00:05:50,995 --> 00:05:53,230
че може да се наложи
noticed-- добре, има

118
00:05:53,230 --> 00:05:55,980
две неща, които може да
забележите, за тези блокове.

119
00:05:55,980 --> 00:05:59,280
Първият, по-скоро по-банално, е, че
питона не изоставаше и запетая.

120
00:05:59,280 --> 00:06:02,630
>> Точка и запетая не са задължителни навсякъде
и безвредни навсякъде.

121
00:06:02,630 --> 00:06:03,722
Можете да ги добавите.

122
00:06:03,722 --> 00:06:06,430
То може да накара хората, които пишат
Python за един живот кикот по вас

123
00:06:06,430 --> 00:06:08,860
зад гърба ти, защото
те не са необходими.

124
00:06:08,860 --> 00:06:13,497
Те често са признак на задържани над
от C. Дизайнерите на езика

125
00:06:13,497 --> 00:06:16,580
Чувствам, че това е по-ясно, по този начин
и че не е необходимо да се декларират

126
00:06:16,580 --> 00:06:18,700
всеки път, когато в крайна линия.

127
00:06:18,700 --> 00:06:21,799
>> Друго странно нещо за този п
е че не разполага тип приложен.

128
00:06:21,799 --> 00:06:24,590
Един от най-вълшебните парчета Python--
и аз отивам да го наричат ​​магия,

129
00:06:24,590 --> 00:06:26,381
но има много
технически причини, поради които

130
00:06:26,381 --> 00:06:28,560
works-- един от най-
вълшебните парчета на Python

131
00:06:28,560 --> 00:06:32,700
е, че променливи могат да се разширяват или
свие до съдържат каквото и данни

132
00:06:32,700 --> 00:06:34,530
видове, които бихте ги да искат.

133
00:06:34,530 --> 00:06:35,580
>> Така че това е 10.

134
00:06:35,580 --> 00:06:40,060
Ако по-късно надолу I определено на тази
п 0.5, това ще отнеме, че 0.5.

135
00:06:40,060 --> 00:06:43,770
Без значение, че това е едно цяло число тук и
плува там, нещо, което използва този п

136
00:06:43,770 --> 00:06:47,057
ще, повече или по-малко, да може да пъхтене
заедно ако стане една от тези.

137
00:06:47,057 --> 00:06:49,640
Освен ако няма някаква реална
причина, поради която не може да използва данните

138
00:06:49,640 --> 00:06:52,170
написали, че в момента има п,
в този момент той ще получите

139
00:06:52,170 --> 00:06:54,490
заклещва и хвърлят грешка,
и тези различни неща.

140
00:06:54,490 --> 00:06:57,050
>> Но тук, Python
не ми пука какво

141
00:06:57,050 --> 00:06:59,140
то е, че аз отивам да се придържаме в тази
изречение, като, искате това нещо?

142
00:06:59,140 --> 00:06:59,840
Това нещо в това?

143
00:06:59,840 --> 00:07:00,640
Да, това е вид на нещо.

144
00:07:00,640 --> 00:07:01,810
Аз ще го залепите в края.

145
00:07:01,810 --> 00:07:04,740
Това ще бъде проблем по-късно, ако
някой, който иска да използва тази цел

146
00:07:04,740 --> 00:07:05,710
не може да се справи.

147
00:07:05,710 --> 00:07:08,500
Това е една от най-големите
разлики между Python и C

148
00:07:08,500 --> 00:07:10,790
който го прави лесно да се
напиша много големи програми C

149
00:07:10,790 --> 00:07:15,120
и го прави по-лесно да се напише
много малък Python програма.

150
00:07:15,120 --> 00:07:19,564
>> The за синтаксис не е много
различно от това, което той прави.

151
00:07:19,564 --> 00:07:21,480
Това е малко по-различен
в това как тя е изразена.

152
00:07:21,480 --> 00:07:25,370
Така че това е един много, което се нарича
Pythonic, начин да го пишете.

153
00:07:25,370 --> 00:07:28,969
за ред в диапазон (п), това е най-
поредица от номера от 0 до п,

154
00:07:28,969 --> 00:07:31,010
включително на дъното
и изключително на върха.

155
00:07:31,010 --> 00:07:34,790
Така че е от 0 до п-1, което е
точно това, кодът C се правят,

156
00:07:34,790 --> 00:07:38,690
освен това е много по-лесно
да погледнем може би.

157
00:07:38,690 --> 00:07:42,710
>> Съответният блок е
не тръгна с тиранти,

158
00:07:42,710 --> 00:07:44,540
вместо това е тръгна
от тази вдлъбнатина.

159
00:07:44,540 --> 00:07:47,580
Така че всички тези линии са
четири пространства над надясно,

160
00:07:47,580 --> 00:07:50,410
или като за ширина на слон.

161
00:07:50,410 --> 00:07:54,570
И тези, които са тези, които са
ще бъде изпълнена в тази за.

162
00:07:54,570 --> 00:07:57,020
Ако аз обърквам
отстъп по този въпрос и аз

163
00:07:57,020 --> 00:08:01,420
бутнете че печатащата обратно
оригиналния вдлъбнатина,

164
00:08:01,420 --> 00:08:04,320
че на печат ще остави за контур.

165
00:08:04,320 --> 00:08:08,560
За разлика от C, когато тук аз всъщност
трябва да се движат, че затворената скоба наоколо.

166
00:08:08,560 --> 00:08:11,820
>> Това означава, че те не получават грешки
че се хвърли върху вас, защото вие

167
00:08:11,820 --> 00:08:13,580
сложи скоба в грешното място.

168
00:08:13,580 --> 00:08:16,460
Това означава, че можете да получите грешки
че се хвърли върху вас, защото вие

169
00:08:16,460 --> 00:08:17,620
разчленена линия погрешно.

170
00:08:17,620 --> 00:08:19,290
Така че има вдлъбнатини супер внимателни.

171
00:08:19,290 --> 00:08:22,123
Надяваме се, бяха като супер
Внимавай с отстъп или иначе,

172
00:08:22,123 --> 00:08:25,300
и така, че това не е
много по-голямо бреме.

173
00:08:25,300 --> 00:08:28,762
>> Но основно правило за Python,
и ще имаме няколко от тях

174
00:08:28,762 --> 00:08:30,970
че ще мине през през
По време на разговора,

175
00:08:30,970 --> 00:08:33,840
се опитайте естествен синтаксис
преди да погледне нещо нагоре.

176
00:08:33,840 --> 00:08:37,610
Така че този синтаксис, за
този номер в обхват,

177
00:08:37,610 --> 00:08:41,460
Много е отличителен по отношение на стила.

178
00:08:41,460 --> 00:08:45,260
Много неща в Python
ще видим, като тази форма.

179
00:08:45,260 --> 00:08:47,420
>> И така, ако излезе
с нов обект, който ви

180
00:08:47,420 --> 00:08:50,870
Мисля, че трябва да бъде в състояние да
обхождане това, в този формат,

181
00:08:50,870 --> 00:08:53,720
Оказва се, че вероятно
поддържа този формат.

182
00:08:53,720 --> 00:08:56,990
Ние няма да отиде супер дълбоко в
техническите причини, поради които е вярно.

183
00:08:56,990 --> 00:09:00,167
>> Но това е полезно да има интуиция
когато сте приближава Python програми,

184
00:09:00,167 --> 00:09:01,750
че това нещо е просто ще работят.

185
00:09:01,750 --> 00:09:03,020
Опитай.

186
00:09:03,020 --> 00:09:06,480
Обувка горе командния ред
Interpreter, да видим дали тя работи,

187
00:09:06,480 --> 00:09:09,827
продължим с нещата, преди да
дори трябва да се отворят Google и да кажа,

188
00:09:09,827 --> 00:09:11,660
какъв е синтаксиса
този конкретен нещо?

189
00:09:11,660 --> 00:09:14,740
Много Python бихте могли да
открият само като се опита.

190
00:09:14,740 --> 00:09:19,005
>> Това, ако е още по сходен
да C тогава Форс са.

191
00:09:19,005 --> 00:09:20,380
Имайте предвид, че няма скоби.

192
00:09:20,380 --> 00:09:23,490
В скоби са отново
безобидни, но ненужни.

193
00:09:23,490 --> 00:09:25,750
Има дебелото черво в края
точно като за електрически вериги,

194
00:09:25,750 --> 00:09:30,800
и отново, относителните блокове са
разчленена, а не тръгна от скоби.

195
00:09:30,800 --> 00:09:33,080
Това останало е в оригинала
ниво на вдлъбнатина,

196
00:09:33,080 --> 00:09:35,930
както и съответстващите блок разчленена отново.

197
00:09:35,930 --> 00:09:41,720
Тези, работа точно както правят в C.

198
00:09:41,720 --> 00:09:44,520
>> Това всъщност е много същото.

199
00:09:44,520 --> 00:09:49,430
Отново печат губи един символ
на разстояние от ФОРМАТ Минавате някои струни.

200
00:09:49,430 --> 00:09:51,520
Оказва се, струни
могат или да бъдат разграфени

201
00:09:51,520 --> 00:09:53,562
от единични кавички или двойни кавички.

202
00:09:53,562 --> 00:09:55,270
Няма разлика,
освен, че вътре

203
00:09:55,270 --> 00:09:57,722
на единични кавички можете да използвате
двойни кавички с изоставят,

204
00:09:57,722 --> 00:09:59,430
а не да се налага да
избягат всички от тях.

205
00:09:59,430 --> 00:10:01,480
И вътре в двойни кавички, вие
да използвате единични кавички с изоставят

206
00:10:01,480 --> 00:10:02,420
без да ги избегне.

207
00:10:02,420 --> 00:10:04,253
Ако искате да се смесват
тях, вие със сигурност може да

208
00:10:04,253 --> 00:10:06,100
гледам онлайн как се прави това.

209
00:10:06,100 --> 00:10:09,581
>> Ще забележите, че тук,
Аз бях приет през край = това нещо.

210
00:10:09,581 --> 00:10:12,580
Това е пример на незадължителен
аргумент, който е едно от онези неща

211
00:10:12,580 --> 00:10:14,990
че Python поддържа, че
го прави доста полезно.

212
00:10:14,990 --> 00:10:18,240
Така печат всъщност има много
аргументи, които обикновено са

213
00:10:18,240 --> 00:10:20,140
настроен на тяхното неизпълнение
стойност, но тук съм

214
00:10:20,140 --> 00:10:21,924
реши да замени този, наречен край.

215
00:10:21,924 --> 00:10:24,340
Причината, поради която аз трябва да
го замени с празен низ

216
00:10:24,340 --> 00:10:26,756
е, че за печат в Python, от
подразбиране, отпечатва нов ред

217
00:10:26,756 --> 00:10:28,630
след което можете да го казал също.

218
00:10:28,630 --> 00:10:31,462
>> Така че този хеш всъщност ще
разпечатате хеш на нов ред.

219
00:10:31,462 --> 00:10:34,670
И ако аз не искам хеш да разпечатате
нов ред след това, тогава аз трябва да кажа,

220
00:10:34,670 --> 00:10:35,340
не извежда един.

221
00:10:35,340 --> 00:10:37,980

222
00:10:37,980 --> 00:10:43,690
Но, все още е така, едно последно нещо, което
тази програма липсва, че човек има е

223
00:10:43,690 --> 00:10:44,960
включва един в горната част.

224
00:10:44,960 --> 00:10:48,120
Print се пече в Python така че основно
че няма горен или модул

225
00:10:48,120 --> 00:10:49,869
че трябва да се
включват, макар че ако исках

226
00:10:49,869 --> 00:10:52,029
да се включат и други неща
в Python скрипт,

227
00:10:52,029 --> 00:10:55,320
Аз ще го направя по много подобен format--
думите са само малко по-различни.

228
00:10:55,320 --> 00:10:58,840

229
00:10:58,840 --> 00:11:01,360
>> Споменах, че ние
не се нуждаят от основна тук,

230
00:11:01,360 --> 00:11:03,372
защото питона започва
изпълнение на върха.

231
00:11:03,372 --> 00:11:05,080
Ако исках да приключи
това във функция, I

232
00:11:05,080 --> 00:11:07,667
ще го направя като this-- I
бих казал името дефиниция функция,

233
00:11:07,667 --> 00:11:10,500
аргументи могат да отидат в тук и ние ще
виж някои от тези, които по-късно, на дебелото черво,

234
00:11:10,500 --> 00:11:13,040
и след това отново, този
Цялата тръгна блок

235
00:11:13,040 --> 00:11:16,810
е това, което е оперативно
блокират за тази функция.

236
00:11:16,810 --> 00:11:18,560
Така че това е определението
на функцията.

237
00:11:18,560 --> 00:11:21,587
А има и декларация, после надолу
тук, мога просто да извикате функцията.

238
00:11:21,587 --> 00:11:23,920
И отново, програмата
преводач, започвайки от върха,

239
00:11:23,920 --> 00:11:25,280
Ще видите това е определението.

240
00:11:25,280 --> 00:11:27,960
Тя няма да се изпълни това, докато не
стигнем до тук, а след това е като, о

241
00:11:27,960 --> 00:11:30,860
Сега сте го нарича, I
Предполагам, че трябва да го изпълни.

242
00:11:30,860 --> 00:11:33,850
>> А нещо, което е много често срещано
да се види в Python файлове,

243
00:11:33,850 --> 00:11:36,700
особено Python файлове, които
са достъпни за обществеността

244
00:11:36,700 --> 00:11:41,650
и развива по-- и разработени и
поддържа, е нещо от този вид.

245
00:11:41,650 --> 00:11:44,540
Това е така, защото basically--
Python, да започнете в горната

246
00:11:44,540 --> 00:11:50,310
и тогава ще се изпълни до дъното,
Аз ако аз просто трябваше Mario извика тук,

247
00:11:50,310 --> 00:11:54,190
След всяко време съм включил този файл в
друг файл, защото исках да използвам

248
00:11:54,190 --> 00:11:58,580
Mario е функция, която би друг файл
също имат този призив да Mario в него.

249
00:11:58,580 --> 00:12:01,000
И когато аз се завтече този файл,
тя ще се обади на Марио.

250
00:12:01,000 --> 00:12:04,520
>> Така че това е възможно, че само аз
искате да изпълните това, ако аз съм всъщност

251
00:12:04,520 --> 00:12:07,290
Добрата този конкретен файл.

252
00:12:07,290 --> 00:12:11,520
И така, аз да наслагвате това в
идиом, подобен на този, когато казвам,

253
00:12:11,520 --> 00:12:14,820
ако името на това изпълнение
среда е основна,

254
00:12:14,820 --> 00:12:16,200
След това искам да правя тези неща.

255
00:12:16,200 --> 00:12:18,710
В противен случай някой друг не може
use-- включва ми function--

256
00:12:18,710 --> 00:12:22,510
досието ми, и само за да получите
достъп до тези функции

257
00:12:22,510 --> 00:12:25,552
без да се налага да тичам нещата
че искам да се изпълни в този файл.

258
00:12:25,552 --> 00:12:27,260
Това е, отново, по желание
но много често.

259
00:12:27,260 --> 00:12:30,450

260
00:12:30,450 --> 00:12:33,840
>> Тези неща са entirely-- са
точно същото между C и Python,

261
00:12:33,840 --> 00:12:35,100
Със сигурност в 3.

262
00:12:35,100 --> 00:12:38,610
Мисля, че в 2, операторът на разделение
понякога дава назад, когато плува

263
00:12:38,610 --> 00:12:41,450
можете опериран цели числа, и или
което исках, че или не сте.

264
00:12:41,450 --> 00:12:44,777
Но плюс, минус, и времена
работи точно като можете да очаквате,

265
00:12:44,777 --> 00:12:46,110
възразява над леко повече видове.

266
00:12:46,110 --> 00:12:49,740
Така че можете да се размножават чрез поплавъци
цели числа, както и тези видове неща.

267
00:12:49,740 --> 00:12:52,480
>> набор работи точно същото.

268
00:12:52,480 --> 00:12:54,310
Можете да използвате две равни знаци.

269
00:12:54,310 --> 00:12:59,000
inequals-- по-голямо от, по-малко
от тези видове things--

270
00:12:59,000 --> 00:13:02,580
имат значенията, които
вие сте запознат с тях.

271
00:13:02,580 --> 00:13:05,770
>> Къде C използва тези оператори,
Python използва малко по-English

272
00:13:05,770 --> 00:13:06,390
четими такива.

273
00:13:06,390 --> 00:13:09,348
Така че, вместо две, амперсанди, вие
буквално написали думата "и", "или"

274
00:13:09,348 --> 00:13:10,740
или не."

275
00:13:10,740 --> 00:13:13,420
Както във вашия if-- във вашия
условни конструкции,

276
00:13:13,420 --> 00:13:17,670
видяхме по-рано, че този синтаксис в C
съответства на този синтаксис в Python.

277
00:13:17,670 --> 00:13:21,010
И там не е много по-различно
там, с изключение на малко по-

278
00:13:21,010 --> 00:13:24,780
на препинателни знаци около страни.

279
00:13:24,780 --> 00:13:28,890
Отново, където C би останало
ако, Python използва Елиф,

280
00:13:28,890 --> 00:13:33,960
но това са най-вече
промени на повърхността.

281
00:13:33,960 --> 00:13:38,450
>> Повторение, като това е често
писано в тази идиом в Python.

282
00:13:38,450 --> 00:13:42,350
Вие може да произвежда този вид
нещо, с линия, докато отвън

283
00:13:42,350 --> 00:13:46,387
ако искаш, но ти
със сигурност не е нужно да.

284
00:13:46,387 --> 00:13:48,970
И пак, ако искате на
разпечатате елементи в масив от

285
00:13:48,970 --> 00:13:50,560
може да го направи по този начин.

286
00:13:50,560 --> 00:13:52,927
Един от най-забавните неща
за Python обаче,

287
00:13:52,927 --> 00:13:54,760
е, че не е нужно
За да използвате тази парадигма,

288
00:13:54,760 --> 00:13:57,290
и можете да използвате
малко по-елегантен един.

289
00:13:57,290 --> 00:13:59,370
Вие казвате за в ари.

290
00:13:59,370 --> 00:14:02,980
>> Така че, вместо да пътуват тук
препълнена индексите,

291
00:14:02,980 --> 00:14:05,630
и след това се изтегля
отделни елементи,

292
00:14:05,630 --> 00:14:08,644
ви кажа за да всъщност просто
прегазен самите елементи.

293
00:14:08,644 --> 00:14:11,060
И тогава каквото и да правите
вътре може да работи директно

294
00:14:11,060 --> 00:14:13,260
за елементите, което е доста забавно.

295
00:14:13,260 --> 00:14:16,710
И ние ще see-- ще използваме
отново и отново, че идиом

296
00:14:16,710 --> 00:14:18,050
като ходим чрез код.

297
00:14:18,050 --> 00:14:20,091
>> Това е, отново, пример
на нещо, което аз ще

298
00:14:20,091 --> 00:14:23,300
обадете Python магия, въпреки че има
много технически причини, поради които тя работи.

299
00:14:23,300 --> 00:14:26,340
И там са технически неща, които
трябва да бъде вярно за масив, за

300
00:14:26,340 --> 00:14:28,340
за това да работят зад кулисите.

301
00:14:28,340 --> 00:14:31,390
Работата е там, че повечето видове
които можете да очаквате това да работят

302
00:14:31,390 --> 00:14:36,610
са имали тази реализира за
сте в вградени езика.

303
00:14:36,610 --> 00:14:40,030
>> Друго нещо, което би било хубаво
ако това е работил във всеки език,

304
00:14:40,030 --> 00:14:45,460
но са налице някои от причините, поради които не може,
Принтирай тази струнни пъти този номер.

305
00:14:45,460 --> 00:14:48,860
Оказва се, че в Python, това прави точно
това, което искате, който е само забавление,

306
00:14:48,860 --> 00:14:52,840
и означава, че ние можем действително
намаляване на тази програма, отново mario.c.

307
00:14:52,840 --> 00:14:57,150
Вместо да итерации много, което можем
само да кажа, искам някакъв брой на местата,

308
00:14:57,150 --> 00:15:01,120
Искам броя на хешове,
и някои хешове в края.

309
00:15:01,120 --> 00:15:02,640
И пак, ние използваме този формат.

310
00:15:02,640 --> 00:15:05,340
>> Ето, ние сме преминаване в
променлива този начин.

311
00:15:05,340 --> 00:15:08,050
Отново, ние не трябва да се каже,
какъв тип е променлива,

312
00:15:08,050 --> 00:15:11,322
и единственият път, ние ще
получите грешки е по време на изпълнение.

313
00:15:11,322 --> 00:15:13,030
Когато някой се опитва
да премине в нещо,

314
00:15:13,030 --> 00:15:14,860
тя ще влезе в функцията само глоба.

315
00:15:14,860 --> 00:15:18,240
Ако ние клин тук, защото това не е
нещо, което можете да създадете обхвати над,

316
00:15:18,240 --> 00:15:22,100
Ще получите по време на работа грешка там,
и аз ще трябва да го трасира по този начин.

317
00:15:22,100 --> 00:15:25,050
Но междувременно, аз нямам
да бъдем много внимателни за това,

318
00:15:25,050 --> 00:15:32,800
да се изпраща в, докато в действителната
изпълнение всичко работи много чисто.

319
00:15:32,800 --> 00:15:35,080
>> Аз дори може да направи това
малко по-чист

320
00:15:35,080 --> 00:15:41,770
с помощта на специално вградена функция
на низове, които се Подравняване отдясно.

321
00:15:41,770 --> 00:15:45,250
Това е само една полезна функция
разположена около библиотеката.

322
00:15:45,250 --> 00:15:47,660
Това е в документацията
ако отидете и потърсете го.

323
00:15:47,660 --> 00:15:51,650
И аз казвам, добре Отивам да имат
този низ, някои брой хешове,

324
00:15:51,650 --> 00:15:56,390
и бих искал да оправдае правото it-- подложка
то с празни места, за да бъде тази дължина.

325
00:15:56,390 --> 00:16:00,584
>> Отново, това е в
документация, която носи us--

326
00:16:00,584 --> 00:16:03,500
Аз всъщност ще кликвате these--
което ни довежда до втората ни норма

327
00:16:03,500 --> 00:16:06,990
за Python-- стандартната библиотека
методи функция са вашите приятели.

328
00:16:06,990 --> 00:16:09,880
И това е често за вас
да отида търси Чудя

329
00:16:09,880 --> 00:16:12,310
ако има нещо, което просто прави това.

330
00:16:12,310 --> 00:16:13,830
Има вероятно е.

331
00:16:13,830 --> 00:16:15,990
Ако искате да тампон
изложени низ, ако искате

332
00:16:15,990 --> 00:16:17,470
искал да се възползвам гърба
половината от низ, ако искате

333
00:16:17,470 --> 00:16:20,370
искали да се търси чрез низ, ако
бихте искали да смачка няколко неща

334
00:16:20,370 --> 00:16:22,420
заедно с низ
със запетаи между тях,

335
00:16:22,420 --> 00:16:24,640
има стандартна библиотека
функции за извършване на това.

336
00:16:24,640 --> 00:16:27,190
>> И това прави живота ви
по-лесно, ако ги използвате

337
00:16:27,190 --> 00:16:29,240
вместо разточване
всичко по своему

338
00:16:29,240 --> 00:16:31,650
в пет реда код тук,
пет реда код тук.

339
00:16:31,650 --> 00:16:34,430
Това наистина започва в
добавите до реално време.

340
00:16:34,430 --> 00:16:37,430
>> Един от най-интересните неща
за това как получава т.нар.

341
00:16:37,430 --> 00:16:39,980
Ще забележите, че има нещо, точка.

342
00:16:39,980 --> 00:16:43,490
Имам някакъв предмет в ляво,
и след това се обадих функция една точка.

343
00:16:43,490 --> 00:16:49,780
Това е една от парадигмите, че Python
използва за закрепване на методи за обекти.

344
00:16:49,780 --> 00:16:54,410
Ще говорим за това, което този
е съвсем накратко в края,

345
00:16:54,410 --> 00:16:58,510
но знам, че и ние може да работи с
неща, като взима това нещо казват дот

346
00:16:58,510 --> 00:17:01,690
независимо, или като се обадите
функция, която отнема

347
00:17:01,690 --> 00:17:04,339
този обект и някои други аргументи.

348
00:17:04,339 --> 00:17:07,450
>> Така че това са двата начина, по които
неща се правят в Python.

349
00:17:07,450 --> 00:17:09,780
И дали конкретна
функционалност е реализирана

350
00:17:09,780 --> 00:17:14,230
в този стил или този
стил е нещо, което

351
00:17:14,230 --> 00:17:19,990
трябва да погледнете нагоре, докато не получите цаката
за които един е вероятно да попаднат в.

352
00:17:19,990 --> 00:17:22,660
Има повече или по-малко сплотено
философията зад Python

353
00:17:22,660 --> 00:17:24,930
че можете да абсорбира най-вече
вписвайки много в него.

354
00:17:24,930 --> 00:17:28,190
В един момент, който един от тях
нещо ще се прилага като

355
00:17:28,190 --> 00:17:29,470
става естествено.

356
00:17:29,470 --> 00:17:32,420
За сега, това е просто нещо
можете да научите колкото разбера

357
00:17:32,420 --> 00:17:34,140
всеки отделен нещо.

358
00:17:34,140 --> 00:17:36,420
>> Така стандартната библиотека
функции са моите приятели,

359
00:17:36,420 --> 00:17:41,320
и те да ви пиша неща, които
заемат много място това наистина скоро,

360
00:17:41,320 --> 00:17:42,040
наистина елегантно.

361
00:17:42,040 --> 00:17:45,670
И всъщност това е може би по-
четливи, бих казал, от програмата C

362
00:17:45,670 --> 00:17:46,780
Ето там.

363
00:17:46,780 --> 00:17:49,730
Да не говорим за факта, че е така
Накратко може да се побере цяло слон

364
00:17:49,730 --> 00:17:52,250
в пространството, че сме спасени.

365
00:17:52,250 --> 00:17:56,270
>> Друго нещо, това е реализация
на Марио, който е точка C, която мисля, че

366
00:17:56,270 --> 00:17:57,890
е най-краткият можете да го получите.

367
00:17:57,890 --> 00:18:00,757
Тя не разполага с GET ср, но
тя твърди кодове на стойност 10

368
00:18:00,757 --> 00:18:02,090
по същия начин, че този човек прави.

369
00:18:02,090 --> 00:18:06,080
Оказва се, че това един часовници в най-
84 знака, че Python е 64.

370
00:18:06,080 --> 00:18:11,490
И това е безкрайно по-
неразбираем от този боклук тук.

371
00:18:11,490 --> 00:18:14,610
Така че Python е по-ефективно в пространството.

372
00:18:14,610 --> 00:18:17,260
Това е малко по-малко ефективен
във времето, но не много.

373
00:18:17,260 --> 00:18:18,890
>> Списъци са важно нещо в Python.

374
00:18:18,890 --> 00:18:21,540

375
00:18:21,540 --> 00:18:24,587
Ние не съм ги виждал, но те
работят много като масиви правят в C.

376
00:18:24,587 --> 00:18:27,170
Така че тук, можете да ги декларират,
можете да ги премине в нещо.

377
00:18:27,170 --> 00:18:29,810
Сега площади притежава
масив от тези неща.

378
00:18:29,810 --> 00:18:33,480
Отново, ние не са декларирани като
тип, но ако някога се опита да го използва,

379
00:18:33,480 --> 00:18:36,260
всичко, което можете да очаквате да
работят на масив от цели числа

380
00:18:36,260 --> 00:18:40,130
ще работи върху
набор от числа.

381
00:18:40,130 --> 00:18:42,030
>> Това е нещо, което
сте абсолютно не може

382
00:18:42,030 --> 00:18:47,390
направя в C, понеже
памет е толкова ръце,

383
00:18:47,390 --> 00:18:48,950
но е много лесно да се направи в Python.

384
00:18:48,950 --> 00:18:55,310
Ако искам да ми бъде по-голям масив, което мога
добавяне на елемент към нея, и това е добре.

385
00:18:55,310 --> 00:18:57,150
>> Какво се случва зад кулисите?

386
00:18:57,150 --> 00:18:59,150
Преводачът ще отидат
и да получите някакъв спомен,

387
00:18:59,150 --> 00:19:00,860
и може би това ще получите
малко повече памет,

388
00:19:00,860 --> 00:19:03,090
така че аз не съм толкова не е нужно
да презаделяне всеки път.

389
00:19:03,090 --> 00:19:04,897
Но колко имат повече
памет нужда от нея?

390
00:19:04,897 --> 00:19:06,730
Това не са решения
че трябва да се направи,

391
00:19:06,730 --> 00:19:10,540
това са решенията, които най-
преводач, ще направи.

392
00:19:10,540 --> 00:19:12,270
>> Тук виждаме гама може
отнеме два аргумента,

393
00:19:12,270 --> 00:19:16,430
но тя все още продължава да бъде включено
на върха, така че ние да добавите 1 там.

394
00:19:16,430 --> 00:19:21,970
Това е идиом, което е още по-
хитър начин да напише такива неща.

395
00:19:21,970 --> 00:19:25,980
Тя се нарича списък с разбиране,
и тук това, което казвате,

396
00:19:25,980 --> 00:19:32,560
е Бих искал да пробва аз квадрат
за всяка стойност на аз в този диапазон.

397
00:19:32,560 --> 00:19:35,770
Това нещо в дясно може да бъде друг
масив, и това нещо в ляво

398
00:19:35,770 --> 00:19:40,740
да бъде определена функция
че ще вземе в аз като променлива

399
00:19:40,740 --> 00:19:42,250
и ми даде някои резултат.

400
00:19:42,250 --> 00:19:43,480
>> Това, което ще направя е,
Отивам да се изгради

401
00:19:43,480 --> 00:19:46,200
масив, който е всички тези неща
за всяка стойност в този диапазон.

402
00:19:46,200 --> 00:19:48,960

403
00:19:48,960 --> 00:19:55,670
И това е супер елегантен, супер кратка,
и това е много ясно какво означава това.

404
00:19:55,670 --> 00:19:59,190
Това е една от най-
things-- това е отново,

405
00:19:59,190 --> 00:20:03,860
една of-- много емблематичен за
съображения, че хора като Python.

406
00:20:03,860 --> 00:20:05,900
Ако искате програмиране
по този начин, след това Python

407
00:20:05,900 --> 00:20:07,830
е език може би искате да научите.

408
00:20:07,830 --> 00:20:10,950
>> И пак, има техническа
причини защо става това.

409
00:20:10,950 --> 00:20:14,730
Но доколкото ние сме засегнати,
ние повече или по-малко не ме интересува.

410
00:20:14,730 --> 00:20:18,500
>> Така че, ако искате да разпечатате списъци,
някои от същите идиоми са полезни.

411
00:20:18,500 --> 00:20:20,940
Защото в този диапазон, можехме
индекса през всички неща,

412
00:20:20,940 --> 00:20:23,140
и след това да ги отпечатате.

413
00:20:23,140 --> 00:20:24,650
И ще видите Лен тук.

414
00:20:24,650 --> 00:20:27,150
Ако някога сте искали да получите
дължината на масива, че е

415
00:20:27,150 --> 00:20:31,150
много лесно в Python,
това е много трудно в C.

416
00:20:31,150 --> 00:20:33,720
Това ще отпечата точно
това, което бихте го очакваме да.

417
00:20:33,720 --> 00:20:36,986
Бихме могли също така, както сме виждали преди,
обхождане на елементите в масив

418
00:20:36,986 --> 00:20:39,860
директно, а след това просто да се говори за
тях, а не като индекса

419
00:20:39,860 --> 00:20:43,190
обратно в масива всеки път.

420
00:20:43,190 --> 00:20:45,990
>> И това е нещо, което можеш да направиш.

421
00:20:45,990 --> 00:20:49,984
Така че в C, ако питаш за нещо
като този, печат бих казал,

422
00:20:49,984 --> 00:20:51,150
това е масив от цели числа.

423
00:20:51,150 --> 00:20:53,456
Това определено не е по-
низ, не мога да го отпечатате.

424
00:20:53,456 --> 00:20:54,830
Python повече или по-малко не се интересува.

425
00:20:54,830 --> 00:20:57,496
Това е като, има ли начин, че аз
може да се превърне това в в низ?

426
00:20:57,496 --> 00:20:58,500
Да, аз ще го направя.

427
00:20:58,500 --> 00:21:01,600
И така, аз просто ще отпечатате, че навън.

428
00:21:01,600 --> 00:21:03,640
Това означава, че можете да
правят неща like-- тях

429
00:21:03,640 --> 00:21:06,530
са повечето от твърдите части
на игра на петнайсет, написани

430
00:21:06,530 --> 00:21:08,930
съвсем накратко в Python.

431
00:21:08,930 --> 00:21:11,320
>> Ще видите, че има
малко of-- тук

432
00:21:11,320 --> 00:21:14,441
Аз бях хвърлен цяло число в низ,
и аз трябва да направя това ръчно.

433
00:21:14,441 --> 00:21:16,190
И аз отивам да добавите
то на друг низ,

434
00:21:16,190 --> 00:21:17,590
или по друг начин Python се обърква.

435
00:21:17,590 --> 00:21:19,840
Но дали, когато сте
добавяне на низ в цяло число,

436
00:21:19,840 --> 00:21:22,630
съм предполагам, за да получите
цяло число в гърба или низ обратно?

437
00:21:22,630 --> 00:21:24,480
Но отново, ако просто
обадете ул по нещо,

438
00:21:24,480 --> 00:21:27,240
и той би могъл по никакъв възможно
свят се превръща в низ,

439
00:21:27,240 --> 00:21:30,390
тя вероятно ще бъде
превръща в низ.

440
00:21:30,390 --> 00:21:33,120
>> Тук виждаме, използване на
вложените списък с разбиране

441
00:21:33,120 --> 00:21:38,690
отляво някои индексиране, което
е точно така, както искате да се използва за нея,

442
00:21:38,690 --> 00:21:40,060
а някои отпечатване на нещата.

443
00:21:40,060 --> 00:21:42,560
Отново сме определено някои
функции и ние ще ги наричаме надолу

444
00:21:42,560 --> 00:21:45,820
в основната когато ние действително зареждане на файла.

445
00:21:45,820 --> 00:21:52,004
възвръщаемост работи точно както бихте
очакваме от работата с C. Намерете,

446
00:21:52,004 --> 00:21:54,420
ние можем да се създаде неща като
this-- ето списък с разбиране

447
00:21:54,420 --> 00:21:59,245
има една задача на променлива,
и всъщност можем да го направим още по-лесно.

448
00:21:59,245 --> 00:22:01,870
Ние не трябва да напишете търсене,
защото вградени в езика

449
00:22:01,870 --> 00:22:04,230
е, ако това нещо е в този масив.

450
00:22:04,230 --> 00:22:05,680
Върнете вярно, друго върне фалшиви.

451
00:22:05,680 --> 00:22:08,830
Така че това е съвкупността от находка.

452
00:22:08,830 --> 00:22:12,230
>> Целият сортиране
включва се обадите на сортиране,

453
00:22:12,230 --> 00:22:15,462
които is-- има реализации
на това, вградена в някои C библиотеки.

454
00:22:15,462 --> 00:22:17,170
Ако искате тази
нещо назад, вие

455
00:22:17,170 --> 00:22:20,450
да пренебрегнете тази опция
аргумент в обратната с истинно.

456
00:22:20,450 --> 00:22:23,350

457
00:22:23,350 --> 00:22:27,860
И ако искате да сортирате над
струни, която е вградена, както добре.

458
00:22:27,860 --> 00:22:31,950
>> Така че това не е да се каже, те са
неща, които трябва да направите, всеки ден,

459
00:22:31,950 --> 00:22:34,280
но Идеята е, че този
е философията на Python,

460
00:22:34,280 --> 00:22:37,530
че всички тези неща, който искате
нещо като искам да направя са вградени вътре.

461
00:22:37,530 --> 00:22:42,410
И повечето стандартни функции,
така подредени, дължина, независимо,

462
00:22:42,410 --> 00:22:44,380
подкрепят най-логично разумно вход.

463
00:22:44,380 --> 00:22:49,020
Ти се обадя Лен на масив еднакви
начин ти се обадя Лен на низ.

464
00:22:49,020 --> 00:22:55,785
Можете multiply-- сортирате струни
По същия начин можете сортирате масиви.

465
00:22:55,785 --> 00:22:58,930

466
00:22:58,930 --> 00:23:00,740
>> Повечето стандартни функции
че хората да градят,

467
00:23:00,740 --> 00:23:03,000
и най-трета страна
библиотеки, които хората

468
00:23:03,000 --> 00:23:06,980
изгради, защото те подражават
проектирането на стандартната библиотека,

469
00:23:06,980 --> 00:23:10,190
може да се нарече върху всичко, което сте
харесват, защо не това просто работа,

470
00:23:10,190 --> 00:23:12,800
в C. Повече или по-малко,
тя ще работи в Python

471
00:23:12,800 --> 00:23:15,930
защото хората работят зад фигура
какво нещо е, а след това работи

472
00:23:15,930 --> 00:23:17,510
по подходящ начин върху него.

473
00:23:17,510 --> 00:23:22,760
Така че отново, техническа база, но това
прави живота ни по-лесно като програмисти.

474
00:23:22,760 --> 00:23:26,820
>> Така че тук е файла I / O. подаде I / O има много
малките неща, които го правят сложно,

475
00:23:26,820 --> 00:23:29,890
и така има ресурси
онлайн, но по-накратко,

476
00:23:29,890 --> 00:23:33,010
ти се обадя отворено на файл
назове с определен тип.

477
00:23:33,010 --> 00:23:37,640
Така че това е четене, четене и
пиши, пиши или добавете.

478
00:23:37,640 --> 00:23:41,790
Вие четете определен брой
знаци и вие печатат тези,

479
00:23:41,790 --> 00:23:42,595
вие ще получите Hello!

480
00:23:42,595 --> 00:23:43,970
Искам да кажа, като този файл трябваше Hello!

481
00:23:43,970 --> 00:23:46,480
В него се обадя да се чете,
и това, което ще се върнем

482
00:23:46,480 --> 00:23:49,520
е низ, който притежава всички
на останалата част на масива,

483
00:23:49,520 --> 00:23:50,860
или всички от останалата част от файла.

484
00:23:50,860 --> 00:23:53,805

485
00:23:53,805 --> 00:23:56,055
Ако се обадите прочетете отново,
ти си в края на файла,

486
00:23:56,055 --> 00:23:58,138
и така не се получи
нищо и затова ще се затвори.

487
00:23:58,138 --> 00:24:02,510
Отново, това е .close вместо
близо файл, тъй като това би било в C.

488
00:24:02,510 --> 00:24:07,190
Това е повече или по-малко, защото е е
нещо, и искате за е да се затвори.

489
00:24:07,190 --> 00:24:12,092
Но основния файл I / O не е
особено сложно.

490
00:24:12,092 --> 00:24:15,300
Отново, ако искате да отворите файл, ако
искате да прочетете определен ред,

491
00:24:15,300 --> 00:24:17,870
можете да се измъкнем от специално
line-- има вградени модули за това.

492
00:24:17,870 --> 00:24:19,995
Ако искате да напишете
нещо, можете да напишете това.

493
00:24:19,995 --> 00:24:23,412
Ако искате да напишете индивидуално
ухапвания, можете да напишете тези.

494
00:24:23,412 --> 00:24:25,620
И ако искате да превъртите
над линиите на файл

495
00:24:25,620 --> 00:24:29,557
индивидуално, както направихме в парче от
преди няколко седмици, което можете да направите, че да.

496
00:24:29,557 --> 00:24:32,140
Отново, повечето обекти, които бихте
искал да бъде в състояние да обхождане

497
00:24:32,140 --> 00:24:33,780
подкрепа итерации над тях.

498
00:24:33,780 --> 00:24:37,430
В Питони, даден файл е може би нещо, което
Бих искал да обхождане ред по ред.

499
00:24:37,430 --> 00:24:39,138
Ако това беше речника
на думи и аз бях

500
00:24:39,138 --> 00:24:42,181
се опитва да получи тези, индивидуално
думи, а след това, в рамките на този цикъл,

501
00:24:42,181 --> 00:24:44,180
Онлайн то се случва да бъде
всяка дума от своя страна и това

502
00:24:44,180 --> 00:24:47,880
ще се изпълнява за всеки ред
в преписката, до края на файла.

503
00:24:47,880 --> 00:24:52,280
И отново, ако имам разпечатан всеки
линия, линиите идват с нови линии,

504
00:24:52,280 --> 00:24:54,740
така че аз съм за определяне края
обратно към нещо подобно.

505
00:24:54,740 --> 00:24:56,580
Тогава щях да получите съдържанието на досието ми.

506
00:24:56,580 --> 00:25:03,610

507
00:25:03,610 --> 00:25:07,480
>> Второто нещо, което извършва дейност в
някои начини, като списъци и в някои отношения

508
00:25:07,480 --> 00:25:11,870
като нещо съществено
по-мощен,

509
00:25:11,870 --> 00:25:16,170
са речници, които са наистина
готино да се използва, но основно се разискват

510
00:25:16,170 --> 00:25:17,670
маси под прикритие.

511
00:25:17,670 --> 00:25:23,330
Можете създадете с помощта на точно
два символа, което е страхотно

512
00:25:23,330 --> 00:25:25,959
ако сте се опитали да приложат
хеш-таблица за вашия проблем набор,

513
00:25:25,959 --> 00:25:27,250
Знаете ли, че много болка, която може да бъде.

514
00:25:27,250 --> 00:25:29,390
Но хората са направили
го, и го прави толкова добре,

515
00:25:29,390 --> 00:25:32,260
че не е нужно да
тревожи за това вече.

516
00:25:32,260 --> 00:25:35,180
>> След това можете да вмъкнете индивидуални неща.

517
00:25:35,180 --> 00:25:38,110
Hash tables-- или речници
не особено

518
00:25:38,110 --> 00:25:40,240
интересува това, което съхранявате в тях.

519
00:25:40,240 --> 00:25:44,210
Така че, ако някои записи са числа,
и някои записи са списъци,

520
00:25:44,210 --> 00:25:47,360
ако някои записи и други речници,
и някои записи са струни,

521
00:25:47,360 --> 00:25:49,930
Python не много грижи.

522
00:25:49,930 --> 00:25:53,460
>> Отново, ако отидете в него очаквах
низ и това, което се върна

523
00:25:53,460 --> 00:25:56,269
е масив, това е ваш проблем.

524
00:25:56,269 --> 00:25:58,810
И може би това е по вина на който и да
Мислех, че е пускането неща

525
00:25:58,810 --> 00:26:00,476
в речника, може би това беше ти.

526
00:26:00,476 --> 00:26:02,350
Ако това беше някой
друго, да се надяваме, че са

527
00:26:02,350 --> 00:26:04,520
добре възпитани за това, което
щеше в речника

528
00:26:04,520 --> 00:26:07,420
и не остави никакви клопки
за вас да не попаднат в.

529
00:26:07,420 --> 00:26:10,890
>> Но стандартните функции ще
ти върна добре възпитани неща.

530
00:26:10,890 --> 00:26:13,500
Така че те казват, че това се връща
резервно речник на низове,

531
00:26:13,500 --> 00:26:15,860
тогава всичко ти започваш
да се измъкнем от е низ.

532
00:26:15,860 --> 00:26:20,710
Ако го направите някои от това и го пътувания
вие нагоре, добре, че може да е от вас.

533
00:26:20,710 --> 00:26:25,542
Python със сигурност ви дава достатъчно
въже, за да се мотае, ако искате.

534
00:26:25,542 --> 00:26:28,250
Сега можем да разпечатате индивидуалния
елементи на настоящата и това се връща

535
00:26:28,250 --> 00:26:29,935
точно това, което очаквате.

536
00:26:29,935 --> 00:26:32,810
Точно това, което очаквате, предполагам,
е фраза, че аз съм с много,

537
00:26:32,810 --> 00:26:35,070
но това е повече или по-
по-малко как работи Python.

538
00:26:35,070 --> 00:26:39,880
Ако попитате за нещо, което не е
тя, Python ще изхвърля грешка

539
00:26:39,880 --> 00:26:43,194
и тя ще ви откажат от
каквото и програмата, сте били вътре.

540
00:26:43,194 --> 00:26:45,360
То всъщност ще отпечата
повече информация от тази,

541
00:26:45,360 --> 00:26:49,110
това ще посоча, че ще you--
добавете ред, и така.

542
00:26:49,110 --> 00:26:52,190
>> И, отново, може би искаме
да обхождане речници

543
00:26:52,190 --> 00:26:54,410
и да намерят всички неща в него.

544
00:26:54,410 --> 00:26:57,440
Тук ние итерации над
две неща едновременно.

545
00:26:57,440 --> 00:27:03,040
И така, ние ще го направя с ключ, стойност,
но след това отпечатайте всички от тях.

546
00:27:03,040 --> 00:27:06,300
>> И ако ние искахме да cast--
ако ние действително изтича това,

547
00:27:06,300 --> 00:27:10,840
ние ще имаме някои проблеми, защото
on-- когато отидохме в с Дейвид,

548
00:27:10,840 --> 00:27:13,920
тя не може да add-- ако ние не го направи
хвърли го в низ от една страна,

549
00:27:13,920 --> 00:27:17,802
не бихме могли да добавим, че масив
струни върху низ.

550
00:27:17,802 --> 00:27:19,760
Но ако ние я хвърли към
низ, получаваме нещо

551
00:27:19,760 --> 00:27:22,590
като това, което е може би
това, което ние бихме искали да прочетете.

552
00:27:22,590 --> 00:27:27,000

553
00:27:27,000 --> 00:27:30,500
>> И това е правопис.

554
00:27:30,500 --> 00:27:32,460
Ние току-що прочетох в нещата.

555
00:27:32,460 --> 00:27:35,770
Така че можем да прочетем в
отделни думи като линии.

556
00:27:35,770 --> 00:27:38,240
Ние отсечем последният
нещо, така че дебелото черво минус 1

557
00:27:38,240 --> 00:27:41,651
chomps разстояние последното нещо, което we--
последния знак от низ.

558
00:27:41,651 --> 00:27:42,150
Ние ще кажем.

559
00:27:42,150 --> 00:27:44,730
Добре, всеки един от тези получава
вмъква в този речник,

560
00:27:44,730 --> 00:27:45,810
картографиране на стойност 1.

561
00:27:45,810 --> 00:27:48,006
Ние не особено
грижа за това един,

562
00:27:48,006 --> 00:27:51,130
но това е само там, за да се каже, О, добре,
това нещо Ще сложа в речника.

563
00:27:51,130 --> 00:27:53,182
Защото по-късно това, което сме
ще направя, е, че сме

564
00:27:53,182 --> 00:27:55,390
ще кажа, добре, ако това е
в речника на всички.

565
00:27:55,390 --> 00:27:57,650
>> Отново, това чек за
членството е до операционната

566
00:27:57,650 --> 00:28:00,940
използвайки напълно различен
алгоритъм, отколкото ще в списък,

567
00:28:00,940 --> 00:28:05,709
но ние го наричаме по същия начин, който
е, че някои от Python захарно покритие

568
00:28:05,709 --> 00:28:07,250
неща, така че те са по-лесни за използване.

569
00:28:07,250 --> 00:28:10,230
И пак сме виждали
неща като това преди.

570
00:28:10,230 --> 00:28:12,940
Това е в общи линии се намери, или
това е точно същия синтаксис

571
00:28:12,940 --> 00:28:16,480
като се намери, но работи в продължение на
напълно различна структура.

572
00:28:16,480 --> 00:28:20,170
И ние не ме интересува особено.

573
00:28:20,170 --> 00:28:25,540
Така че тези, които са нещата, които ви
са били помолени да приведе в действие за правопис.

574
00:28:25,540 --> 00:28:29,278
С това темпо, ние ще получим
повече или по-малко всички psets направили.

575
00:28:29,278 --> 00:28:31,474
>> АУДИТОРИЯ: Така че
основно просто се връща

576
00:28:31,474 --> 00:28:34,852
като неправилно изписано ако това не стане
съвпада нещо в речника?

577
00:28:34,852 --> 00:28:36,060
ROSS RHEINGANS-YOO: Да, да.

578
00:28:36,060 --> 00:28:38,964

579
00:28:38,964 --> 00:28:40,880
И така, това е
Адаптиране на определен проблем

580
00:28:40,880 --> 00:28:43,150
който иска от вас да направите точно това.

581
00:28:43,150 --> 00:28:46,357
>> АУДИТОРИЯ: Защо е линията минус 1 до там?

582
00:28:46,357 --> 00:28:48,190
ROSS RHEINGANS-YOO: Значи
когато сте итерации

583
00:28:48,190 --> 00:28:50,300
над даден файл с молба за
по линии, линиите

584
00:28:50,300 --> 00:28:53,900
идват с нова линия характер
в края на it-- на минус 1

585
00:28:53,900 --> 00:28:55,260
е просто да пазаруват тези, на разстояние.

586
00:28:55,260 --> 00:28:59,549
А това е особено гъвкава
начин на индексиране в неща.

587
00:28:59,549 --> 00:29:01,590
Така че, ако имате низ,
и искате, добре съм

588
00:29:01,590 --> 00:29:05,340
ще започне в герой три
и аз ще отида до края.

589
00:29:05,340 --> 00:29:07,140
3 дебелото черво ще направи това за вас.

590
00:29:07,140 --> 00:29:10,570
Ако сте като, искам да започна в
започващ и да преминете към последната минус 1

591
00:29:10,570 --> 00:29:12,400
характер, на дебелото черво минус 1.

592
00:29:12,400 --> 00:29:14,940
И ако искате да отидете от
третият в отрицателна посока на първо място,

593
00:29:14,940 --> 00:29:16,570
тогава бих казал, че 3 минус 1.

594
00:29:16,570 --> 00:29:19,464

595
00:29:19,464 --> 00:29:22,400
>> Освен това, ако искате да се индексират
в неща, считано от гърба,

596
00:29:22,400 --> 00:29:24,470
просто индекс с минус номера.

597
00:29:24,470 --> 00:29:26,980
И тъй, когато C
щеше да експлодира или може би

598
00:29:26,980 --> 00:29:31,090
те храня друга памет, която не е имала
достъп до чуете може да се каже минус 1

599
00:29:31,090 --> 00:29:34,104
означава последно 1
знак в низ.

600
00:29:34,104 --> 00:29:36,950

601
00:29:36,950 --> 00:29:43,590
>> Модулите са version-- са
аналози на библиотеки в C

602
00:29:43,590 --> 00:29:45,119
и са полезни за много неща.

603
00:29:45,119 --> 00:29:46,910
Много от нещата, които ще
обичам да правя в Python,

604
00:29:46,910 --> 00:29:50,040
освен проста
манипулиране на променливите,

605
00:29:50,040 --> 00:29:52,290
искате да вмъкнете в
по-големи библиотеки с по-голяма

606
00:29:52,290 --> 00:29:55,910
интерфейси и повече
възможности за взаимодействие

607
00:29:55,910 --> 00:29:57,195
с други части на света.

608
00:29:57,195 --> 00:29:58,910
Сис е един от тези,
с куп инструменти

609
00:29:58,910 --> 00:30:01,159
които са полезни за взаимодействие
със самата система

610
00:30:01,159 --> 00:30:05,050
и ще го внесе като внос сис.

611
00:30:05,050 --> 00:30:07,820
>> Има и още документация от
че, които можете да отидете тук,

612
00:30:07,820 --> 00:30:11,490
или бихте могли да намерите в Google
от Googling Python сис.

613
00:30:11,490 --> 00:30:12,640
Можете да въведете влиза.

614
00:30:12,640 --> 00:30:15,140
Първият линк ще бъде
документацията в Python 2,

615
00:30:15,140 --> 00:30:19,260
втората връзка ще
е Python документация 3.

616
00:30:19,260 --> 00:30:24,830
>> И ако ние написа файл, който изглеждаше
като this-- Ако по-специално, ние сме

617
00:30:24,830 --> 00:30:27,910
гледаш, работещи на
командния ред аргументи,

618
00:30:27,910 --> 00:30:30,040
като сме се научили да се справят много
в началото на този клас.

619
00:30:30,040 --> 00:30:32,190
Това не е трудно.
Можете да се измъкнем argv,

620
00:30:32,190 --> 00:30:34,565
което е едно от онези неща
който се реализира от сис.

621
00:30:34,565 --> 00:30:37,210
Това не е вграден към
база на пакетите, но отново,

622
00:30:37,210 --> 00:30:40,080
може да го удължи, като се внасят
тази функционалност от сис.

623
00:30:40,080 --> 00:30:41,090
Ще го наречем сис.

624
00:30:41,090 --> 00:30:42,611
както и да е.

625
00:30:42,611 --> 00:30:43,360
Тук има argv.

626
00:30:43,360 --> 00:30:45,193
Има действително не
argc в сис, защото

627
00:30:45,193 --> 00:30:47,880
може да го получи толкова лесно, като се обадите дъл.

628
00:30:47,880 --> 00:30:55,390
Ние след това отпечатва, че навън, тогава ние
изтича на нашия терминал echo-args.py.

629
00:30:55,390 --> 00:30:58,360
Ние се върне масив, който
е този първи аргумент.

630
00:30:58,360 --> 00:31:02,240
Отново, това е argv 0, което е най-
име на нещо, което беше колнат.

631
00:31:02,240 --> 00:31:04,870
Ако ние го нарича с допълнителен
доводи, щяхме да получат тези обратно.

632
00:31:04,870 --> 00:31:07,687

633
00:31:07,687 --> 00:31:09,770
Това е един от начините за получаване на
командния ред аргументи.

634
00:31:09,770 --> 00:31:13,440
Ако искате знамена където се обръщат
конкретните неща, върху или пренебрегване

635
00:31:13,440 --> 00:31:16,050
конкретен подразбиране
argparse е твой приятел.

636
00:31:16,050 --> 00:31:21,550
И пак ще откриете, че онлайн
най питон argparse в Google.

637
00:31:21,550 --> 00:31:24,300
>> Има няколко на полезност
модули, които ще намериш себе си, използвайки

638
00:31:24,300 --> 00:31:27,630
и отново, ако прекарвате всяко време
на този език вносител jsons

639
00:31:27,630 --> 00:31:33,300
за четене и излизат от JSON
файлове, а не толкова сложно.

640
00:31:33,300 --> 00:31:37,139
Вие се отвори файл, можете нарича json.load
на този файл, и ще получите обратно нещо.

641
00:31:37,139 --> 00:31:37,930
Какво е това нещо?

642
00:31:37,930 --> 00:31:40,329
Това е JSON обект.

643
00:31:40,329 --> 00:31:42,370
Когато това JSON има масив,
питона е масиви.

644
00:31:42,370 --> 00:31:44,420
Когато това е JSON
асоциативни масиви, Пайтън

645
00:31:44,420 --> 00:31:48,810
речници, струни,
и цифри, и така нататък.

646
00:31:48,810 --> 00:31:53,560
Искаш ли да се отърват, че, вие
отвори нов файл, ти се обадя сметището,

647
00:31:53,560 --> 00:31:57,590
и товари и сметища за
да влиза и излиза от низове.

648
00:31:57,590 --> 00:32:02,120
>> По същия начин, туршия получава нарича
в общи линии един и същ интерфейс.

649
00:32:02,120 --> 00:32:04,740
Това е малко по-полезно, ако
можете да започнете дъмпинга Python обекти.

650
00:32:04,740 --> 00:32:08,370
Така че, ако някога сте искали да запазите
версия на текущото състояние

651
00:32:08,370 --> 00:32:11,930
на променливата за бъдеща
тичам на вашата програма,

652
00:32:11,930 --> 00:32:14,740
туршия е Пайтън
библиотека за да направим това.

653
00:32:14,740 --> 00:32:19,140
>> Ако имате каквато и да е
променлива, която може да бъде изписано

654
00:32:19,140 --> 00:32:21,990
в подобни думи и символи и
bytes-- като този речник,

655
00:32:21,990 --> 00:32:24,230
бихме могли да напише, ние
може да го запише като

656
00:32:24,230 --> 00:32:26,670
като JSON обект, който е
буквално тези герои.

657
00:32:26,670 --> 00:32:29,420
И след това ще бъде много лесно за
човек да го отворите up-- отворят

658
00:32:29,420 --> 00:32:30,889
и го прочетете.

659
00:32:30,889 --> 00:32:33,180
Ако не сме особено
грижа за хората да го четат,

660
00:32:33,180 --> 00:32:38,490
бихме могли да опаковате още по-ефективно
във форми, които биха могли да бъдат по-късно на неопаковани

661
00:32:38,490 --> 00:32:42,860
или които биха могли по-късно да се надува.

662
00:32:42,860 --> 00:32:46,740
И това спестява 80% от
пространство, което ви предмети мощ

663
00:32:46,740 --> 00:32:49,390
предприеме, ако ги написа longhand.

664
00:32:49,390 --> 00:32:52,384
>> Наричаш туршия много
по същия way-- сметището, натоварване,

665
00:32:52,384 --> 00:32:53,800
и след това можете да си нещата обратно.

666
00:32:53,800 --> 00:32:56,880
Така че, ако се пише много
кратки програми на Питон, че

667
00:32:56,880 --> 00:32:59,952
искате да запишете състояние, а след това се чете
ги върне по-късно, подобни неща

668
00:32:59,952 --> 00:33:00,660
са вашите приятели.

669
00:33:00,660 --> 00:33:02,640
Че бихте могли много
лесно да ги зареже като JSON.

670
00:33:02,640 --> 00:33:04,550
Повечето Python обекти
може да изхвърля на JSON

671
00:33:04,550 --> 00:33:11,310
ако има някаква надежда, че в структурно
те могат да бъдат представени по този начин.

672
00:33:11,310 --> 00:33:14,410
>> Това са само върхът на
айсберг на модули, които са полезни.

673
00:33:14,410 --> 00:33:19,510
Така че сис, OS, многопроцесорна, са
нещо като основни работни коне за неща

674
00:33:19,510 --> 00:33:23,120
ние трябва да си взаимодействат с
ОС на файловата система.,

675
00:33:23,120 --> 00:33:28,764
като os.isfile, os.isdirectory,
os.makefile, това са моите приятели.

676
00:33:28,764 --> 00:33:30,930
Ако искате да си взаимодействат
с определен тип файл,

677
00:33:30,930 --> 00:33:32,190
JSON, туршия, CSV.

678
00:33:32,190 --> 00:33:37,160
Ако искате да си взаимодействат с уеб
страници, на urllib за получаване на HTTP

679
00:33:37,160 --> 00:33:41,370
страници. bs4-- BeautifulSoup--
това е чудесен анализатор за HTML.

680
00:33:41,370 --> 00:33:47,047
Можете да го ползвате на HTML и вие
получи това вложените масив обект сега,

681
00:33:47,047 --> 00:33:49,630
които можете да се пресичат
Lookin, с харесват просто търсите

682
00:33:49,630 --> 00:33:52,380
ако, е, в, което е фантастично.

683
00:33:52,380 --> 00:33:55,920
>> Има един куп
пакети за running--

684
00:33:55,920 --> 00:33:57,960
за това особено mathy неща.

685
00:33:57,960 --> 00:34:01,790
Така че, ако искате да се размножават,
обърнете, трансформиране матрици,

686
00:34:01,790 --> 00:34:05,690
numpy се използва от хора, всички
цял свят за това.

687
00:34:05,690 --> 00:34:09,620
scipy е още по-полезен
инструменти в тази посока.

688
00:34:09,620 --> 00:34:13,980
sklearn-- обучение машина,
обработка на естествен език,

689
00:34:13,980 --> 00:34:17,880
супер полезни неща, получава
изпълнява в Python през цялото време.

690
00:34:17,880 --> 00:34:21,469
>> И пак, отнема малко по-
вече да write-- съжалявам,

691
00:34:21,469 --> 00:34:26,199
отнема малко по-дълго, за да тичам, но
причината, че истинските инженери са склонни

692
00:34:26,199 --> 00:34:29,900
използване Python е така, защото сте склонни да бъдат
блокиран от вас писане на код, а

693
00:34:29,900 --> 00:34:32,699
от вашия компютър, работещ с кода.

694
00:34:32,699 --> 00:34:35,860
Така че, ако ти започваш да се напише
Програмата, която много други хора

695
00:34:35,860 --> 00:34:37,699
ще използваме
завинаги, като Linux, вие

696
00:34:37,699 --> 00:34:41,900
може да го напиша на C. Ако бяхте
ще напише изчисляване на двигателя,

697
00:34:41,900 --> 00:34:46,124
можете да пишете в Python, ако е необходимо
за да го промените на всеки няколко месеца.

698
00:34:46,124 --> 00:34:48,540
Някои хора биха го пишат в
C, защото те са по този начин.

699
00:34:48,540 --> 00:34:51,100

700
00:34:51,100 --> 00:34:54,050
>> Така че сме виждали внос сис
като начин за получаване на нещата

701
00:34:54,050 --> 00:34:57,070
за получаване на модул в програмата си.

702
00:34:57,070 --> 00:35:00,370
Можете също така да го импортирате като
псевдоним, ако искате.

703
00:35:00,370 --> 00:35:03,660
Отново многопроцесорна е болка за
напишете всеки път, така че внасят като т.т.

704
00:35:03,660 --> 00:35:05,900
и след това по всяко време
я използват в програмата,

705
00:35:05,900 --> 00:35:09,732
ще кажа mp.process, или това, което имате.

706
00:35:09,732 --> 00:35:12,670
Ако искате внос
само едно нещо,

707
00:35:12,670 --> 00:35:19,450
така urllib има нещо, наречено
поискване, така че може просто да импортирате това.

708
00:35:19,450 --> 00:35:22,610
По-късно, няма да му се позовават като
urllib.request, но само като искане

709
00:35:22,610 --> 00:35:24,590
от само себе си.

710
00:35:24,590 --> 00:35:30,110
>> И вие можете да импортирате всичко
от един модул, ако искате.

711
00:35:30,110 --> 00:35:34,820
Това понякога не е добър idea--
това обикновено не е добра идея, всъщност.

712
00:35:34,820 --> 00:35:39,080
Защото ти very-- защото ако нещо
в този модул има име, което

713
00:35:39,080 --> 00:35:41,640
Исках да използвам някъде другаде
в програмата си, не можеш.

714
00:35:41,640 --> 00:35:44,127
>> И това не винаги е очевидно,
че това е така.

715
00:35:44,127 --> 00:35:46,460
За да се уверите, че
това, което правиш е в безопасност,

716
00:35:46,460 --> 00:35:47,920
което трябва да се отворят
модула и виж всички

717
00:35:47,920 --> 00:35:50,295
за имената, които се озовават в
there-- всички функции,

718
00:35:50,295 --> 00:35:53,010
Всички променливи
които живеят в този модул,

719
00:35:53,010 --> 00:35:57,040
защото вие ще вкарат всички
ги във вашия местен пространство от имена.

720
00:35:57,040 --> 00:35:58,680
>> Така че хората правят това.

721
00:35:58,680 --> 00:36:01,322
Обикновено се препоръчва
че вие ​​не направите това.

722
00:36:01,322 --> 00:36:03,280
Но хората правят това всички
времето, защото те са

723
00:36:03,280 --> 00:36:05,180
мързелив и не искате да напишете тр.

724
00:36:05,180 --> 00:36:06,310
нищо, никога.

725
00:36:06,310 --> 00:36:09,560

726
00:36:09,560 --> 00:36:13,310
>> Всичко това говори за модули
ми донесе около до кратък разговор

727
00:36:13,310 --> 00:36:15,930
за това как можете да изготвят програми в Python.

728
00:36:15,930 --> 00:36:19,860
Първата стъпка е да се провери дали
някой друг вече е направил това нещо,

729
00:36:19,860 --> 00:36:22,160
или прави 90% от нещо.

730
00:36:22,160 --> 00:36:26,010
Шансовете са те вероятно имат, и вие
трябва да отида да им нещо и тичам, че.

731
00:36:26,010 --> 00:36:28,900
Или напиши обвивка около него
да се адаптира към вашата цел.

732
00:36:28,900 --> 00:36:31,250
Това е едва след това има
провали, които бихте тогава

733
00:36:31,250 --> 00:36:35,529
отида и write-- започне да мисли за
как бихте сложи това нещо заедно.

734
00:36:35,529 --> 00:36:37,320
Има много неща,
там, и това е

735
00:36:37,320 --> 00:36:39,180
един от най-полезните
неща за Python.

736
00:36:39,180 --> 00:36:40,930
Подобно на езика е
елегантен, езика

737
00:36:40,930 --> 00:36:43,800
е лесен за използване, но и защото
това е толкова елегантен и лесен за използване,

738
00:36:43,800 --> 00:36:47,420
хората са го използват за
дълго време и има много неща,

739
00:36:47,420 --> 00:36:52,520
там, че можете да
впрегнат за собствена употреба.

740
00:36:52,520 --> 00:36:58,457
>> Така последното правило на Python е, някой
друг е вече вероятно написан

741
00:36:58,457 --> 00:37:00,290
модул за това,
някой друг има вече

742
00:37:00,290 --> 00:37:02,980
Вероятно писмено библиотека за това.

743
00:37:02,980 --> 00:37:06,579
Преди да се опитаме да направим нещо, да потърсите
за да видите дали това е била предприета.

744
00:37:06,579 --> 00:37:07,370
Това не е толкова трудно.

745
00:37:07,370 --> 00:37:11,960
Всичко от модулите, че аз пригодени
преди, може би с изключение на един,

746
00:37:11,960 --> 00:37:15,220
идват с предварително инсталиран във всяка
стандартна инсталация Python.

747
00:37:15,220 --> 00:37:17,769
И така, с обаждане до
внасят каквото можете

748
00:37:17,769 --> 00:37:19,852
всички от тази функционалност
на пръстите си.

749
00:37:19,852 --> 00:37:24,660

750
00:37:24,660 --> 00:37:28,920
>> Започвайки да приключи до
Забавление, има няколко неща,

751
00:37:28,920 --> 00:37:32,770
че съм оставил като черни кутии
и някак Споменахме,

752
00:37:32,770 --> 00:37:37,217
а има и няколко бели крие, че съм
каза, че в името на честността,

753
00:37:37,217 --> 00:37:39,050
Аз ще поне точка
тук, дори и ако няма да го направя

754
00:37:39,050 --> 00:37:43,980
отидете супер дълбоко в всички от тях
и техните технически обяснения.

755
00:37:43,980 --> 00:37:46,010
>> Много от нещата,
че съм нарича магия

756
00:37:46,010 --> 00:37:48,980
е това, което другите хора биха нарекли
обектно-ориентирано програмиране.

757
00:37:48,980 --> 00:37:52,470
Така че има много things--
така променливи не са много често

758
00:37:52,470 --> 00:37:56,540
прости байта седят,
памет, но са доста сложни

759
00:37:56,540 --> 00:38:01,910
обекти, които имат вътрешна
състояние за функции и много

760
00:38:01,910 --> 00:38:05,570
на скрити променливи, много
скрит функционалност, която

761
00:38:05,570 --> 00:38:09,480
ви позволява да ги превърне в низове,
която ви позволява да превъртите над тях.

762
00:38:09,480 --> 00:38:12,260
И ако сте writing--
и причината, че те

763
00:38:12,260 --> 00:38:15,710
имаме всичко това богата функционалност
е така, защото people--

764
00:38:15,710 --> 00:38:17,740
архитектите на
language-- са отишли

765
00:38:17,740 --> 00:38:22,420
чрез и за всеки стандарт
обект, пробва функционалността

766
00:38:22,420 --> 00:38:26,970
да кажа, че това е начина, това е
как това ще се оперира

767
00:38:26,970 --> 00:38:28,470
ако някой иска да превъртите над него.

768
00:38:28,470 --> 00:38:31,240
>> Така че всичко, което някой може
вероятно искате да обхождане,

769
00:38:31,240 --> 00:38:34,529
е логиката, написани на
ръчно от това как сте

770
00:38:34,529 --> 00:38:36,070
трябвало да обхождане този обект.

771
00:38:36,070 --> 00:38:40,274
Всичко, което бихте могли да искате
изхвърлени в низ е логиката писмено.

772
00:38:40,274 --> 00:38:43,440
Това е функцията, която ти се обадя, ако
искате да зареже тази изложени в низ.

773
00:38:43,440 --> 00:38:45,273
Ето защо можете да
обадете дъл на нещата, това

774
00:38:45,273 --> 00:38:49,900
Ето защо можете да се обадите в, това е
Затова можете да се обадите, ако в по всичко

775
00:38:49,900 --> 00:38:53,490
че вие ​​ще искате да, защото
тези, които всички са носейки със себе си,

776
00:38:53,490 --> 00:38:55,380
техническото ноу-хау, за да направим това.

777
00:38:55,380 --> 00:38:58,170

778
00:38:58,170 --> 00:39:00,432
>> Това е нещо, което аз съм
супер няма да отидат в.

779
00:39:00,432 --> 00:39:03,140
Но за нещо, в списъка е едва доловимо
различен от C стил за линии,

780
00:39:03,140 --> 00:39:06,160
и можете да прочетете всичко за това по
интернет, ако проявявате интерес.

781
00:39:06,160 --> 00:39:08,930
Има една тъмна страна на всички,
на този, който споменах,

782
00:39:08,930 --> 00:39:10,359
така че има две неща.

783
00:39:10,359 --> 00:39:13,400
Първата е, че този обект ориентирани
програмиране добавя много режийни

784
00:39:13,400 --> 00:39:16,080
до случайни неща, така че в крайна
като се използват много повече памет;

785
00:39:16,080 --> 00:39:18,640
ти свърши с помощта на малко повече
време, отколкото бихте друго.

786
00:39:18,640 --> 00:39:21,300
The other-- но колкото повече
коварна тъмна страна на този

787
00:39:21,300 --> 00:39:24,047
е, ако нещата просто действат
като ги искате да

788
00:39:24,047 --> 00:39:27,130
без да ви се налага да мислите супер трудно
за това дали това трябва да бъде едно цяло число

789
00:39:27,130 --> 00:39:29,713
или дали трябва да има по-
плувка, може би е, че тук

790
00:39:29,713 --> 00:39:34,240
произвеждате пад, но тук ви
мисля, но те ще always-- съжалявам,

791
00:39:34,240 --> 00:39:36,555
тя може да бъде, че тук
произвеждате поплавък,

792
00:39:36,555 --> 00:39:39,430
но когато стигнем до втората част
на вашата програма, си мислиш,

793
00:39:39,430 --> 00:39:41,150
О, добре, но те ще
винаги ми се явят на инт.

794
00:39:41,150 --> 00:39:43,608
И ако това не е така, това е възможно
че сте заседнали някъде,

795
00:39:43,608 --> 00:39:47,600
ако се опитате да използвате, че да индексира
в масив, или това, което имате.

796
00:39:47,600 --> 00:39:51,050
>> Така че една от реалното
полезни неща за C е

797
00:39:51,050 --> 00:39:54,219
той ви принуждава да мислим наистина
трудно, преди да направите any--

798
00:39:54,219 --> 00:39:56,510
преди да предявява каквито и променлива
в съществуване, като това, което

799
00:39:56,510 --> 00:39:58,764
е от типа на тази променлива.

800
00:39:58,764 --> 00:40:00,680
И то се случва да има
този вид за всички времена.

801
00:40:00,680 --> 00:40:02,410
>> Това не е вярно
Python, а в действителност, вие

802
00:40:02,410 --> 00:40:04,740
can-- ако сте просто
нещо става с ухо,

803
00:40:04,740 --> 00:40:07,690
и можете да направите някои решения
един начин на едно място,

804
00:40:07,690 --> 00:40:09,870
и някои решения един
начин на друго място

805
00:40:09,870 --> 00:40:12,960
без да се излагат достатъчно неща зад
кулисите в друго място

806
00:40:12,960 --> 00:40:16,170
за улов на нещата правилно,
може да получите някои много странни грешки.

807
00:40:16,170 --> 00:40:19,200
И програмата може да продължи да работи
за много дълго време, защото това е

808
00:40:19,200 --> 00:40:23,200
вършеше много работа, за да се каже, добре
това нещо може да работи по този начин,

809
00:40:23,200 --> 00:40:25,070
така че аз отивам да тичам по този начин.

810
00:40:25,070 --> 00:40:30,300
>> И в действителност, че го избутва
предаде през много малки грешки

811
00:40:30,300 --> 00:40:33,260
означава, че когато често
грешка е всъщност лош

812
00:40:33,260 --> 00:40:38,720
а вие всъщност не искам да го оправя,
тя завършва мили away-- програмата

813
00:40:38,720 --> 00:40:41,780
озовава спиране мили
от времето, когато сте имали си грешка.

814
00:40:41,780 --> 00:40:46,590
И така, едно нещо, което бихме искали
програми за вършене, sometimes-- едно нещо

815
00:40:46,590 --> 00:40:48,910
че ние бихме искали програми
да се направи, когато сме отстраняване на грешки

816
00:40:48,910 --> 00:40:54,160
е провали шумно и не успяват много
бързо, когато нещо се обърка.

817
00:40:54,160 --> 00:40:55,510
>> Python е много лошо в това.

818
00:40:55,510 --> 00:40:58,820
Python е много добър в не
при липса и подвижен напред

819
00:40:58,820 --> 00:41:00,320
чрез неочаквани неща.

820
00:41:00,320 --> 00:41:02,820
Така че това е полезно, когато
пишете малки програми.

821
00:41:02,820 --> 00:41:07,110
Когато получите сложно
бъгове понякога

822
00:41:07,110 --> 00:41:09,300
отнема много време, за да ги дразни навън.

823
00:41:09,300 --> 00:41:12,210
>> Така че има и тъмна страна за всички
това, като просто работи.

824
00:41:12,210 --> 00:41:13,860
Той просто работи, както бихте очаквали да.

825
00:41:13,860 --> 00:41:18,320
Само че, когато това не е така, че в крайна
нагоре в напълно различно място

826
00:41:18,320 --> 00:41:21,530
и се опитвам да разбера къде
това е, че сте се обърка.

827
00:41:21,530 --> 00:41:25,180
>> Събирането на боклука is-- така
едно нещо, което ще забележите

828
00:41:25,180 --> 00:41:28,110
е, че всеки от следните неща
Аз бях приведени в existence--

829
00:41:28,110 --> 00:41:34,114
тези масиви, тези речници, тези
предмети, те никога няма да се остави files--.

830
00:41:34,114 --> 00:41:36,030
Не е имало обаждане до
безплатно в някоя от тези приказки.

831
00:41:36,030 --> 00:41:40,340
И това е на C-напред, защото
ние никога не влезе в тези неща.

832
00:41:40,340 --> 00:41:42,220
>> Но в Python страна, там не е безплатна.

833
00:41:42,220 --> 00:41:43,970
Нещата стават автоматично
се освобождава, когато Python

834
00:41:43,970 --> 00:41:45,386
мисли, че не сте ги гледаше.

835
00:41:45,386 --> 00:41:49,640
Това е наистина добри неща, които не освобождава
може би все още е възможно да се търсят в,

836
00:41:49,640 --> 00:41:54,262
но това означава, че ако сте били
ще разпредели тази голяма работа,

837
00:41:54,262 --> 00:41:55,970
и вие сте като, о
Аз съм направи с него сега,

838
00:41:55,970 --> 00:42:00,360
това е трудно да се каже Python
че сте готови с това сега.

839
00:42:00,360 --> 00:42:02,986
>> Понякога можете да зададете
тази променлива да бъде никой,

840
00:42:02,986 --> 00:42:05,110
и след това се надявам, че в крайна сметка
боклучарят

841
00:42:05,110 --> 00:42:06,720
идва и да го почиства.

842
00:42:06,720 --> 00:42:10,177
Но отново, не го направите
имат контрол над това.

843
00:42:10,177 --> 00:42:13,510
И една от причините, които хората използват C
за наистина производителност критични неща,

844
00:42:13,510 --> 00:42:16,570
е тази способност да вижда
знаете, когато паметта е разпределена

845
00:42:16,570 --> 00:42:19,369
и, когато е освободен, и имат
много контрол над казвайки:

846
00:42:19,369 --> 00:42:20,910
Аз съм с не повече памет, отколкото ми трябва.

847
00:42:20,910 --> 00:42:23,632
Което е нещо, което
Python не е толкова чудесно.

848
00:42:23,632 --> 00:42:25,090
АУДИТОРИЯ: Мога ли да ви попитам нещо?

849
00:42:25,090 --> 00:42:29,800
Какво искаш да кажеш с провали шумно?

850
00:42:29,800 --> 00:42:32,070
>> ROSS RHEINGANS-YOO: Така че, ако
става нещо нередно

851
00:42:32,070 --> 00:42:34,950
и вие сте в отстраняване на грешки
режим, бихте направили много често

852
00:42:34,950 --> 00:42:38,510
Искам си програма, за да ви кажа,
къде точно това е объркало,

853
00:42:38,510 --> 00:42:42,360
а не просто тихо спира да тече.

854
00:42:42,360 --> 00:42:45,085
Но ще всъщност това да отпечатате
от всички видове информация за

855
00:42:45,085 --> 00:42:46,972
харесват, тук е това.

856
00:42:46,972 --> 00:42:53,957
Това нещо се случи Ако сте отпечатване
а wen-- ако показвате уеб server--

857
00:42:53,957 --> 00:42:55,390
>> АУДИТОРИЯ: [недоловим]

858
00:42:55,390 --> 00:42:59,800
>> ROSS RHEINGANS-YOO: Да, ако
сте с уеб сървър,

859
00:42:59,800 --> 00:43:02,680
понякога е лошо, ако сте
винаги изхвърляне на грешки,

860
00:43:02,680 --> 00:43:04,530
а вие казвате,
добре, че не е работа.

861
00:43:04,530 --> 00:43:05,300
Отивам да се спре.

862
00:43:05,300 --> 00:43:07,680
Аз съм просто ще игнорира
то и да става.

863
00:43:07,680 --> 00:43:11,260
Защото тогава можете да получите в стотици
от тези грешки и да не ги види.

864
00:43:11,260 --> 00:43:13,910
>> Това със сигурност ще бъде полезно
за целите на отстраняване на грешки

865
00:43:13,910 --> 00:43:20,327
ако всеки път, когато вашия уеб сървър направи
грешка, трябваше трайни записи на това.

866
00:43:20,327 --> 00:43:22,910
Може би дори искате програмата
да спре, така че тези записи

867
00:43:22,910 --> 00:43:25,471
Да не се получи погребан под неща.

868
00:43:25,471 --> 00:43:26,970
Но отново, това е в режим на дебъгване.

869
00:43:26,970 --> 00:43:31,280
>> Често в режим на производство,
свят е малко по-различна.

870
00:43:31,280 --> 00:43:36,380
И в малки скриптове, които Бягам,
когато нещо, което аз казах да се направи

871
00:43:36,380 --> 00:43:40,680
може да бъде само малко разстояние
от това, което бих искал да направя,

872
00:43:40,680 --> 00:43:44,010
След това нещо прокарване
грешки е нещо, което може да искате.

873
00:43:44,010 --> 00:43:49,410
И в тези случаи, със сигурност
Python наистина печели своите започва.

874
00:43:49,410 --> 00:43:54,617
>> Последното нещо, което аз не говоря
в this--, че аз не говоря за

875
00:43:54,617 --> 00:43:57,700
но може да бъде наистина вбесяващ първият
път имате един от тези грешки,

876
00:43:57,700 --> 00:44:00,491
и втората и третата и четвъртата
път имате едно на тези грешки.

877
00:44:00,491 --> 00:44:03,490
Python, споменах
че той използва бяло пространство

878
00:44:03,490 --> 00:44:06,700
да ви кажа какво е нивото на отстъп
и какво функционален блок сте в,

879
00:44:06,700 --> 00:44:08,840
тя се отнася раздели и пространства по различен начин.

880
00:44:08,840 --> 00:44:12,780
Така че, ако в продължение на четири раздела, а след това
следващия ред се състои от четири помещения,

881
00:44:12,780 --> 00:44:16,910
дори ако те се показват като
същата сума във вашия редактор,

882
00:44:16,910 --> 00:44:20,160
Python не ги третират по един и същ.

883
00:44:20,160 --> 00:44:23,610
>> В действителност, Python третира раздели
и пространства като масло и вода.

884
00:44:23,610 --> 00:44:25,050
Те са просто различни неща.

885
00:44:25,050 --> 00:44:27,264
Няма специално
дължина, че раздела е,

886
00:44:27,264 --> 00:44:30,180
така че не е като таб равнява 8
пространства, и така вие ще получите около него

887
00:44:30,180 --> 00:44:30,860
по този начин.

888
00:44:30,860 --> 00:44:34,110
Подобно, когато се казва, това, което
ниво на бяло пространство аз съм най-,

889
00:44:34,110 --> 00:44:37,240
тя действително да търси
модел на интервали и табулатори.

890
00:44:37,240 --> 00:44:43,050
И така, най-добрият начин да се справят с този
е да се използва винаги пространства през цялото време.

891
00:44:43,050 --> 00:44:47,510
>> И в действителност, в Cloud9
IDE и CS50 IDE,

892
00:44:47,510 --> 00:44:50,610
Вашите ключови Tab вложки
четири помещения, в вместо

893
00:44:50,610 --> 00:44:53,800
на раздела, който е супер полезно.

894
00:44:53,800 --> 00:44:57,074
Въпреки, че отново, ако е написал Python
програма с табове, че ще се оправи,

895
00:44:57,074 --> 00:44:58,990
това е просто, ако някой
влезе и се опита да добавите

896
00:44:58,990 --> 00:45:02,655
един ред, за да си програма, която
имаше четири пространства за всеки раздел,

897
00:45:02,655 --> 00:45:03,280
може да се счупи.

898
00:45:03,280 --> 00:45:07,800
И може да се счупи по начин,
че наистина не се вижда.

899
00:45:07,800 --> 00:45:12,390
Въпреки, че действителната грешка
съобщение, че тя хвърля

900
00:45:12,390 --> 00:45:15,610
има нещо общо с новата
тире, не се очаква тук,

901
00:45:15,610 --> 00:45:18,700
or-- ако тя говори за тире
и изглежда, че не е наред,

902
00:45:18,700 --> 00:45:22,090
това е може би, защото
има проблем с таб-пространството.

903
00:45:22,090 --> 00:45:24,154
Те все още вбесяващ да дебъгване.

904
00:45:24,154 --> 00:45:26,070
Най-големият в цяла
този разговор, който не го направих

905
00:45:26,070 --> 00:45:29,740
стигнем до, защото това е наистина
сложен, изтънчен тема,

906
00:45:29,740 --> 00:45:34,760
и не е необходимо да се направи всеки
от нещата, които съм правил досега,

907
00:45:34,760 --> 00:45:37,140
са концепция, наречена кортежи.

908
00:45:37,140 --> 00:45:41,280
Те са там, който много прилича на
масиви, че не могат да променят.

909
00:45:41,280 --> 00:45:44,700
Те свикне по цялото място, защото
те са полезни за много неща

910
00:45:44,700 --> 00:45:46,300
че масиви не са полезни за.

911
00:45:46,300 --> 00:45:49,890
>> Но ако искате да направите масив, и
след това обещавам интерпретатора, че сте

912
00:45:49,890 --> 00:45:53,140
никога няма да искате да промените, че
thing-- в действителност, ако искате да се промени,

913
00:45:53,140 --> 00:45:56,800
вие ще направите нова, с новото
стойности в it-- това са кортежи.

914
00:45:56,800 --> 00:45:58,800
Вместо да се произвежда
тях с квадратни скоби,

915
00:45:58,800 --> 00:46:00,341
можете да ги произвеждат с кръгли скоби.

916
00:46:00,341 --> 00:46:05,074
Защо трябва да използвате тези неща,
е малко на един въпрос. ,

917
00:46:05,074 --> 00:46:06,990
Единственото нещо, което аз ще
казват за вас, че е

918
00:46:06,990 --> 00:46:10,680
може да се използва като кортежи
индексите за речници.

919
00:46:10,680 --> 00:46:15,010
Не можете да използвате като масиви
индексите за речници.

920
00:46:15,010 --> 00:46:18,970
И защо е, отново, техническа и
Аз няма да се сблъскате с него.

921
00:46:18,970 --> 00:46:23,140
>> The pset, че аз не съм пипал
на в този разговор е pset6.

922
00:46:23,140 --> 00:46:25,837
Така че ето как можете По-
приложат A-- ето

923
00:46:25,837 --> 00:46:28,140
как бихте приложи pset6 в Python.

924
00:46:28,140 --> 00:46:32,680
Имайки предвид Python
цикъла на проектиране, първото нещо,

925
00:46:32,680 --> 00:46:34,760
, което правите, когато сте
писане на програми е проверка

926
00:46:34,760 --> 00:46:38,030
за да видите дали някой го направи вече.

927
00:46:38,030 --> 00:46:42,152
>> В действителност, ако искате
да serve-- Apache 50

928
00:46:42,152 --> 00:46:44,110
приблизително прави това,
освен това не идва

929
00:46:44,110 --> 00:46:45,840
стандартно инсталирана на Linux машини.

930
00:46:45,840 --> 00:46:50,490
Python прави, и Python
прост HTTP сървър прави, както добре.

931
00:46:50,490 --> 00:46:54,717
Ако сте някога на Linux машина,
или Cloud9 IDE външната страна на CS50

932
00:46:54,717 --> 00:46:57,550
и искате да послужи този ток
указател към определен порт,

933
00:46:57,550 --> 00:47:04,610
питон-m SimpleHTTPServer
порт служи това.

934
00:47:04,610 --> 00:47:07,190
Можете също да импортирате
простата HTTP сървър

935
00:47:07,190 --> 00:47:11,240
и тя има много функции, ако
Искате ли да го персонализирате, или да го промените,

936
00:47:11,240 --> 00:47:15,860
или се експлоатират it-- го впрегне да
Направи свой собствен сървър услуги.

937
00:47:15,860 --> 00:47:18,032
>> Така че това е Python в орехова черупка.

938
00:47:18,032 --> 00:47:20,280
И това е CS50.

939
00:47:20,280 --> 00:47:21,980
Благодаря.

940
00:47:21,980 --> 00:47:23,468