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

2
00:00:05,426 --> 00:00:06,800
ROSS RHEINGANS-YOO：你好，我是羅斯。

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
和慢一倍來執行，可能會
在某些方面的改進℃。

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
在這個網站，應該
帶你做一個谷歌文檔。

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
>> 該CS50設備附帶
Python中，默認情況下它使用Python 2。

57
00:02:41,969 --> 00:02:44,010
您可以通過檢查這
輸入你的命令行

58
00:02:44,010 --> 00:02:51,310
蟒蛇 - 版本，這應該輸出
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
蟒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
和標準庫提供
你的一些擴展

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
和程序開始執行
在這個東西叫做INT為主。

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
但在這裡，當第一
計劃是n等於10，

90
00:04:18,459 --> 00:04:21,273
的第一件事，這個方案
需要做的是利用10這個值

91
00:04:21,273 --> 00:04:24,120
並設置成一個叫做變量n。

92
00:04:24,120 --> 00:04:27,690
>> 說起這一行的，一
其他things-- sorry--這

93
00:04:27,690 --> 00:04:31,040
意味著C程序，
你會寫他們，

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
是這個文件，我只是表現
你 - 你會運行該文件

98
00:04:44,900 --> 00:04:47,450
你會執行，
它和內容

99
00:04:47,450 --> 00:04:50,390
將通過執行
Python解釋器。

100
00:04:50,390 --> 00:04:52,470
你可以在你的IDE做到這一點。

101
00:04:52,470 --> 00:05:02,260
>> 所以，如果我有一個Hello文件，
它只是有這個內容。

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
所以在這裡，如果我輸入
打印空間“你好，世界”。

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
第一，而更現實的是，
在Python有沒有尾隨分號。

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
它可能使人們誰寫的
蟒蛇在你生活竊笑

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
>> 另一個奇怪的事情有關這款N
是它不具有連接一個類型。

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
如果以後下來我分配給該
ñ0.5，則需0.5。

135
00:06:40,060 --> 00:06:43,770
不管它是在這裡為int，
漂浮在那裡，使用該n什麼

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
鍵入使得n目前，
在這一點上，它會得到

139
00:06:52,170 --> 00:06:54,490
楔形，並拋出一個錯誤，
而那些各種各​​樣的事情。

140
00:06:54,490 --> 00:06:57,050
>> 但在這裡，巨蟒
並不真正關心什麼

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
>> 該語法不是很
不同之處是什麼呢。

151
00:07:19,564 --> 00:07:21,480
這是稍有不同
它是如何表達的。

152
00:07:21,480 --> 00:07:25,370
所以這是一個非常，所謂
Python化，寫它的方式。

153
00:07:25,370 --> 00:07:28,969
對於行中的範圍（n）的，這是
從0到n範圍內的數字，

154
00:07:28,969 --> 00:07:31,010
包容在底
和獨特的頂部。

155
00:07:31,010 --> 00:07:34,790
因此，它是從0到n-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
該打印將離開for循環。

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
啟動命令行
解釋器，看看它是否工作，

187
00:09:06,480 --> 00:09:09,827
事情繼續前進，然後再
甚至需要打開谷歌說，

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
有一個冒號在端
就像for循環，

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
此外，打印失去一個字符
關閉printf函數您傳遞一些字符串。

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
打印被烤成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
因為Python的開始
執行在頂部。

231
00:11:03,372 --> 00:11:05,080
如果我想換行
這在一個功能，我

232
00:11:05,080 --> 00:11:07,667
會做它像this--我
會說DEF函數名，

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
現在你已經把它稱為，我
想我應該執行它。

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
並制定by--和發展，
維護，是值得的這種形式。

245
00:11:41,650 --> 00:11:44,540
這是basically--是因為
Python中，您從頂部開始

246
00:11:44,540 --> 00:11:50,310
然後執行下到谷底，
我如果我只是叫馬里奧在這裡，

247
00:11:50,310 --> 00:11:54,190
那麼任何時候我包括在此文件
另一個文件，因為我想用

248
00:11:54,190 --> 00:11:58,580
馬里奧功能，其他的文件將
也有這樣的呼籲馬里奧在裡面。

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使用稍微英語

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使用ELIF，

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
您可以製造這樣的
在外面while循環的事情

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
我想右對齊它 - 墊
它與空間是這個長度。

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
所以我沒有，所以我沒有
以realloc的每一次。

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
是我想放在我的平方
對i在此範圍內的每個值。

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
1 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
你會看到這裡len個。

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
返回true，否則返回false。

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
調用len陣列相同的
調用len在字符串的方式。

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
你會得到你好！

