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