480
00:23:42,595 --> 00:23:43,970
我的意思是，像這樣的文件有你好！

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
這是多還是少，因為f是一個
的事情，你想在f關閉。

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
哈希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
它會指出你 - 它會
添加一行，等等。

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
關閉要吃掉了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
以這樣的速度，我們將得到
或多或少都做過pset時的。

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
配備了一個新的行字符
在它 - 負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
SYS是其中之一
與一群工具

609
00:29:58,910 --> 00:30:01,159
這是對交互有用
與系統本身

610
00:30:01,159 --> 00:30:05,050
並將其導入像進口SYS。

611
00:30:05,050 --> 00:30:07,820
>> 還有來自更多文檔
是，你可以去這裡，

612
00:30:07,820 --> 00:30:11,490
或者你可以找到關於谷歌
通過谷歌搜索的Python SYS。

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
這是其中的一件事情
這是由SYS實現。

621
00:30:34,565 --> 00:30:37,210
它沒有內置到
基礎包，但同樣，你

622
00:30:37,210 --> 00:30:40,080
可以通過導入擴展它
從SYS該功能。

623
00:30:40,080 --> 00:30:41,090
你會SYS調用它。

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在sys，因為你

627
00:30:45,193 --> 00:30:47,880
可以通過調用LEN得到它那麼容易。

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在谷歌。

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有數組，
在Python有數組。

644
00:31:42,370 --> 00:31:44,420
如果這一JSON有
關聯數組，Python的

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
泡菜是Python的
庫這樣做。

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
如果需要你寫出來速記。

664
00:32:49,390 --> 00:32:52,384
>> 你叫鹹菜很
相同的方式 - 轉儲，裝載

665
00:32:52,384 --> 00:32:53,800
然後你會得到你的東西回來。

666
00:32:53,800 --> 00:32:56,880
所以，如果你正在寫很
簡短的Python程序

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
因此，SYS，操作系統，多，是
排序基本廣為使用的東西

674
00:33:19,510 --> 00:33:23,120
我們需要與之交互
文件系統OS，

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
你可以穿越過
眼含，與像只是尋找

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
>> 再次，需要稍
更長的時間來寫 - 對不起，

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
可以寫成​​的。如果你是
打算寫一個計算引擎，

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
>> 因此，我們已經看到了進口SYS
為把事情的一種方式

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
此外多是痛苦的
每次都打出來，所以導入為MP

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
這最終在名字
那裡 - 所有的功能，

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
懶惰，不想打字了MP。

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
去和寫 - 開始考慮
你將如何把這個事情做好。

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
這就是為什麼你可以
調用len的事情，這

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
但對於事情的名單是微妙
從for循環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
該other--但更
陰險黑暗的一面，以這種

787
00:39:21,300 --> 00:39:24,047
是，如果事情只是行動
就像你希望他們

788
00:39:24,047 --> 00:39:27,130
無需你覺得超級難
是否這應該是一個int

789
00:39:27,130 --> 00:39:29,713
或是否應該有一個
浮動，這也許是因為在這裡

790
00:39:29,713 --> 00:39:34,240
你生產一個int，但在這裡你
的看法，但他們會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
哦，好吧，但他們會
總是遞給我一個int。

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
這種事情發生。如果你要打印
如果你正在運行一個Web server--一個wen--

857
00:42:53,957 --> 00:42:55,390
>> 聽眾：[聽不清]

858
00:42:55,390 --> 00:42:59,800
>> ROSS RHEINGANS-YOO：是的，如果
您正在運行一個Web服務器，

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
如果每次你的Web服務器中進行的
錯誤，你有那持久的記錄。

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
>> 事實上，巨蟒把標籤
而像油和水的空間。

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
永遠不會想修改
件事 - 事實上，如果要修改，

913
00:45:53,140 --> 00:45:56,800
你會是一個新的與新
在它 - 這些值的元組。

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
>> 我還沒有觸及處理器集
在這次談話是pset6。

922
00:46:23,140 --> 00:46:25,837
因此，這裡是你如何倒是
實施A--這裡

923
00:46:25,837 --> 00:46:28,140
你會如何在Python實現pset6。

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--阿帕奇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機器上，
或CS50的Cloud9 IDE外部

932
00:46:54,717 --> 00:46:57,550
你想成為這個電流
目錄以一個特定的端口，

933
00:46:57,550 --> 00:47:04,610
蟒蛇米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
或者運行它 - 利用它來
運行自己的服務器服務。

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