1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:03,227
[音乐播放]

3
00:00:03,227 --> 00:00:04,705

4
00:00:04,705 --> 00:00:05,830
EZRA ZIGMOND：嗨，大家好。

5
00:00:05,830 --> 00:00:08,020
谢谢你今天出来。

6
00:00:08,020 --> 00:00:10,660
本次研讨会是“的Python
Web应用程序与瓶。“

7
00:00:10,660 --> 00:00:14,510
>> 所以，我将所讨论
为什么一点点

8
00:00:14,510 --> 00:00:17,400
您可能需要使用瓶，使
与Python的网络应用程序，而不是

9
00:00:17,400 --> 00:00:21,556
其他一些框架在那里，像
Django中，这是最公知的。

10
00:00:21,556 --> 00:00:24,330
副标题是“和
peewee“，这是值得

11
00:00:24,330 --> 00:00:27,250
我们要谈谈如何
与SQL数据库交互。

12
00:00:27,250 --> 00:00:29,610
这使得它非常好的。

13
00:00:29,610 --> 00:00:32,390
>> 所以，在这里只是一个快速纲要
是我想要走了过来。

14
00:00:32,390 --> 00:00:35,520
因此，首先，只有一个幻灯片
这将是快速入门，

15
00:00:35,520 --> 00:00:38,530
这是怎么得到的一切
设置您的计算机上。

16
00:00:38,530 --> 00:00:41,760
我将要展示
这在我的本地的Mac机，

17
00:00:41,760 --> 00:00:45,220
只是因为这是我做这个
以前，我最舒服，

18
00:00:45,220 --> 00:00:48,510
但这绝对
可能对CD50 IDE。

19
00:00:48,510 --> 00:00:52,050
>> 所以，在那之后，我想
引进什么样瓶，

20
00:00:52,050 --> 00:00:55,089
并说服你，为什么你应该
用它摆在首位。

21
00:00:55,089 --> 00:00:56,880
然后，我给一个快速
例如什么，你

22
00:00:56,880 --> 00:01:00,550
可在瓶，一个简单的例子做
你可以在peewee做什么，

23
00:01:00,550 --> 00:01:05,010
然后我会告诉你一个更
完整的示例应用程序

24
00:01:05,010 --> 00:01:07,520
我放在一起，我们
可以一起走过。

25
00:01:07,520 --> 00:01:10,040
>> 然后最后，在
最后一张幻灯片，我有

26
00:01:10,040 --> 00:01:12,730
你看一些资源
在网上获取更多信息。

27
00:01:12,730 --> 00:01:15,560
这不是一个完整
教程的如何使用瓶。

28
00:01:15,560 --> 00:01:18,140
我会希望离开
一段时间的问题。

29
00:01:18,140 --> 00:01:21,050
任何人都看在本地，只是
喜欢，喊出来在中间

30
00:01:21,050 --> 00:01:22,340
如果你有任何问题。

31
00:01:22,340 --> 00:01:27,150
>> 因此，快速安装的东西，
如果你想跟随，

32
00:01:27,150 --> 00:01:29,240
或者，如果你想获得这个
在您自己的机器，

33
00:01:29,240 --> 00:01:32,440
我将要使用Python 2.7.10。

34
00:01:32,440 --> 00:01:35,860
瓶做工作，
Python 3中，但我喜欢

35
00:01:35,860 --> 00:01:38,660
使用Python 2，因为有
一些Python包

36
00:01:38,660 --> 00:01:40,910
不与3个工作呢。

37
00:01:40,910 --> 00:01:44,800
如果你已经安装了点子，这
是一个Python包管理器，

38
00:01:44,800 --> 00:01:48,190
我认为，如果你的Python是
大于或等于2.7.9，

39
00:01:48,190 --> 00:01:52,220
您有它已经安装了，这是
超级容易安装这些软件包。

40
00:01:52,220 --> 00:01:54,990
>> 你可以做PIP安装
瓶，画中画安装peewee，

41
00:01:54,990 --> 00:01:58,600
通常你必须只执行sudo
这样的权限制定。

42
00:01:58,600 --> 00:02:01,080
而且，如果你使用的是
超级老版本的Python，

43
00:02:01,080 --> 00:02:05,100
我建议您更新的Python，
或使用EasyInstall安装点子。

44
00:02:05,100 --> 00:02:09,180

45
00:02:09,180 --> 00:02:11,120
那么，接下来的问题是，什么是瓶？

46
00:02:11,120 --> 00:02:13,280
我想，首先一
合理的问题我不知道

47
00:02:13,280 --> 00:02:15,585
很长一段时间是，什么是一个Web应用程序？

48
00:02:15,585 --> 00:02:17,960
因为这是一个词，我
觉得周围有很多抛出

49
00:02:17,960 --> 00:02:19,240
我真的不知道。

50
00:02:19,240 --> 00:02:22,340
我认为，最好的
例如一个什么样的Web应用程序是，

51
00:02:22,340 --> 00:02:26,960
真的是CS50融资，其中，
它不是真的只是一个网站，

52
00:02:26,960 --> 00:02:29,320
但它的东西，你
排序可以互动。

53
00:02:29,320 --> 00:02:31,736
有用户帐户和
各种不同的事情。

54
00:02:31,736 --> 00:02:35,010
那么，在什么地方你画
区别什么是一个网站线，

55
00:02:35,010 --> 00:02:38,780
什么是一个Web应用程序，则排序
任意的，但我想这个想法，

56
00:02:38,780 --> 00:02:42,110
它比一个网站更多的东西
这是一个有用的应用程序。

57
00:02:42,110 --> 00:02:46,081
>> 所以，瓶为框架
使得使用Python的网络应用程序。

58
00:02:46,081 --> 00:02:48,330
并希望，年底
这一点，我会说服你

59
00:02:48,330 --> 00:02:52,210
你实际上可以写的东西
像CS50财经使用Python，我

60
00:02:52,210 --> 00:02:53,950
像很多比PHP好，个人。

61
00:02:53,950 --> 00:02:57,320
>> 因此，瓶，他们所谓的
microframework，其中，

62
00:02:57,320 --> 00:02:59,800
他们的意思是非常
简单，但扩展性。

63
00:02:59,800 --> 00:03:02,980
因此，它只有你所需要的，
但如果你想要更多的功能，

64
00:03:02,980 --> 00:03:04,522
它很容易带给他们进来。

65
00:03:04,522 --> 00:03:06,480
但是，仅仅因为它是一个
microframework，不

66
00:03:06,480 --> 00:03:08,960
意味着它是唯一的小项目。

67
00:03:08,960 --> 00:03:12,590
我这里有一个链接，说
奥巴马用瓶在2012年

68
00:03:12,590 --> 00:03:14,410
为他的竞选
网站，该网站希望，

69
00:03:14,410 --> 00:03:16,937
是值得认可的。

70
00:03:16,937 --> 00:03:18,770
但事实是我
真的很喜欢瓶

71
00:03:18,770 --> 00:03:22,401
的是，它并没有真正做
任何形式的对你的决定。

72
00:03:22,401 --> 00:03:24,150
正因为我们是
谈到网络应用程序，

73
00:03:24,150 --> 00:03:26,940
我有比较它的Ruby on
Rails和Django的，这两个

74
00:03:26,940 --> 00:03:30,450
是伟大的框架，但
他们都做出假设

75
00:03:30,450 --> 00:03:33,600
你如何想
与数据库交互，

76
00:03:33,600 --> 00:03:36,900
如何你想展示你的
意见，而且他们肯定

77
00:03:36,900 --> 00:03:38,850
好的方面说。

78
00:03:38,850 --> 00:03:41,490
>> 例如，Ruby on Rails的
有这个活动记录系统，

79
00:03:41,490 --> 00:03:43,100
这是一个非常好的
的方式与数据进行交互，

80
00:03:43,100 --> 00:03:45,960
但如果你想使用的Ruby on
Rails的，你是那种绑成。

81
00:03:45,960 --> 00:03:47,835
但随着瓶，因为我会
显示你peewee，

82
00:03:47,835 --> 00:03:49,830
你可以使用任何排序
数据库的需要，

83
00:03:49,830 --> 00:03:53,980
你可以只拉，在
作为扩展到瓶中。

84
00:03:53,980 --> 00:03:56,350
>> 所以这就是为什么我真的
像瓶，那就是它

85
00:03:56,350 --> 00:04:01,170
不为你做的假设
基于东西你并不需要真的。

86
00:04:01,170 --> 00:04:04,440
>> 所以，你为什么要使用瓶？

87
00:04:04,440 --> 00:04:08,230
的优点是，它只是
拥有真正的核心特征

88
00:04:08,230 --> 00:04:09,420
内置到它，你需要的。

89
00:04:09,420 --> 00:04:11,980
所以，你不必担心
了解一大堆的东西

90
00:04:11,980 --> 00:04:13,175
你并不真正需要。

91
00:04:13,175 --> 00:04:15,060
您不必担心
有关关闭功能

92
00:04:15,060 --> 00:04:16,620
你并不真正需要。

93
00:04:16,620 --> 00:04:21,082
>> 而且，正如我所说，它的超
容易的事情扩展添加

94
00:04:21,082 --> 00:04:21,790
你确实需要。

95
00:04:21,790 --> 00:04:24,700
他们中的一些，瓶有
自己对它的支持。

96
00:04:24,700 --> 00:04:28,230
因此，有一种叫做瓶
管理，这反映了管理

97
00:04:28,230 --> 00:04:32,060
面板Django提供，
这给你一个很好的可视化的方式

98
00:04:32,060 --> 00:04:33,405
管理你的网站。

99
00:04:33,405 --> 00:04:35,280
但同样，如果你
制作简单的东西，

100
00:04:35,280 --> 00:04:39,550
你也许并不需要一个大管理员
面板上，所以我认为这是超级漂亮。

101
00:04:39,550 --> 00:04:45,940
而缺点是，这
你有更少的功率开箱。

102
00:04:45,940 --> 00:04:49,660
所以，当你第一次打开瓶，
在你的Python程序，

103
00:04:49,660 --> 00:04:53,150
你刚刚从瓶式
进口*，或什么的，

104
00:04:53,150 --> 00:04:55,957
你没有完全得到所有的
该功能，你可能希望。

105
00:04:55,957 --> 00:04:58,540
所以，你必须更明确地
列出你想要的功能。

106
00:04:58,540 --> 00:05:01,990
所以这是一个不利因素，但我
认为，建设小网站

107
00:05:01,990 --> 00:05:04,782
喜欢我的应用我要展示
你，这不是一个真正的问题。

108
00:05:04,782 --> 00:05:07,281
而最后一件事是什么
应该说，这是一个错字，

109
00:05:07,281 --> 00:05:10,240
是，有欠规范
约定如何使用瓶，

110
00:05:10,240 --> 00:05:12,400
只是因为有没有那么多
使用它的专业人

111
00:05:12,400 --> 00:05:13,191
相比于Django的。

112
00:05:13,191 --> 00:05:16,380
所以，如果你是这个样子，
在Django“我怎么办×”，

113
00:05:16,380 --> 00:05:18,190
你可能会发现它。

114
00:05:18,190 --> 00:05:20,260
>> 有良好的设计
图案可以使用，

115
00:05:20,260 --> 00:05:22,660
但与瓶，它是
样的走自己的路，

116
00:05:22,660 --> 00:05:24,850
只是因为它是一个
漂亮的小型图书馆。

117
00:05:24,850 --> 00:05:27,100
所以，这些都是
缺点，但我认为

118
00:05:27,100 --> 00:05:29,370
它仍然是一个很好的库来使用。

119
00:05:29,370 --> 00:05:31,909
>> 那么就让我们直接进入瓶中。

120
00:05:31,909 --> 00:05:34,200
这是绝对不会
是一个完整的教程，

121
00:05:34,200 --> 00:05:37,480
但它给你的想法
如何构建物，

122
00:05:37,480 --> 00:05:40,790
所以你感觉很舒服去
关闭并寻找文档

123
00:05:40,790 --> 00:05:42,570
并找出更多。

124
00:05:42,570 --> 00:05:48,500
>> 所以，让我开了一个非常
在第一个简单的例子，

125
00:05:48,500 --> 00:05:50,737
并且告诉你那是什么
样子，然后我们会

126
00:05:50,737 --> 00:05:52,070
打破它，多一点点。

127
00:05:52,070 --> 00:05:56,160
>> 因此，这在这里，让我得到它运行。

128
00:05:56,160 --> 00:06:06,800

129
00:06:06,800 --> 00:06:09,750
所以，我现在有应用程序的运行我的。

130
00:06:09,750 --> 00:06:15,910
我要打开Safari浏览器，和
这是我的本地主机上运行。

131
00:06:15,910 --> 00:06:19,360
所以，我只是打算让这个更大。

132
00:06:19,360 --> 00:06:23,960
但本地主机：5000

133
00:06:23,960 --> 00:06:27,650
>> 所以，现在，这一切都不会
是，当您访问的网站，

134
00:06:27,650 --> 00:06:31,490
它打印出“你好瓶，”
这是不是超级有用，

135
00:06:31,490 --> 00:06:34,630
但我认为这是很酷的
在这里这个小文件，

136
00:06:34,630 --> 00:06:37,390
我们有一个Web服务器上运行
正在打印出来的东西。

137
00:06:37,390 --> 00:06:40,500
所以，让我们实际上看起来
在用于第二代码，

138
00:06:40,500 --> 00:06:43,080
并能把它们一点点。

139
00:06:43,080 --> 00:06:45,260
就是尺寸对大家都有好处吗？

140
00:06:45,260 --> 00:06:51,560
>> 所以，我希望，你是有点
舒适的使用Python。

141
00:06:51,560 --> 00:06:55,820
我假设大家可以看看
在Python和阅读它。

142
00:06:55,820 --> 00:06:59,290
如果您有任何疑问，
任何事情，我也可以去了这一点。

143
00:06:59,290 --> 00:07:03,974
>> 所以，第一行是，从瓶，
我们导入，瓶用大写字母“F”

144
00:07:03,974 --> 00:07:06,140
这是排序的所有
你需要的关键功能。

145
00:07:06,140 --> 00:07:08,890
当你写
一个文件，并使用烧瓶，

146
00:07:08,890 --> 00:07:12,120
你将要导入的是，
只是因为有所有主要的事情。

147
00:07:12,120 --> 00:07:15,400
我们做的下一件事，就是我们
调用这个函数瓶，只是

148
00:07:15,400 --> 00:07:19,270
创建一个应用程序对象，而你
总是会想这样做。

149
00:07:19,270 --> 00:07:25,960
>> 然后，跳跃下至
底部很快，这部分在这里，

150
00:07:25,960 --> 00:07:28,760
'if_name _ ==“_ main_”'，这是
排序Python的公约。

151
00:07:28,760 --> 00:07:32,750
因此，这只会如果执行
直接运行使用Python这个文件。

152
00:07:32,750 --> 00:07:36,040
然后，我们调用app.run，这将
实际上启动应用程序去。

153
00:07:36,040 --> 00:07:39,570
>> 所以，这是最主要的结构
你必须在任何瓶的应用，

154
00:07:39,570 --> 00:07:48,550
是你有这样的
应用=合剂（_NAME_），然后app.run。

155
00:07:48,550 --> 00:07:54,940
>> 因此，两件事情，我有
在这里，就是我们所说的路线。

156
00:07:54,940 --> 00:07:57,150
那么，让我们来谈谈
路由多一点点。

157
00:07:57,150 --> 00:07:58,430
我会回去的幻灯片。

158
00:07:58,430 --> 00:08:02,540
>> 所以最根本
概念瓶路由。

159
00:08:02,540 --> 00:08:06,750
而且它的想法，你
在Python分配功能

160
00:08:06,750 --> 00:08:11,280
具体地址
在您的网页。

161
00:08:11,280 --> 00:08:13,930
所以，当你想
创建一个新的路线，

162
00:08:13,930 --> 00:08:16,500
使用此@ app.route
功能装饰。

163
00:08:16,500 --> 00:08:19,770
所以，如果你不熟悉
功能装饰在Python，

164
00:08:19,770 --> 00:08:24,160
它的这个概念，
让你把一个函数

165
00:08:24,160 --> 00:08:26,800
和别的东西包围它。

166
00:08:26,800 --> 00:08:30,140
>> 因此，其实，这是什么装饰呢，
是，它需要在它下面的功能，

167
00:08:30,140 --> 00:08:33,409
它增加了更多的信息
其实吧，但什么瓶

168
00:08:33,409 --> 00:08:37,480
没有做到这一点是不超
至关重要的，但重要的，

169
00:08:37,480 --> 00:08:43,640
是路由之前，则
把这个@ app.route，然后

170
00:08:43,640 --> 00:08:46,480
的路由的地址，
所以斜线是我们

171
00:08:46,480 --> 00:08:48,360
看到我们刚刚打开网页。

172
00:08:48,360 --> 00:08:49,580
所以这是主页。

173
00:08:49,580 --> 00:08:51,037
这只是斜线路线。

174
00:08:51,037 --> 00:08:52,370
然后你有这个功能。

175
00:08:52,370 --> 00:08:54,453
的函数的名称
可以是任何你想要的。

176
00:08:54,453 --> 00:08:56,930
它不必一定
都与路线。

177
00:08:56,930 --> 00:08:59,440
然后，无论
函数的返回，

178
00:08:59,440 --> 00:09:01,730
该函数返回一个字符串。

179
00:09:01,730 --> 00:09:03,740
而该字符串可以
包含HTML或任何东西，

180
00:09:03,740 --> 00:09:06,920
那实际上是什么将得到
返回给Web浏览器为HTML，

181
00:09:06,920 --> 00:09:08,200
它会渲染。

182
00:09:08,200 --> 00:09:12,030
>> 因此，这是相同的代码
这是从例如

183
00:09:12,030 --> 00:09:16,430
我刚跑了，所以当我们访问的斜线，
它调用一个Hello World功能，

184
00:09:16,430 --> 00:09:20,470
只是返回一个字符串，你好瓶，
并且被显示在屏幕上。

185
00:09:20,470 --> 00:09:27,290
>> 因此，有另外一个例子，
这就是，当你访问/你好，

186
00:09:27,290 --> 00:09:30,370
它打印出您好字，这
实际上应该说，你好世界，

187
00:09:30,370 --> 00:09:32,010
但让我们假装是故意的。

188
00:09:32,010 --> 00:09:35,140
因此，让我们拉了起来真快。

189
00:09:35,140 --> 00:09:41,290
>> 所以，如果你去到localhost /你好，
现在将打印别的东西。

190
00:09:41,290 --> 00:09:45,680
所以这是一个如何只是一个简单的例子
你可以创建两个不同的路线。

191
00:09:45,680 --> 00:09:50,630
>> 因此，到目前为止，这是不是超级有用，
没有了一大堆你可以做，

192
00:09:50,630 --> 00:09:55,360
你可以只做的一切，与
具有不同的HTML页面，

193
00:09:55,360 --> 00:09:58,000
当你访问一个特定的
网页它只是加载页面。

194
00:09:58,000 --> 00:10:00,864
所以，让我们来看看一些
有用的事情可以做。

195
00:10:00,864 --> 00:10:03,780
所以，有一件事，你可能有
注意到在我把这个例子

196
00:10:03,780 --> 00:10:07,160
起来，是我app.run（调试= TRUE）。

197
00:10:07,160 --> 00:10:09,580
所以，这是什么
调试的说法呢，是

198
00:10:09,580 --> 00:10:14,600
当你运行你的Web服务器，
当你在你的应用程序，

199
00:10:14,600 --> 00:10:18,100
如果更改一个文件时，它会
自动重新加载服务器。

200
00:10:18,100 --> 00:10:21,160
>> 所以你实际上并不需要
重启Python中，这是超级有用。

201
00:10:21,160 --> 00:10:24,020
我可以证明。

202
00:10:24,020 --> 00:10:26,960
让我拉起我的代码
在它的错字，

203
00:10:26,960 --> 00:10:30,420
并假装错字放在那里
故意为启发性的目的。

204
00:10:30,420 --> 00:10:31,625
因此，让我们加入这个。最

205
00:10:31,625 --> 00:10:33,140
所以现在说的Hello World。

206
00:10:33,140 --> 00:10:34,410
我会保存它。

207
00:10:34,410 --> 00:10:36,540
如果我们拉回来了
终端，你会

208
00:10:36,540 --> 00:10:39,520
说它是重新启动，
因为它检测到变化，

209
00:10:39,520 --> 00:10:43,620
所以现在当我们刷新这个页面，
它会打印出正确的事情。

210
00:10:43,620 --> 00:10:45,630
>> 所以，调试是该超级有用。

211
00:10:45,630 --> 00:10:48,740
此外，如果您有任何
那种崩溃的，所以

212
00:10:48,740 --> 00:10:54,370
让我做这个应用程序崩溃
有它不会返回一个字符串。

213
00:10:54,370 --> 00:10:57,540
所以，我们只是把它
返回无出于某种原因。

214
00:10:57,540 --> 00:11:00,810
然后，当我访问这个
页面，它只会崩溃，

215
00:11:00,810 --> 00:11:04,465
但服务器并不仅仅崩溃，它
实际上给你一个超级有益的回

216
00:11:04,465 --> 00:11:06,490
一切痕迹出了问题。

217
00:11:06,490 --> 00:11:10,050
而什么是真正好的，就是
在此回溯任何一步，

218
00:11:10,050 --> 00:11:14,260
你可以打开一个互动
外壳在这里，排序打印出什么

219
00:11:14,260 --> 00:11:17,780
你想变量来看一看。

220
00:11:17,780 --> 00:11:21,054
>> 所以调试真的
为找出有用

221
00:11:21,054 --> 00:11:23,470
什么与怎么回事你
服务器，而不是仅仅看

222
00:11:23,470 --> 00:11:28,201
一些在PHP像500的内部
服务器错误，这是超级没用。

223
00:11:28,201 --> 00:11:30,700
有一点需要注意的，是
如果你把你的应用程序在线

224
00:11:30,700 --> 00:11:34,260
所以它的公开显示的，你
永远都不想离开的调试模式，

225
00:11:34,260 --> 00:11:37,320
因为人们实际上可以
使用控制台，我

226
00:11:37,320 --> 00:11:39,150
表现出你来执行任意代码。

227
00:11:39,150 --> 00:11:42,120
>> 因此，他们可以打印出像任何
暗号你在那里，

228
00:11:42,120 --> 00:11:44,755
他们可以看看完全
如何你的网站工作。

229
00:11:44,755 --> 00:11:46,630
所以这是非常有用的
进行测试，但总是

230
00:11:46,630 --> 00:11:50,090
一定要拿出来之前，
你在网上发布任何东西。

231
00:11:50,090 --> 00:11:56,640
>> 因此，当你使用的东西
如PHP，有这种想法

232
00:11:56,640 --> 00:11:58,920
你可以通过
网页之间的信息

233
00:11:58,920 --> 00:12:03,620
通过将信息实际
在URL，它是一个GET请求，

234
00:12:03,620 --> 00:12:07,490
但在瓶，你其实可以
做一些有点像的，

235
00:12:07,490 --> 00:12:10,590
通过具有包含路由
一个变量作为它的一部分。

236
00:12:10,590 --> 00:12:14,090
>> 所以，如果你看看这个
例如在屏幕上这里，

237
00:12:14,090 --> 00:12:19,930
我们有一个路由的
（'/你好/'），所以，如果你访问

238
00:12:19,930 --> 00:12:23,790
/你好/的东西，这东西
是要真正得到填充

239
00:12:23,790 --> 00:12:25,490
到name变量。

240
00:12:25,490 --> 00:12:27,850
并注意函数
随这条路线

241
00:12:27,850 --> 00:12:31,302
必须采取在参数
名字，这样它实际上

242
00:12:31,302 --> 00:12:32,510
得到传递给函数。

243
00:12:32,510 --> 00:12:34,190
>> 然后，一旦你
该函数的内部，

244
00:12:34,190 --> 00:12:36,420
你可以把像
一个普通的Python变量，

245
00:12:36,420 --> 00:12:39,650
因此，然后，它会
打印出你好，和它

246
00:12:39,650 --> 00:12:42,000
使用这个名字将填补
某些字符串格式化。

247
00:12:42,000 --> 00:12:48,060
>> 所以可变份添加至路由，
使用尖括号标记。

248
00:12:48,060 --> 00:12:51,220
而且您还可以选择使用
什么叫做转换器。

249
00:12:51,220 --> 00:12:56,840
所以，如果你把这个
注解与结肠，

250
00:12:56,840 --> 00:13:00,015
你可以指定它的
一个int，或浮，或路径，

251
00:13:00,015 --> 00:13:01,640
它会自动将其转换。

252
00:13:01,640 --> 00:13:05,130
你也可以做转换
Python的函数中，

253
00:13:05,130 --> 00:13:09,710
只需使用一投，但有时如果
要确保它是一个int，

254
00:13:09,710 --> 00:13:12,080
你可以把
在那里转换规则。

255
00:13:12,080 --> 00:13:15,930
>> 所以，让我们拉起一个例子
一些变量规则。

256
00:13:15,930 --> 00:13:21,480
所以在这里，这具有相同的基本
结构与从瓶进口

257
00:13:21,480 --> 00:13:25,030
瓶，应用程序=瓶（_NAME_）
然后在最后的运行。

258
00:13:25,030 --> 00:13:28,050
我们有两种不同的
变量的路线在这里。

259
00:13:28,050 --> 00:13:29,900
而第一位的，是
我表现出一个

260
00:13:29,900 --> 00:13:34,230
在滑动，这是
它只是需要一个字符串名称

261
00:13:34,230 --> 00:13:35,650
它会打印出你好，名称。

262
00:13:35,650 --> 00:13:41,410
>> 然后，第二
人使用的转换。

263
00:13:41,410 --> 00:13:44,690
因此，这会自动将其转换
为int，然后双击该INT，

264
00:13:44,690 --> 00:13:46,150
并打印了这一点。

265
00:13:46,150 --> 00:13:48,220
而且，我们不做任何形式的
在它的转换

266
00:13:48,220 --> 00:13:49,594
因为瓶需要的照顾。

267
00:13:49,594 --> 00:13:53,181
因此，让我们得到这个运行。

268
00:13:53,181 --> 00:13:54,930
当你有一个瓶
应用程序运行，

269
00:13:54,930 --> 00:13:58,440
您可以控制​​-C出来的
停止服务器运行。

270
00:13:58,440 --> 00:14:02,420
然后我将运行变量。

271
00:14:02,420 --> 00:14:11,740
>> 因此，让我们为localhost /你好/以斯拉和
但愿，这会跟我打招呼。

272
00:14:11,740 --> 00:14:14,530

273
00:14:14,530 --> 00:14:20,310
>> 因此，它参加了我的名字，在变量
路线，并且它填充它在这里。

274
00:14:20,310 --> 00:14:23,950
所以，我也将展示一个快速
例如增加一倍。

275
00:14:23,950 --> 00:14:28,600
所以，如果你去/双/ 3，
它会打印出6。

276
00:14:28,600 --> 00:14:31,440
因此，这把照顾
转换我们。

277
00:14:31,440 --> 00:14:34,190
>> 所以，你也可以做到这一点与
float和一些特别的东西，

278
00:14:34,190 --> 00:14:37,530
如果你需要指定像
一个路径，即让它接受斜杠，

279
00:14:37,530 --> 00:14:39,155
但通常不应是一个问题。

280
00:14:39,155 --> 00:14:41,480

281
00:14:41,480 --> 00:14:43,820
到目前为止，我们，还有
刚刚回国

282
00:14:43,820 --> 00:14:46,320
串，这是不很有趣。

283
00:14:46,320 --> 00:14:48,730
>> 我们其实可以返回
文字HTML字符串。

284
00:14:48,730 --> 00:14:54,322
因此，在代码中我们可以插入一些东西
像B-标签，使之大胆，

285
00:14:54,322 --> 00:14:56,030
但大多数时候，你
其实不愿意

286
00:14:56,030 --> 00:14:58,420
要编写HTML代码
在你的Python代码。

287
00:14:58,420 --> 00:15:01,940
它变得非常凌乱，
这不是一个好时机。

288
00:15:01,940 --> 00:15:06,430
>> 烧瓶允许我们以分离出
HTML到什么叫做模板，

289
00:15:06,430 --> 00:15:09,467
所以，如果你想
在MVC模型而言

290
00:15:09,467 --> 00:15:11,550
你是熟悉的，
希望，从工作

291
00:15:11,550 --> 00:15:15,520
与CS50融资一点点，
你可以认为Python的文件

292
00:15:15,520 --> 00:15:19,430
作为多个控制器，其中的
它们与任何交互

293
00:15:19,430 --> 00:15:20,970
数据模型，你可能有。

294
00:15:20,970 --> 00:15:24,900
>> 然后，他们被呼唤意见
和传递信息的查看

295
00:15:24,900 --> 00:15:28,120
填写信息
在HTML中，它需要。

296
00:15:28,120 --> 00:15:30,490
而我们所说的这些意见
在类模板。

297
00:15:30,490 --> 00:15:35,280
>> 因此，瓶用另一个Python
模块，它会自动

298
00:15:35,280 --> 00:15:38,620
安装时，PIP安装
瓶所谓的神社，它

299
00:15:38,620 --> 00:15:40,885
允许您添加这些
注释到HTML

300
00:15:40,885 --> 00:15:45,140
你在屏幕上看到，这让
你把东西像条件语句，

301
00:15:45,140 --> 00:15:47,230
并循环到HTML。

302
00:15:47,230 --> 00:15:51,140
>> 所以它看起来像你如何一点点
可以使用PHP中的HTML文件，

303
00:15:51,140 --> 00:15:57,380
但是这仅仅是当瓶
服务器提供了HTML文件，

304
00:15:57,380 --> 00:16:01,610
它会运行这个模板引擎和
通过分析这并填写事物研究。

305
00:16:01,610 --> 00:16:06,650
所以瓶具有render_template功能
您可以在底部看到这里。

306
00:16:06,650 --> 00:16:14,300
所以，当你访问这个页面时，它
会使这个hello.html的模板，

307
00:16:14,300 --> 00:16:16,407
然后填写此HTML页面。

308
00:16:16,407 --> 00:16:18,990
因此，让我们只需要运行这个现实
很快，看看它是什么样子，

309
00:16:18,990 --> 00:16:21,198
然后我会去通过
更详细一点。

310
00:16:21,198 --> 00:16:25,380

311
00:16:25,380 --> 00:16:30,260
所以，你的模板会
走在一个模板文件夹。

312
00:16:30,260 --> 00:16:33,980
它会自动寻找内
Templates文件夹为模板。

313
00:16:33,980 --> 00:16:35,615
因此，让我们打开此了。

314
00:16:35,615 --> 00:16:47,350

315
00:16:47,350 --> 00:16:50,005
所以，我将运行模板的例子。

316
00:16:50,005 --> 00:16:52,820

317
00:16:52,820 --> 00:17:03,660
>> 所以，如果我去/你好/以斯拉，
它有这个太可怕了，

318
00:17:03,660 --> 00:17:05,930
讨厌的字幕标记，我插嘴说。

319
00:17:05,930 --> 00:17:08,050
非常好，非常有活力。

320
00:17:08,050 --> 00:17:09,349
我是一个大风扇。

321
00:17:09,349 --> 00:17:13,900
但是，如果发生
我刚去，/你好？

322
00:17:13,900 --> 00:17:15,220
所以它只是世界您好如是说。

323
00:17:15,220 --> 00:17:17,678
我并没有传递给它一个名称，
它会自动填充入。

324
00:17:17,678 --> 00:17:22,050
所以，让我们来看看它是怎么做的，以及如何
我们可以摆脱那个帐篷的可能。

325
00:17:22,050 --> 00:17:26,240
>> 所以在这里，这是有点
一个有趣的例子，

326
00:17:26,240 --> 00:17:29,101
如果你熟悉如何开关
报表的语言工作。

327
00:17:29,101 --> 00:17:31,350
之所以这样说，是有点像，
那种跌倒过的，

328
00:17:31,350 --> 00:17:34,266
在这里你居然挂的两个
不同的路线相同的功能。

329
00:17:34,266 --> 00:17:41,190
因此，我们附上/你好路线，
将/你好/名称路线您好，

330
00:17:41,190 --> 00:17:45,130
我们指定using--利用Python可以
指定默认功能arguments--

331
00:17:45,130 --> 00:17:48,300
因此，如果没有名字，所以
如果我们去刚刚/你好，

332
00:17:48,300 --> 00:17:50,680
它会自动过滤
命名等于无。

333
00:17:50,680 --> 00:17:55,010
>> 那么，我们呈现
模板名称=名称，

334
00:17:55,010 --> 00:17:59,510
所以它会通过在名称参数
等于这个名称功能参数，

335
00:17:59,510 --> 00:18:00,730
入模板。

336
00:18:00,730 --> 00:18:04,040
这仍然没有解释是如何
在决定是否打印的Hello World，

337
00:18:04,040 --> 00:18:05,100
或打印我的名字。

338
00:18:05,100 --> 00:18:08,050
因此，让我们实际上看起来
入模板本身

339
00:18:08,050 --> 00:18:11,610
而看到这是来自。

340
00:18:11,610 --> 00:18:18,680
>> 所以，这个模板中，我们
实际上有一些有条件的逻辑，

341
00:18:18,680 --> 00:18:20,580
有些人会
认为，你居然

342
00:18:20,580 --> 00:18:23,730
不应该有很多的条件
模板本身的逻辑。

343
00:18:23,730 --> 00:18:26,310
应当在更
控制器，但在本实施例

344
00:18:26,310 --> 00:18:27,476
它的东西非常小。

345
00:18:27,476 --> 00:18:31,060
所以在这里，我们检查，如果名字，所以
如果名称不等于无，

346
00:18:31,060 --> 00:18:33,130
如果一个名字实际上是
传递，那么我们将

347
00:18:33,130 --> 00:18:36,210
说你好，名称
标题和字幕，

348
00:18:36,210 --> 00:18:41,490
所有这些普通的HTML，否则，我们将
打印出来的Hello，World只是一般。

349
00:18:41,490 --> 00:18:45,820
因此，有两件事情这里要注意
你如何格式化模板，

350
00:18:45,820 --> 00:18:49,110
的是，所有这些
条件语句，

351
00:18:49,110 --> 00:18:54,475
有点像我们如何PHP它时，
要插入一些PHP，

352
00:18:54,475 --> 00:18:58,380
使用小于问题
标记，它是那种类似于这里

353
00:18:58,380 --> 00:19:00,140
与{％。

354
00:19:00,140 --> 00:19:02,130
>> 所以在这里，我们有我们的条件代码。

355
00:19:02,130 --> 00:19:05,920
然后，当你真的想
从字面上评估的东西，并打印

356
00:19:05,920 --> 00:19:08,710
它的屏幕，
使用双括号。

357
00:19:08,710 --> 00:19:12,310
因此，这里有双重支撑，
然后我们指定的名称，

358
00:19:12,310 --> 00:19:15,500
左右的时间内，它会评估
到变量名，它

359
00:19:15,500 --> 00:19:18,860
从传递
渲染模​​板功能，

360
00:19:18,860 --> 00:19:21,484
而不是仅仅印刷
出，如果我们摆脱这些，

361
00:19:21,484 --> 00:19:23,150
它只是打印出来的字“的名字。”

362
00:19:23,150 --> 00:19:26,340
所以，这件事情要注意。

363
00:19:26,340 --> 00:19:29,792
>> 所以，另一件事
通知是，当我们

364
00:19:29,792 --> 00:19:31,500
要使用的
render_template功能，

365
00:19:31,500 --> 00:19:34,490
我们其实有进口
它明确地从瓶。

366
00:19:34,490 --> 00:19:36,915
这就是一个例子
合剂的模块化，

367
00:19:36,915 --> 00:19:39,290
你不必进口
东西，你不需要。

368
00:19:39,290 --> 00:19:41,290
你可以只是把在
功能你其实

369
00:19:41,290 --> 00:19:43,450
确实需要，有时
不错，这样你就不会

370
00:19:43,450 --> 00:19:46,560
必须有所有这些功能
坐在那里，你没有使用，

371
00:19:46,560 --> 00:19:49,730
而且，如果你忘了你
需要进口render_template，

372
00:19:49,730 --> 00:19:52,660
你可能会得到一个警告
这将让你知道。

373
00:19:52,660 --> 00:19:56,700
所以，这就是一种模板。

374
00:19:56,700 --> 00:20:01,680
>> 因此，我们已经展示了如何
制作简单的网页，

375
00:20:01,680 --> 00:20:04,947
并添加一点点逻辑
它，在可变路由而言。

376
00:20:04,947 --> 00:20:08,280
它可以让你做不同的事情的基础上
你去了，也再网址，给

377
00:20:08,280 --> 00:20:11,950
在HTML一点点更有意义
术语要如何呈现的东西。

378
00:20:11,950 --> 00:20:14,210
你不必把所有
你的HTML在你的Python，

379
00:20:14,210 --> 00:20:16,640
但对于相当多
每个Web应用程序，

380
00:20:16,640 --> 00:20:21,480
你会需要某种
数据模型的与它相关联。

381
00:20:21,480 --> 00:20:25,560
>> 所以传统上，这将
是这样的一个SQL数据库。

382
00:20:25,560 --> 00:20:30,280
而且你可以互动
直接使用SQL。

383
00:20:30,280 --> 00:20:32,190
Python有，我想这就是所谓的。

384
00:20:32,190 --> 00:20:33,040
SQLite的3。

385
00:20:33,040 --> 00:20:38,454
你可以只导入的SQLite 3
直接执行SQL查询，

386
00:20:38,454 --> 00:20:40,870
但我不知道你，
但我真的不喜欢，只是，

387
00:20:40,870 --> 00:20:42,750
写出SQL查询。

388
00:20:42,750 --> 00:20:45,350
它往往会得到真正
漫长而复杂。

389
00:20:45,350 --> 00:20:49,180
>> 因此，一些
我喜欢用的是什么

390
00:20:49,180 --> 00:20:53,610
被称为一个ORM，这是一个
对象关系映射。

391
00:20:53,610 --> 00:20:56,890
而一个点
对象 - 关系映射，

392
00:20:56,890 --> 00:21:00,100
是，有两个不同的
方法，你可以考虑一下数据库。

393
00:21:00,100 --> 00:21:03,240
>> 这样的例子，
马兰教授通常

394
00:21:03,240 --> 00:21:07,660
采用课堂，是Excel表格，其中
你有这些行和这些列，

395
00:21:07,660 --> 00:21:10,210
而这对于真正有用的
它是如何表示的SQL

396
00:21:10,210 --> 00:21:13,170
你如何与它进行交互，但
另一种方式，它实际上

397
00:21:13,170 --> 00:21:16,390
去想它有时是有用的，
在类和对象方面。

398
00:21:16,390 --> 00:21:20,420
>> 因此，而不是思维
每个表中的作为具有

399
00:21:20,420 --> 00:21:23,040
此行有一定
信息，你其实可以

400
00:21:23,040 --> 00:21:26,100
把它看作是
每个表是一个类，

401
00:21:26,100 --> 00:21:29,810
的，然后每一个实例
类有一定的属性。

402
00:21:29,810 --> 00:21:35,110
所以，在这个例子中，实例
类是在表中的行，

403
00:21:35,110 --> 00:21:37,490
然后每个属性会
在表中的一列。

404
00:21:37,490 --> 00:21:40,840
>> 所以，我喜欢的ORM
使用被称为peewee。

405
00:21:40,840 --> 00:21:43,520
这是非常小的，有点像瓶。

406
00:21:43,520 --> 00:21:46,760
我认为他们可以融洽​​相处，
但也有很多其他的奥姆斯的

407
00:21:46,760 --> 00:21:47,730
您可以使用。

408
00:21:47,730 --> 00:21:52,180
更常用的是
被称为SQLAlchem​​y的，

409
00:21:52,180 --> 00:21:56,050
我不记得为什么我原来
选择peewee了SQLAlchem​​y的，

410
00:21:56,050 --> 00:21:58,311
或者我会告诉你我为什么
认为这是最好的一个，

411
00:21:58,311 --> 00:22:01,060
但我们只是要使用此
一个，因为我知道如何使用它。

412
00:22:01,060 --> 00:22:04,760
>> 于是，一个问题是，为什么
如果您懒得使用ORM，

413
00:22:04,760 --> 00:22:07,552
而不只是直接
编写SQL查询？

414
00:22:07,552 --> 00:22:09,760
我认为最好的情况下，
是，你实际上并不

415
00:22:09,760 --> 00:22:11,356
必须编写SQL查询。

416
00:22:11,356 --> 00:22:14,480
这是很容易，因为我会告诉你，
做这样的事情的选择，插入，

417
00:22:14,480 --> 00:22:16,157
缺失，尤其是创建表。

418
00:22:16,157 --> 00:22:17,990
它更容易
写一个类结构，

419
00:22:17,990 --> 00:22:22,250
比它构建一个创建
表声明，但有一件事

420
00:22:22,250 --> 00:22:25,710
要注意的是，
在ORM将尽力

421
00:22:25,710 --> 00:22:28,640
找出最
有效的SQL查询是，

422
00:22:28,640 --> 00:22:30,110
但有时它得到它错了。

423
00:22:30,110 --> 00:22:32,660
>> 特别是如果你是
有一个大的数据库的工作，

424
00:22:32,660 --> 00:22:35,557
你可以看到一个查询
应该运行速度快，

425
00:22:35,557 --> 00:22:36,640
实际上是需要较长时间。

426
00:22:36,640 --> 00:22:40,164
如果你看看引擎盖下如何
在ORM的解释是到SQL，

427
00:22:40,164 --> 00:22:42,080
它可能会做什么
真是可笑，

428
00:22:42,080 --> 00:22:44,371
仅仅因为几分之
示意你的意图是错误的。

429
00:22:44,371 --> 00:22:48,080
而且，曾经有段时间在哪里
我已经覆盖它，只是

430
00:22:48,080 --> 00:22:52,429
执行自己的SQL查询，只
因为它是分析在一个陌生的方式。

431
00:22:52,429 --> 00:22:54,220
所以，有一些
开销，只是在方式

432
00:22:54,220 --> 00:22:58,680
它编译您
语句分解成SQL。

433
00:22:58,680 --> 00:23:06,200
>> 所以，让我们快速浏览一下超在
一个数据模型的一个简单的例子

434
00:23:06,200 --> 00:23:07,350
你可能会使用。

435
00:23:07,350 --> 00:23:11,880
所以，这是Python代码，所以
你想要做的第一件事情是从

436
00:23:11,880 --> 00:23:12,950
peewee进口*。

437
00:23:12,950 --> 00:23:15,850
因此，与瓶，那就是你有
所有这些单独的模块，

438
00:23:15,850 --> 00:23:18,125
并要导入烧瓶中，
写一个模板，和一些其他

439
00:23:18,125 --> 00:23:20,690
以后我们会看到，从peewee，
你可以导入一切，

440
00:23:20,690 --> 00:23:22,290
因为它是一个非常小的图书馆。

441
00:23:22,290 --> 00:23:26,490
>> 所以，你要做的第一件事，就是
真正创建这个数据库对象。

442
00:23:26,490 --> 00:23:31,212
所以，你有DB = SqliteDatabase，
然后你的数据库的名称。

443
00:23:31,212 --> 00:23:33,170
而这实际上
创建数据库对象

444
00:23:33,170 --> 00:23:36,230
您可以与互动，与peewee。

445
00:23:36,230 --> 00:23:40,570
>> 然后，我们有实际的
我们要创建的模型。

446
00:23:40,570 --> 00:23:42,470
因此，上表中我们要创建。

447
00:23:42,470 --> 00:23:47,270
因此，在peewee，每个班都有
在数据库中自己的表。

448
00:23:47,270 --> 00:23:52,800
因此，所有的类
从基础模型继承，

449
00:23:52,800 --> 00:23:55,960
和资本M型是
这在peewee定义的东西。

450
00:23:55,960 --> 00:24:02,162
>> 所以，所有的车型都应该
继承他们的最高超，

451
00:24:02,162 --> 00:24:04,620
他们应该继承
模式，但什么是真的很酷，

452
00:24:04,620 --> 00:24:07,610
是，你实际上可以有你
模型继承彼此。

453
00:24:07,610 --> 00:24:10,530
而且很多时候，你的
数据模型不一定

454
00:24:10,530 --> 00:24:13,754
使一个很好的继承层次，但
时间在那里做什么，这是非常好的，

455
00:24:13,754 --> 00:24:15,920
因为你的模型
固有彼此。

456
00:24:15,920 --> 00:24:19,710
>> 因此，我们定义这个类
“学生”，它继承了一个模型，

457
00:24:19,710 --> 00:24:21,170
它有三个属性。

458
00:24:21,170 --> 00:24:24,080
它的ID，它是
一个PrimaryKeyField，这

459
00:24:24,080 --> 00:24:26,920
是提供真实的东西
通过peewee，名字是一个CharField，

460
00:24:26,920 --> 00:24:28,490
和档次是IntegerField。

461
00:24:28,490 --> 00:24:32,260
因此，这可能会或可能不会
如何CS50实际存储所有

462
00:24:32,260 --> 00:24:33,650
学生的成绩。

463
00:24:33,650 --> 00:24:36,060
它不是，但是这是我会怎么做。

464
00:24:36,060 --> 00:24:37,920
>> 然后它有，内
这个类，而这

465
00:24:37,920 --> 00:24:41,620
是你可以做的
Python中，你可以有嵌套类。

466
00:24:41,620 --> 00:24:43,920
而这是后话
的需要的由peewee。

467
00:24:43,920 --> 00:24:47,250
因此，该类元，你有
指定该数据库

468
00:24:47,250 --> 00:24:49,830
等于物体
我们在上面创建的。

469
00:24:49,830 --> 00:24:54,339
这表示什么文件该表
究竟要包含研究。

470
00:24:54,339 --> 00:24:57,130
因此，这是，你有什么
在所有的模型做。

471
00:24:57,130 --> 00:24:59,380
你只需要指定
这个元类中

472
00:24:59,380 --> 00:25:01,400
该数据库是等于分贝。

473
00:25:01,400 --> 00:25:03,940
所以我通常会做，如果我有
一堆不同的模式，

474
00:25:03,940 --> 00:25:05,910
是，我有一个基本
模型，我平时

475
00:25:05,910 --> 00:25:08,839
就叫“示范基地”
具有元类​​，

476
00:25:08,839 --> 00:25:10,380
并设置数据库等于分贝。

477
00:25:10,380 --> 00:25:13,710
然后我所有的后续机型
将继承该基类。

478
00:25:13,710 --> 00:25:16,760
然后，我就不必担心
有关设置元类。

479
00:25:16,760 --> 00:25:21,490
>> 所以，当这实际上得到
编译成的SQL语句，

480
00:25:21,490 --> 00:25:24,875
它看起来像这个讨厌的东西下来
在这里，“创建表的学生证整数，

481
00:25:24,875 --> 00:25:26,020
“ 随你。

482
00:25:26,020 --> 00:25:30,002
>> 而且，我认为，这是短，
这个SQL查询就在这里，

483
00:25:30,002 --> 00:25:32,960
但如果你看一下这个类在这里
你可以清楚地看到发生了什么。

484
00:25:32,960 --> 00:25:36,116
你可以看到什么类型的字段
还有，他们是怎么叫，

485
00:25:36,116 --> 00:25:38,115
所以，我认为，
看着这个Python代码

486
00:25:38,115 --> 00:25:43,340
很多比更具可读性
尝试写这个SQL查询。

487
00:25:43,340 --> 00:25:45,990
>> 所以，为了实际
使用该数据库，

488
00:25:45,990 --> 00:25:48,470
我们必须连接到它在Python的。

489
00:25:48,470 --> 00:25:52,770
所以，我平时写一个调用的函数
initialize_db，做两件事情。

490
00:25:52,770 --> 00:25:54,880
它需要在数据库中
对象数据库和它

491
00:25:54,880 --> 00:25:58,360
连接到它，这只是打开
向上部到数据库。

492
00:25:58,360 --> 00:26:00,860
如果你只是运行虽然
网站在本地计算机上，

493
00:26:00,860 --> 00:26:04,320
它不是一个超级大问题担忧
有关连接和断开，

494
00:26:04,320 --> 00:26:06,885
但如果你正在运行
它的网站上，你

495
00:26:06,885 --> 00:26:10,010
要确保，每当用户
连接到它，当他们收出

496
00:26:10,010 --> 00:26:12,270
该网站，断开连接，这样你
没有一堆人连

497
00:26:12,270 --> 00:26:14,480
到数据库的一次。

498
00:26:14,480 --> 00:26:16,370
>> 然后，当你
连接到数据库，

499
00:26:16,370 --> 00:26:20,832
你想打电话db.create_tables，
并列出了模型，你想要什么

500
00:26:20,832 --> 00:26:21,540
创建表。

501
00:26:21,540 --> 00:26:23,950
所以在这里，我只是想
创建了这个学生。

502
00:26:23,950 --> 00:26:28,070
然后，什么是重要的，是要
指定安全=真大部分的时间。

503
00:26:28,070 --> 00:26:30,380
那么，这种说法
会做的，就是它

504
00:26:30,380 --> 00:26:33,580
创建表的
学生模型，但只

505
00:26:33,580 --> 00:26:36,109
如果该表没有
已经创建成功了。

506
00:26:36,109 --> 00:26:37,400
这就是安全的指定。

507
00:26:37,400 --> 00:26:39,150
所以它不会覆盖
您现有的表，

508
00:26:39,150 --> 00:26:41,525
这只会造成新的
表，如果没有一个存在。

509
00:26:41,525 --> 00:26:45,090
所以，你可以只创建
表一旦使用SQL。

510
00:26:45,090 --> 00:26:49,410
再有数据库坐
在那里，然后连接到每一次，

511
00:26:49,410 --> 00:26:52,450
但它通常是不错的只是
把这个create_tables电话，

512
00:26:52,450 --> 00:26:55,550
这样一来，如果你曾经删除
数据库中，当您运行Web

513
00:26:55,550 --> 00:26:57,960
再次应用程序，它会重新创建它。

514
00:26:57,960 --> 00:27:00,730
>> 因此，只要确保安全
被指定为真实的，

515
00:27:00,730 --> 00:27:03,580
或者你只是找到你的数据
越来越重挫每次。

516
00:27:03,580 --> 00:27:06,380
然后，你可以调用
initialize_db建立

517
00:27:06,380 --> 00:27:09,820
一个连接，然后创建
表，如果有必要的。

518
00:27:09,820 --> 00:27:13,150
>> 因此，最常见的事
你会想要做的，

519
00:27:13,150 --> 00:27:15,920
或最常见的事情之一，
是实际插入的东西

520
00:27:15,920 --> 00:27:17,170
到你的数据库。

521
00:27:17,170 --> 00:27:19,430
等，而不是具有
写一个INSERT INTO

522
00:27:19,430 --> 00:27:21,990
所有的声明
的规定值，

523
00:27:21,990 --> 00:27:24,650
实际上你可以调用
功能上的学生类。

524
00:27:24,650 --> 00:27:28,200
所以，当你创建一个类
继承自模型，

525
00:27:28,200 --> 00:27:30,200
它有这个创建方法。

526
00:27:30,200 --> 00:27:33,870
>> 所以，你做的类name.create，
你指定的参数

527
00:27:33,870 --> 00:27:35,260
要通过研究。

528
00:27:35,260 --> 00:27:39,200
所以，如果我想添加一些学生
我们的CS50年级的书为例，

529
00:27:39,200 --> 00:27:41,820
我会在大卫，谁拥有
非常好成绩，他有一个95。

530
00:27:41,820 --> 00:27:45,100
而我自己，谁没有做
如此出色的CS50，我有一个50。

531
00:27:45,100 --> 00:27:47,600
因此，该妙处
这是什么创造功能呢，

532
00:27:47,600 --> 00:27:53,040
是，它返回实例，或
行，它在表内创建的，

533
00:27:53,040 --> 00:27:55,750
所以，你存储在一个
可变的，后来又与它的工作。

534
00:27:55,750 --> 00:27:58,830
你可以改变周围，这
我将展示的一个例子。

535
00:27:58,830 --> 00:28:03,050
>> 请注意，我没有
必须指定ID，

536
00:28:03,050 --> 00:28:09,340
因为既然是
PrimaryKeyField，它会自动

537
00:28:09,340 --> 00:28:10,930
增加它，如果你不指定。

538
00:28:10,930 --> 00:28:12,250
而且，事实上，你可能
不应指定它，

539
00:28:12,250 --> 00:28:14,810
因为你可能会意外地
揍别人的ID。

540
00:28:14,810 --> 00:28:16,830
而你想
确保它是独一无二的。

541
00:28:16,830 --> 00:28:20,662
>> 所以，实际上，最
你想要做平常的事情，

542
00:28:20,662 --> 00:28:22,620
可能是选择了
一旦你的数据库

543
00:28:22,620 --> 00:28:24,078
有大量的信息在里面。

544
00:28:24,078 --> 00:28:27,360
所以，如果你想要得到的一切，
所以选择明星的等效

545
00:28:27,360 --> 00:28:30,940
从学生的说法，它
也只是student.select。

546
00:28:30,940 --> 00:28:34,380
这会给你回一个数组
与所有的学生在里面对象

547
00:28:34,380 --> 00:28:35,770
你遍历你想要的。

548
00:28:35,770 --> 00:28:37,019
你可以得到的东西出来。

549
00:28:37,019 --> 00:28:39,310
而大多数的时候，你
不要只想做选择，

550
00:28:39,310 --> 00:28:40,935
你居然要指定一些东西。

551
00:28:40,935 --> 00:28:44,580
所以，你可以链接
同时这些函数调用，

552
00:28:44,580 --> 00:28:48,830
怎么样，你会链
一起语句在SQL中。

553
00:28:48,830 --> 00:28:53,002
所以，你可以做student.select（）。其中​​，
在这个例子。

554
00:28:53,002 --> 00:28:54,710
然后，你可以
规定的条件，

555
00:28:54,710 --> 00:28:57,880
只是用普通的Python
布尔检查的事情。

556
00:28:57,880 --> 00:29:02,110
>> 因此，在这种情况下，要
限制你选择什么，

557
00:29:02,110 --> 00:29:06,790
其中student.grade等于50，
和student.name等于以斯拉，

558
00:29:06,790 --> 00:29:09,130
这样只会让我离开它。

559
00:29:09,130 --> 00:29:11,340
同时注意，一个人真正
微妙的东西在这里

560
00:29:11,340 --> 00:29:15,570
，如果要指定
一个和/或与一个或/或，

561
00:29:15,570 --> 00:29:19,840
在Python中，你通常会使用，
我认为实际上是“和”字，

562
00:29:19,840 --> 00:29:23,351
但在这里你使用单个号，
这通常是一个按位操作者，

563
00:29:23,351 --> 00:29:25,600
但在这种特殊情况下，
只是peewee的方式这样做，

564
00:29:25,600 --> 00:29:27,660
使用单
符号指定“和”。

565
00:29:27,660 --> 00:29:29,451
在这个时候，
我弄混了很多，

566
00:29:29,451 --> 00:29:32,530
但它不上来
这么多的实践。

567
00:29:32,530 --> 00:29:36,350
>> 然后，一旦你拥有所有的
学生们从数据库中，

568
00:29:36,350 --> 00:29:39,420
一旦你这样做你选择
和你的穿着或什么的，

569
00:29:39,420 --> 00:29:42,334
您可以使用foreach循环，
就像通常的Python语法，

570
00:29:42,334 --> 00:29:44,500
与任何类型的迭代器
或与任何类型的数组。

571
00:29:44,500 --> 00:29:46,333
所以，你可以做的，对于s
在student.select（）。WHE

572
00:29:46,333 --> 00:29:52,930
重（Student.grade <75），并且因此这将
遍历每个学生的表

573
00:29:52,930 --> 00:29:56,260
其等级为小于75，这
在这种情况下，仍然只有我。

574
00:29:56,260 --> 00:29:59,218
然后，你可以做什么东西在
这个循环，就像给我发电子邮件

575
00:29:59,218 --> 00:30:01,680
并告诉我实际
把我的习题集。

576
00:30:01,680 --> 00:30:04,550
>> 所以，另一件事你可以
这样做，是不是真的很容易

577
00:30:04,550 --> 00:30:06,460
更新表内的行。

578
00:30:06,460 --> 00:30:08,720
所以，请记住回到这里，
你当我插入，

579
00:30:08,720 --> 00:30:11,440
我把那价值
通过student.create返回，

580
00:30:11,440 --> 00:30:14,920
我赋予它的名字叫做以斯拉。

581
00:30:14,920 --> 00:30:18,995
所以现在，你可以改变的
该实例中的值，

582
00:30:18,995 --> 00:30:20,870
就像你一个
师范类Python编写的。

583
00:30:20,870 --> 00:30:25,060
>> 所以，你可以设置ezra.grade = 95
将更新本地副本，

584
00:30:25,060 --> 00:30:28,380
但是，如果你真的想
致力于数据库的变化，

585
00:30:28,380 --> 00:30:31,410
你必须调用ezra.save，
所以你所谓的.save方法

586
00:30:31,410 --> 00:30:32,650
在实例。

587
00:30:32,650 --> 00:30:38,085
>> 所以现在，我已经成功地改变
我自己等级的数据库中。

588
00:30:38,085 --> 00:30:41,210
因此，然后让我们说，我被逮住
改变数据库中我的成绩。

589
00:30:41,210 --> 00:30:44,126
马兰教授很可能会
想从类中删除我的，

590
00:30:44,126 --> 00:30:48,630
所以你可以调用.delete
实例方法只是对那件事。

591
00:30:48,630 --> 00:30:51,674
>> 所以，如果你想去
回到这个循环在这里，

592
00:30:51,674 --> 00:30:53,465
实际上，而是
发送电​​子邮件所有

593
00:30:53,465 --> 00:30:56,577
学生的年级少
75，你想删除它们，

594
00:30:56,577 --> 00:30:58,660
在这个循环中，你可以
致电s.delete实例。

595
00:30:58,660 --> 00:31:04,180

596
00:31:04,180 --> 00:31:07,780
而你想做的最后一件事，
就是当你建立连接，

597
00:31:07,780 --> 00:31:10,350
而你与你的工作完成后，
你想打电话db.close，

598
00:31:10,350 --> 00:31:13,190
其中db是数据库
反对我们面前。

599
00:31:13,190 --> 00:31:18,290
而你要确保
一切都被关闭掉的。

600
00:31:18,290 --> 00:31:18,790
>> 凉。

601
00:31:18,790 --> 00:31:22,410
所以，现在，我有一个示例应用程序。

602
00:31:22,410 --> 00:31:26,880
排序我已经预先做好一切只是
使得不会有任何活的编码

603
00:31:26,880 --> 00:31:30,220
失误，但我们可以穿行
，看看你将如何把瓶

604
00:31:30,220 --> 00:31:33,685
和peewee在一起，
并进行简单的应用程序。

605
00:31:33,685 --> 00:31:38,680
我把它叫做CS50咆哮，它的
那种简单的博客平台。

606
00:31:38,680 --> 00:31:41,150
>> 因此，首先，我要运行它，
显示是什么样子，

607
00:31:41,150 --> 00:31:42,890
然后我们就可以更进一步地代码。

608
00:31:42,890 --> 00:32:00,470

609
00:32:00,470 --> 00:32:02,830
好了，我们只是执行这个。

610
00:32:02,830 --> 00:32:14,040

611
00:32:14,040 --> 00:32:17,250
酷，我会让这个
稍微小了一点。

612
00:32:17,250 --> 00:32:20,000
这是不是很漂亮，只是因为
我没有做很多的CSS，

613
00:32:20,000 --> 00:32:23,255
但它的作用是，它有
博客文章该数据库，

614
00:32:23,255 --> 00:32:25,630
并经过所有
它们，并且，将显示它们

615
00:32:25,630 --> 00:32:28,170
在订单的最新的页面。

616
00:32:28,170 --> 00:32:30,920
所以这些都只是一些帖子
我已经保存在数据库中。

617
00:32:30,920 --> 00:32:35,680
>> 所以，如果我们要创建一个新的
文章中，我们可以去添加新帖子，

618
00:32:35,680 --> 00:32:42,720
我们可以进入的称号
后期，所以像，CS50研讨会。

619
00:32:42,720 --> 00:32:45,360

620
00:32:45,360 --> 00:32:46,735
哇，真是享受了研讨会。

621
00:32:46,735 --> 00:32:51,070

622
00:32:51,070 --> 00:32:52,270
>> 凉。

623
00:32:52,270 --> 00:32:56,060
然后你按后，它会
重定向你回到首页，

624
00:32:56,060 --> 00:33:00,039
然后你会看到
最新帖子加入。

625
00:33:00,039 --> 00:33:01,580
而且我们还有所有的人在那里。

626
00:33:01,580 --> 00:33:08,080
所以，现在，让我们来看所有的
代码，看看这是如何实现的。

627
00:33:08,080 --> 00:33:11,995
>> 所以，我认为，我们的第一件事
看看，其实是模型。

628
00:33:11,995 --> 00:33:14,120
很多的时候，
你设计的东西，

629
00:33:14,120 --> 00:33:17,036
你想先说一下是怎么想的
你要表现你的数据，

630
00:33:17,036 --> 00:33:22,915
然后设计围绕这个事情，
让一切都很有意义。

631
00:33:22,915 --> 00:33:25,290
这实际上是我怎么
这样做是当我做这个，

632
00:33:25,290 --> 00:33:28,030
我坐下来，心想：
我该怎么要在后。

633
00:33:28,030 --> 00:33:32,130
>> 所以，在这里，我们有相同的结构
我前面提到，

634
00:33:32,130 --> 00:33:33,755
在这里我们做DB = Sqldatabase（'posts.db“）。

635
00:33:33,755 --> 00:33:37,840

636
00:33:37,840 --> 00:33:40,980
在现实中，你可能不希望
在你的名字的数据库硬编码。

637
00:33:40,980 --> 00:33:43,730
这也许应该是一个参数
一个储存的地方，也许

638
00:33:43,730 --> 00:33:45,940
在配置文件中，但在
一个小例子是这样，

639
00:33:45,940 --> 00:33:48,310
它的好硬编码的研究。

640
00:33:48,310 --> 00:33:53,510
>> 所以，现在，我们有这个Post类，
从基础模型继承。

641
00:33:53,510 --> 00:33:56,930
它具有，再次，所述
ID = PrimaryKeyField。

642
00:33:56,930 --> 00:34:02,250
事实上，如果不指定，
如果我真的摆脱了这一点，

643
00:34:02,250 --> 00:34:07,152
那么peewee我们会照顾
自动创建ID字段，

644
00:34:07,152 --> 00:34:09,360
它会自动
使它的PrimaryKey，这

645
00:34:09,360 --> 00:34:12,485
我觉得是非常好的，因为通常情况下，
这就是你想要拥有的东西，

646
00:34:12,485 --> 00:34:16,239
但我喜欢把它放在具体而言，
只是让我记得它在那里。

647
00:34:16,239 --> 00:34:19,480
但是，如果不指定，
它会自动在那里。

648
00:34:19,480 --> 00:34:22,198
>> 那么，我有个约会其中
是一个DateTimeField字段，并且所有

649
00:34:22,198 --> 00:34:24,864
这些不同的字段，如果
看peewee文档，

650
00:34:24,864 --> 00:34:28,920
它会给你不同的列表
类型，你可以使用领域。

651
00:34:28,920 --> 00:34:34,440
在大多数情况下，它的类似
什么，你会在SQL中看到的。

652
00:34:34,440 --> 00:34:37,699
因此，有一个CharField，一个
VarCharFields，文本域，

653
00:34:37,699 --> 00:34:40,550
这对于非常长的
文本，就像一个博客文章

654
00:34:40,550 --> 00:34:44,460
潜在的，DateTimeFields，
DoubleFields，FloatFields，

655
00:34:44,460 --> 00:34:46,100
所有这样的事情。

656
00:34:46,100 --> 00:34:51,570
>> 你可以通过在其他参数
它，我没有在这里指定。

657
00:34:51,570 --> 00:34:55,719
说，例如，你不想
让两个职位有相同的标题，

658
00:34:55,719 --> 00:34:59,672
你可以指定
像独特= TRUE，

659
00:34:59,672 --> 00:35:02,880
而这仅仅是一个额外的参数
现场，当它编译下来

660
00:35:02,880 --> 00:35:06,865
到SQL，它将指定
它必须是唯一的。

661
00:35:06,865 --> 00:35:09,740
您也可以指定像
不为空，所有其他的事情

662
00:35:09,740 --> 00:35:11,750
你通常做的SQL。

663
00:35:11,750 --> 00:35:16,020
所以，这是一个非常简单的
模型具有的日期。

664
00:35:16,020 --> 00:35:19,460
注意这里，在DateTimeField字段内，
我指定的内容默认为。

665
00:35:19,460 --> 00:35:22,560
我指定它是
datetime.datetime.now，

666
00:35:22,560 --> 00:35:24,920
因为方式
这得到评估，

667
00:35:24,920 --> 00:35:28,750
它实际上评估
该datetime.now时

668
00:35:28,750 --> 00:35:32,110
它被插入到数据库中。

669
00:35:32,110 --> 00:35:34,760
>> 我认为，我有
要仔细检查这一点，

670
00:35:34,760 --> 00:35:38,222
但如果你做了这样的事情，那么
它实际上评估，有一次，

671
00:35:38,222 --> 00:35:40,180
然后将日期时间
将始终是相同的。

672
00:35:40,180 --> 00:35:44,240
所以，只是如果你正在做的事情
有日期时间，仔细检查

673
00:35:44,240 --> 00:35:47,080
，它的评估时，
实际上被插入，否则

674
00:35:47,080 --> 00:35:48,780
你可能会感到困惑。

675
00:35:48,780 --> 00:35:51,221
>> 标题仅仅是一个
CharField，其中有

676
00:35:51,221 --> 00:35:53,970
更多参数可以传递
在指定究竟有多长，你

677
00:35:53,970 --> 00:35:56,170
希望它是，但在这里，
它并没有真正的问题。

678
00:35:56,170 --> 00:35:58,687
而文本将是
整个帖子的文字，

679
00:35:58,687 --> 00:36:01,020
而这将是一个
文本字段只因为你想

680
00:36:01,020 --> 00:36:03,370
允许它是一个相当长的字符串。

681
00:36:03,370 --> 00:36:05,970
>> 然后我们有这个元
子类，只是

682
00:36:05,970 --> 00:36:11,250
指定我们希望数据库
其中，这实际上是开辟成

683
00:36:11,250 --> 00:36:14,267
是，我们在这里的数据库对象。

684
00:36:14,267 --> 00:36:16,350
而过去的事情，我们有
在这里，只是这个功能

685
00:36:16,350 --> 00:36:18,120
我们要去
我们主要的应用程序使用

686
00:36:18,120 --> 00:36:23,970
初始化数据库连接到
它，然后以创建Post表。

687
00:36:23,970 --> 00:36:26,880
>> 现在，让我们来看看在主应用程序本身。

688
00:36:26,880 --> 00:36:30,800
所以，这个人是一个相当
位比那些更长

689
00:36:30,800 --> 00:36:34,840
我们已经看到过，
但希望不是太糟糕。

690
00:36:34,840 --> 00:36:37,140
所以，让我延长了这一点。

691
00:36:37,140 --> 00:36:38,370
好。

692
00:36:38,370 --> 00:36:42,070
>> 因此，注意和顶我进口
一大堆其他东西

693
00:36:42,070 --> 00:36:44,129
从瓶，我们有没有
以前真的见过。

694
00:36:44,129 --> 00:36:46,670
并希望，我们可以通过
这些逐个中的每一个

695
00:36:46,670 --> 00:36:49,420
聊多一点关于
其中，排序的例子。

696
00:36:49,420 --> 00:36:51,380
因此，我们有瓶，
和render_template，

697
00:36:51,380 --> 00:36:54,370
这是我们所见过的，
这个请求对象，

698
00:36:54,370 --> 00:37:00,400
这将拿出当我们看看如何
我是真正展示的形式

699
00:37:00,400 --> 00:37:01,170
作品。

700
00:37:01,170 --> 00:37:04,850
重定向，它可以让您重定向
从创建新邮回

701
00:37:04,850 --> 00:37:11,710
回到原来的网页，然后
URL，这是一件好事，可以让你

702
00:37:11,710 --> 00:37:15,550
找出其中的
网站的某个特定页面。

703
00:37:15,550 --> 00:37:17,810
>> 那么，下一个
我做的事情，是我进口

704
00:37:17,810 --> 00:37:21,550
所有的模型信息
我们只是在看文件。

705
00:37:21,550 --> 00:37:23,140
而且，是的。

706
00:37:23,140 --> 00:37:28,720
>> 所以，别的新自带
当你处理了，

707
00:37:28,720 --> 00:37:31,850
尤其是数据库，
是，你可以指定

708
00:37:31,850 --> 00:37:35,110
一个之前被调用函数
每一个请求，并且功能得到

709
00:37:35,110 --> 00:37:39,690
所谓的每一个请求后，使用此
功能装饰app.before请求。

710
00:37:39,690 --> 00:37:42,324
>> 因此，这将得到执行
无论此功能。

711
00:37:42,324 --> 00:37:44,240
这并不必须是
请求之前调用，

712
00:37:44,240 --> 00:37:46,281
但通常这件事情
理智地调用它。

713
00:37:46,281 --> 00:37:48,580

714
00:37:48,580 --> 00:37:51,650
您可以指定任何功能
你想获得所谓的存在，

715
00:37:51,650 --> 00:37:56,330
所以我指定了该initialize_db
函数，我们在模型有回

716
00:37:56,330 --> 00:38:02,390
文件中，所以每个请求之前，
要连接到数据库。

717
00:38:02,390 --> 00:38:04,560
>> 有两种不同的
方法可以做到这一点。

718
00:38:04,560 --> 00:38:10,830
你可以做@app，我
相信这是after_request。

719
00:38:10,830 --> 00:38:13,800
和之间的差
after_request和teardown_request，

720
00:38:13,800 --> 00:38:17,590
是after_request只会发生
如果请求实际上是有效的。

721
00:38:17,590 --> 00:38:20,440
因此，仅当
请求是成功的，

722
00:38:20,440 --> 00:38:22,490
如果没有出现任何错误，
但teardown_request

723
00:38:22,490 --> 00:38:26,300
发生在一个成功的情况下
请求，或在出现错误的情况。

724
00:38:26,300 --> 00:38:28,252
>> 因此，通常情况下，你想
使用teardown_request，

725
00:38:28,252 --> 00:38:30,460
除非你想做的事
什么东西，特别是不同的

726
00:38:30,460 --> 00:38:31,470
在一个错误的情况下。

727
00:38:31,470 --> 00:38:35,122
但是只是关闭数据库，
无论是成功或失败，

728
00:38:35,122 --> 00:38:37,080
我们要断开
从数据库中。

729
00:38:37,080 --> 00:38:41,240
因此，它被称为，db.close
在数据库对象。

730
00:38:41,240 --> 00:38:43,740
>> 注意，teardown_request
取入一个例外。

731
00:38:43,740 --> 00:38:46,781
所以，你可以检查是否有实际
一个错误，当它被关闭了，

732
00:38:46,781 --> 00:38:49,390
但在这里，有希望，有
是不是一大堆的错误，

733
00:38:49,390 --> 00:38:52,720
排序，所以我们只是忽略了。

734
00:38:52,720 --> 00:38:55,990
>> 好了，和它的其余部分是不是太糟糕。

735
00:38:55,990 --> 00:39:02,240
所以，当我们去到首页，
我们提供的这个home.html的模板

736
00:39:02,240 --> 00:39:03,490
这将打开。

737
00:39:03,490 --> 00:39:06,240
该过程在后
等于，而这是什么

738
00:39:06,240 --> 00:39:10,260
确实是，还记得我们有这个职位
模型，所以我们选择所有的帖子，

739
00:39:10,260 --> 00:39:13,890
然后另一件事可以做，
您可以指定WHERE子句，

740
00:39:13,890 --> 00:39:16,910
你可以指定一个
按顺序，所以我们采取

741
00:39:16,910 --> 00:39:18,820
所有的帖子说
得到选中，然后

742
00:39:18,820 --> 00:39:22,590
我们为了他们的
post.date.descending。

743
00:39:22,590 --> 00:39:25,030
当这将指定，
他们居然出来了，

744
00:39:25,030 --> 00:39:29,250
最近的一次
会很第一个。

745
00:39:29,250 --> 00:39:31,420
>> 然后，我们传递到
在home.html做为模板，

746
00:39:31,420 --> 00:39:34,240
让我们实际打开了
该模板的真快，

747
00:39:34,240 --> 00:39:36,760
并看看怎么说的工作。

748
00:39:36,760 --> 00:39:42,130
这是不是伟大的HTML，但
希望我们能够专注于Python的。

749
00:39:42,130 --> 00:39:46,960
>> 因此，有一个链接添加新
邮政，因此这个指定路线

750
00:39:46,960 --> 00:39:51,580
在烧瓶内，我们
定义，这是在这里。

751
00:39:51,580 --> 00:39:56,310
这是新的布线后，
我们在这里指定了起来。

752
00:39:56,310 --> 00:40:00,450
所以这是一个链接，然后去
向该烧瓶服务器内的路由。

753
00:40:00,450 --> 00:40:03,820
>> 更有趣的事情
是这样的循环在这里。

754
00:40:03,820 --> 00:40:07,685
因此，我们指定该
帖子参数，

755
00:40:07,685 --> 00:40:09,560
通入
render_template功能，

756
00:40:09,560 --> 00:40:13,550
在这篇文章的每一个岗位
获取传递的对象。

757
00:40:13,550 --> 00:40:16,600
我们要打印出
文章标题，上半年，

758
00:40:16,600 --> 00:40:21,930
再下面，我们要打印出
一个段落中的文字后。

759
00:40:21,930 --> 00:40:25,710
>> 在这里，我们实际上可以
调用Python函数，

760
00:40:25,710 --> 00:40:35,130
因此，我们可以调用的strftime，ST-RF-时间，
您可以通过在格式字符串

761
00:40:35,130 --> 00:40:37,064
要打印出来的数据研究。

762
00:40:37,064 --> 00:40:39,980
所以它是相当不错的，你可以
实际上调用这个Python函数

763
00:40:39,980 --> 00:40:41,090
从内部在这里。

764
00:40:41,090 --> 00:40:44,370
你不必做格式上
控制器方面，因为说真的，

765
00:40:44,370 --> 00:40:47,770
格式化的日期是什么，
你要处理的视图中。

766
00:40:47,770 --> 00:40:51,480
>> 而所有这些百分比
事情是不是超级重要。

767
00:40:51,480 --> 00:40:55,270
如果您查找文档
在Python中的strftime函数，

768
00:40:55,270 --> 00:40:57,040
它指定所有这些
的事情，但是这

769
00:40:57,040 --> 00:40:59,190
怎么样，当我们正在寻找
在此间举行的首页，

770
00:40:59,190 --> 00:41:04,440
它格式化这个一个不错的
迄今为止，它指定上午或下午，

771
00:41:04,440 --> 00:41:09,410
但通常，如果我们
没有这个这里，

772
00:41:09,410 --> 00:41:14,024
你可能会得到一些垃圾
日期没有看起来非常好。

773
00:41:14,024 --> 00:41:15,940
然后我们指定
post.text，我可以

774
00:41:15,940 --> 00:41:19,460
已经把几个
换行符在这里，只

775
00:41:19,460 --> 00:41:21,820
把一些空间各岗位之间。

776
00:41:21,820 --> 00:41:26,270
>> 所以，我认为最重要的
在本实施例的东西，

777
00:41:26,270 --> 00:41:28,697
是，你可以使用这个循环。

778
00:41:28,697 --> 00:41:30,780
这类似于
事情可以在PHP做。

779
00:41:30,780 --> 00:41:32,905
您可以遍历，
一切都被传递，

780
00:41:32,905 --> 00:41:36,719
而不必等，做
复制/粘贴，复制/粘贴所有的HTML，

781
00:41:36,719 --> 00:41:40,010
你只需要编写一次，然后
你可以遍历所有的职位。

782
00:41:40,010 --> 00:41:41,510
>> 而这是后话
常见的要

783
00:41:41,510 --> 00:41:44,510
这样做，当你有大量的数据，
是，一切都在你的数据，

784
00:41:44,510 --> 00:41:48,370
你想要做类似的事情。

785
00:41:48,370 --> 00:41:51,690
然后，只记得，当你
要明确地打印出的东西

786
00:41:51,690 --> 00:41:54,780
在HTML，您使用
这里的双重支撑，

787
00:41:54,780 --> 00:41:57,820
但是当你想指定
关于条件的一些信息，

788
00:41:57,820 --> 00:42:02,430
或者约一个for循环，你
使用百分比支架。

789
00:42:02,430 --> 00:42:08,730
>> 所以，要回了Python
代码，以便解释

790
00:42:08,730 --> 00:42:12,242
发生了什么主
路线，当我们去那里，

791
00:42:12,242 --> 00:42:14,450
它只是显示所有
的帖子，但随后的问题

792
00:42:14,450 --> 00:42:17,440
是，我们如何真正得到
帖子到数据库中，这

793
00:42:17,440 --> 00:42:18,970
更有意思一点。

794
00:42:18,970 --> 00:42:23,960
>> 所以，当你点击新
帖子的链接，这是我们在这里看到，

795
00:42:23,960 --> 00:42:26,000
这将您重定向到这种形式。

796
00:42:26,000 --> 00:42:29,580
而这对只是一个简单的通话
render_template功能，然后

797
00:42:29,580 --> 00:42:32,110
在HTML表单的新职位通过。

798
00:42:32,110 --> 00:42:36,212
因此，让我们来看看这一点。

799
00:42:36,212 --> 00:42:37,420
所以这一块是非常简单的。

800
00:42:37,420 --> 00:42:45,110
它有一个简单的HTML表单，其中
看起来有点眼熟，

801
00:42:45,110 --> 00:42:47,380
基于表单的CS50融资。

802
00:42:47,380 --> 00:42:49,940
因此，我们在这里指定的动作。

803
00:42:49,940 --> 00:42:52,435
在这里，如果你的工作
用PHP，通常情况下，

804
00:42:52,435 --> 00:42:55,930
会是这样，
create.PHP，但在这里

805
00:42:55,930 --> 00:42:59,960
我们实际上指定路由
内瓶服务器。

806
00:42:59,960 --> 00:43:02,520
因此，这条线路对应
以创建路线

807
00:43:02,520 --> 00:43:05,680
我们这里有，这
我们将进入在第二。

808
00:43:05,680 --> 00:43:07,630
>> 因此，我们指定
这是一个POST方法，

809
00:43:07,630 --> 00:43:09,820
因为我们想送
这种形式的数据，通常

810
00:43:09,820 --> 00:43:12,945
当你从一个表单发送数据，
你可能想使用POST请求，

811
00:43:12,945 --> 00:43:15,760
只是，这样你就不会结束
这个大，笨重的URL。

812
00:43:15,760 --> 00:43:18,970
但你也可以使用一个GET请求，
和可变路由通过它，

813
00:43:18,970 --> 00:43:21,170
但对于形式，这是很好
在这里POST请求。

814
00:43:21,170 --> 00:43:24,620
因此然后，就像你
将与HTML和PHP做的，

815
00:43:24,620 --> 00:43:28,420
也可把这些文字输入，
并且可以指定他们的名字，

816
00:43:28,420 --> 00:43:33,490
而这，将获得通过的名称
入内瓶的请求对象。

817
00:43:33,490 --> 00:43:36,960
>> 然后我们有一个提交
按钮后说。

818
00:43:36,960 --> 00:43:40,760
在这里，帖子是的名称
按钮，因为它是一个博客帖子，

819
00:43:40,760 --> 00:43:42,700
但在这里，职位要求的方法。

820
00:43:42,700 --> 00:43:47,060
因此，这些都是相同的字
但实际上无关。

821
00:43:47,060 --> 00:43:48,460
是啊

822
00:43:48,460 --> 00:43:54,800
>> 让我们再回到Python代码，
当我们调用create方法，

823
00:43:54,800 --> 00:43:57,702
注意在这里，你可以
实际的路线中指定

824
00:43:57,702 --> 00:44:00,650
请求方法
要接受，

825
00:44:00,650 --> 00:44:04,770
所以在这里，我指定我
只希望接受POST方法。

826
00:44:04,770 --> 00:44:09,800
所以，如果我实际尝试访问的页面
直接，这是使用GET请求，

827
00:44:09,800 --> 00:44:11,700
它会告诉我“不允许的方法。”

828
00:44:11,700 --> 00:44:15,840
>> 所以，你的页面，有点像
这个创建页面，我只是

829
00:44:15,840 --> 00:44:20,192
真正使用的一种方式
的形式得到提交，

830
00:44:20,192 --> 00:44:22,900
你可以指定不
希望人们能够去那里

831
00:44:22,900 --> 00:44:25,650
直接通过GET请求，
或者，如果你不想，

832
00:44:25,650 --> 00:44:28,580
出于某种原因，一个Post请求，
你可以只指定到这里，

833
00:44:28,580 --> 00:44:32,720
但在这个例子中，我们只
想POST请求出去。

834
00:44:32,720 --> 00:44:38,700
>> 所以，当create_post被调用，当
我们参观了经发布采购信息，

835
00:44:38,700 --> 00:44:43,600
当你去一个特定的
路线，有此请求对象，

836
00:44:43,600 --> 00:44:46,640
我们不得不进口
在最高层的要求，

837
00:44:46,640 --> 00:44:49,640
但有此要求
获取传递的对象，

838
00:44:49,640 --> 00:44:53,210
您可以访问表单数据，
它会自动得到填补

839
00:44:53,210 --> 00:44:55,070
当您发送从形式的请求。

840
00:44:55,070 --> 00:44:56,990
>> 然后，我认为
是真的很酷，是

841
00:44:56,990 --> 00:45:02,840
即获得通过表单对象
在，就是一个Python字典，

842
00:45:02,840 --> 00:45:10,560
包含，如果你所以这里access--，让
我拉起HTML旁边，只是

843
00:45:10,560 --> 00:45:17,670
这样你就可以有
作为参考，是的，所以

844
00:45:17,670 --> 00:45:21,060
我们在这里指定的名称
对于不同的领域，所以

845
00:45:21,060 --> 00:45:23,900
标题和文字中，我们
然后只使用那些在这里

846
00:45:23,900 --> 00:45:27,110
作为索引到表单中的数据。

847
00:45:27,110 --> 00:45:28,950
所以这是超级方便。

848
00:45:28,950 --> 00:45:33,320
>> 于是，我们称之为post.create，这
将创建并自动插入

849
00:45:33,320 --> 00:45:36,850
这个新职位的对象到数据库中。

850
00:45:36,850 --> 00:45:40,690
而且我觉得这创造功能
这里是如何一个非常酷的例子

851
00:45:40,690 --> 00:45:44,900
强大的烧瓶中，并与该工作，
因为如果你做的事情

852
00:45:44,900 --> 00:45:48,660
在PHP中，您可能需要
做验证了很多，

853
00:45:48,660 --> 00:45:51,730
你必须再
建立数据库连接，

854
00:45:51,730 --> 00:45:55,210
你必须再
执行SQL查询，

855
00:45:55,210 --> 00:45:59,550
但在这里，我们只是有这个漂亮
post.create，然后我们可以只

856
00:45:59,550 --> 00:46:01,520
获取信息了
请求的对象，

857
00:46:01,520 --> 00:46:05,370
然后把它传递到一个新的
发布，我们正在创造。

858
00:46:05,370 --> 00:46:07,850
>> 然后，在最后的
我们想要做的事情，

859
00:46:07,850 --> 00:46:09,630
是重定向
用户返回到家庭。

860
00:46:09,630 --> 00:46:13,020
因此，我们用这个
瓶重定向功能。

861
00:46:13,020 --> 00:46:17,770
而一些我们还没有看到
之前，是该URL的功能。

862
00:46:17,770 --> 00:46:21,970
所以，网址功能让
你通过在实际上名字

863
00:46:21,970 --> 00:46:26,090
在Python代码的函数，
而不是特定路线

864
00:46:26,090 --> 00:46:26,720
它是在。

865
00:46:26,720 --> 00:46:32,107
>> 所以，我可以很容易地
重定向用户大幅削减，

866
00:46:32,107 --> 00:46:37,050
这将发送回了家，但
使用URL的功能是好的，

867
00:46:37,050 --> 00:46:39,990
因为如果你改变
位置那里的东西，

868
00:46:39,990 --> 00:46:44,080
所以我们说，我改变
家是在/ home上，而不是，

869
00:46:44,080 --> 00:46:47,040
这仍然然后返回/主页，
因为实际上去，抬头

870
00:46:47,040 --> 00:46:50,770
函数的名称，并且它
会还给你的网址为。

871
00:46:50,770 --> 00:46:52,490
>> 因此，对排序
假设你

872
00:46:52,490 --> 00:46:55,489
更容易改变那里的东西
是，比的函数的名称。

873
00:46:55,489 --> 00:46:58,840
您可以使用此真
漂亮的URL的功能。

874
00:46:58,840 --> 00:47:02,470
还有一件事要注意的
这是一个有点棘手，

875
00:47:02,470 --> 00:47:05,750
是，你认为你可以只
呼叫重定向的URL，

876
00:47:05,750 --> 00:47:10,600
但实际上所有的航线都
回到某种形式的文本和HTML，

877
00:47:10,600 --> 00:47:14,360
所以你确实有
返回重定向呼叫。

878
00:47:14,360 --> 00:47:18,379
否则，你会得到什么
关于无效不返回一个字符串，

879
00:47:18,379 --> 00:47:21,420
因为所有这些都返回
在HTML你真的想渲染。

880
00:47:21,420 --> 00:47:26,980
>> 所以，当你调用的重定向，
它会将您重定向到页面，

881
00:47:26,980 --> 00:47:30,270
但它实际上返回的HTML
您需要执行重定向。

882
00:47:30,270 --> 00:47:34,430

883
00:47:34,430 --> 00:47:37,110
返回到主页。

884
00:47:37,110 --> 00:47:39,200
因此，我们有两种不同的看法。

885
00:47:39,200 --> 00:47:40,132
我们的主视图。

886
00:47:40,132 --> 00:47:41,590
或者，我想我应该说的模板。

887
00:47:41,590 --> 00:47:44,190
我们有这两个模板，
家里模板，

888
00:47:44,190 --> 00:47:48,500
显示了我们所有的岗位，
那么，我们有这个广告的事情，

889
00:47:48,500 --> 00:47:52,970
当你点击后，它会
向该烧瓶内的新路线，

890
00:47:52,970 --> 00:47:55,920
但是这条路并不一定
有一个相应的模板。

891
00:47:55,920 --> 00:47:59,290

892
00:47:59,290 --> 00:48:01,560
你没有看到
任何东西，但你仍然可以

893
00:48:01,560 --> 00:48:04,090
有这样的工作会
幕后。

894
00:48:04,090 --> 00:48:07,450
然后你重定向
回到主页。

895
00:48:07,450 --> 00:48:12,230
绝对，很容易合作
在一些更好的CSS到模板

896
00:48:12,230 --> 00:48:15,580
，使这个看起来要好很多，
但所有的主逻辑

897
00:48:15,580 --> 00:48:18,590
有没有在Python。

898
00:48:18,590 --> 00:48:20,020
>> 关于这个例子有问题吗？

899
00:48:20,020 --> 00:48:22,760
我知道有很多
不同的东西对那里发生的，

900
00:48:22,760 --> 00:48:25,341
很多东西我们还没有看到
之前，但像什么。

901
00:48:25,341 --> 00:48:25,840
是啊。

902
00:48:25,840 --> 00:48:28,346
>> 听众1：你有没有做任何事情
特别擦洗这是该数据

903
00:48:28,346 --> 00:48:29,600
从表单来了呢？

904
00:48:29,600 --> 00:48:31,109
我注意到你刚才说的“创造”

905
00:48:31,109 --> 00:48:33,900
EZRA ZIGMOND：是啊，所以这是
实际上，这是一个非常好的点。

906
00:48:33,900 --> 00:48:36,350
所以现在的问题是，你
需要检查并确保

907
00:48:36,350 --> 00:48:39,190
该数据是有效的，并
做任何形式的洗刷

908
00:48:39,190 --> 00:48:41,840
以确保它是有效的，
因为你可以在这里看到，

909
00:48:41,840 --> 00:48:42,660
我没有这样做。

910
00:48:42,660 --> 00:48:48,140
因此，让我们看看会发生什么
如果我发布一些空白。

911
00:48:48,140 --> 00:48:51,190
因此，它会实际上只是做一个
空白后并填写日期时间。

912
00:48:51,190 --> 00:48:55,990
>> 因此，在现实中，可能会
想要做这样的事情，

913
00:48:55,990 --> 00:49:04,749
也许注明标题等于
空字符串，那么不这样做。

914
00:49:04,749 --> 00:49:07,290
或者说，只有这样做，如果标题是
不等于空字符串。

915
00:49:07,290 --> 00:49:10,330
因此，它实际上并没有自动
采取洗涤护理

916
00:49:10,330 --> 00:49:12,820
为你，所以你仍然需要做的。

917
00:49:12,820 --> 00:49:14,330
是啊，好问题。

918
00:49:14,330 --> 00:49:18,497
>> 读者2：它是否磨砂
对于续集注射？

919
00:49:18,497 --> 00:49:19,890
你知道吗？

920
00:49:19,890 --> 00:49:22,830
>> EZRA ZIGMOND：希望，
peewee做到这一点。

921
00:49:22,830 --> 00:49:25,830
我想，这肯定会是一个相当
糟糕的图书馆，如果它没有这样做。

922
00:49:25,830 --> 00:49:29,511

923
00:49:29,511 --> 00:49:32,690
我不知道到底。

924
00:49:32,690 --> 00:49:34,820
我不得不看
查询，它生成的。

925
00:49:34,820 --> 00:49:38,980
我想，如果我输入一个
博客文章的排序，看起来

926
00:49:38,980 --> 00:49:46,370
像SQL注入攻击，
这样的事情，如果这

927
00:49:46,370 --> 00:49:49,370
就像一个密码字段什么的，
你可能会做这样的事情。

928
00:49:49,370 --> 00:49:53,410
>> 我认为，还是会
获得字面贴，

929
00:49:53,410 --> 00:49:59,200
但我认为peewee不会做
某种擦洗数据的

930
00:49:59,200 --> 00:50:01,680
之前，它实际上执行它。

931
00:50:01,680 --> 00:50:04,510
>> 听众1：文本字段
设计上采用纯文本，对不对？

932
00:50:04,510 --> 00:50:05,710
>> EZRA ZIGMOND：是啊，这是。

933
00:50:05,710 --> 00:50:06,465
是啊。

934
00:50:06,465 --> 00:50:09,590
因此，我认为所有的，所以这是
正确的行为，这将做到这一点，

935
00:50:09,590 --> 00:50:12,170
但我认为，peewee
希望不会做

936
00:50:12,170 --> 00:50:13,780
保护对他们的最终某种。

937
00:50:13,780 --> 00:50:16,090
如果你想
仔细检查，有

938
00:50:16,090 --> 00:50:19,530
是当你生成一个查询方式。

939
00:50:19,530 --> 00:50:22,622
这样你就不必
直接执行它。

940
00:50:22,622 --> 00:50:24,330
我不得不采取
看文件，

941
00:50:24,330 --> 00:50:27,930
但实际上你可以查看
SQL它产生，

942
00:50:27,930 --> 00:50:30,840
并看看这一点，使
确保其逃避的东西。

943
00:50:30,840 --> 00:50:33,700
>> 另一个原因，你可能
想看看SQL

944
00:50:33,700 --> 00:50:37,920
这peewee的输出，是，如果
事情似乎得很慢，

945
00:50:37,920 --> 00:50:41,090
你可以看看，看看它的
其实这样做，因为它有时

946
00:50:41,090 --> 00:50:44,670
容易意外增加
在，你的方式写出来，

947
00:50:44,670 --> 00:50:47,880
你可以不小心把它
首先选择整个数据库，

948
00:50:47,880 --> 00:50:50,230
然后做一些操作
上，真当你

949
00:50:50,230 --> 00:50:51,320
为了选择一个子集。

950
00:50:51,320 --> 00:50:53,560
>> 所以，如果事情不
相当在朝好的方向发展，

951
00:50:53,560 --> 00:50:57,300
这是很好的看一看的要求
这实际上是如何产生的。

952
00:50:57,300 --> 00:50:57,800
是啊。

953
00:50:57,800 --> 00:51:02,100
>> 读者2：当你第一次开始，
你把端口为5000。

954
00:51:02,100 --> 00:51:02,904
>> EZRA ZIGMOND：是的。

955
00:51:02,904 --> 00:51:06,070
读者2：是用peewee默认，
或者是一些可以改变？

956
00:51:06,070 --> 00:51:10,870
EZRA ZIGMOND：是的，所以
默认情况下是用瓶端口。

957
00:51:10,870 --> 00:51:13,061
如果你运行它，而不
指定任何东西，

958
00:51:13,061 --> 00:51:14,310
它会自动做到这一点。

959
00:51:14,310 --> 00:51:16,060
我相信，我有
要仔细检查这一点，

960
00:51:16,060 --> 00:51:19,130
但可以指定在app.run，
我想你可以做这样的事情，

961
00:51:19,130 --> 00:51:19,629
端口= 8080。

962
00:51:19,629 --> 00:51:22,375

963
00:51:22,375 --> 00:51:23,750
让我们给一个尝试真正的快。

964
00:51:23,750 --> 00:51:29,100

965
00:51:29,100 --> 00:51:32,230
是啊，所以你可以只指定
端口= 8080，它将在它上面运行，

966
00:51:32,230 --> 00:51:36,130
我认为，如果你想运行
在IDE中，我没有尝试过这一点，

967
00:51:36,130 --> 00:51:38,527
但我认为，如果你
跑了8080端口，

968
00:51:38,527 --> 00:51:40,360
你可能能
访问服务器，

969
00:51:40,360 --> 00:51:41,870
就像你的网站。

970
00:51:41,870 --> 00:51:44,390
>> 是的，但它很容易
改变这种状况，如果你

971
00:51:44,390 --> 00:51:48,540
任何有点像端口转发
你需要做的事情。

972
00:51:48,540 --> 00:51:50,410
>> 其他问题吗？

973
00:51:50,410 --> 00:51:50,916
是吗？

974
00:51:50,916 --> 00:51:53,416
听众1：所以，我看到了你
是，正如你所提到的机型，

975
00:51:53,416 --> 00:51:55,647
你必须指定
数据库为每个对象。

976
00:51:55,647 --> 00:51:58,105
你可知道，做
这使得如果你真的很容易

977
00:51:58,105 --> 00:52:03,210
有很多的SQLite数据库，你
要使用一个单一的Web应用程序，

978
00:52:03,210 --> 00:52:07,210
那你可以指定一组
不同的人在模型？

979
00:52:07,210 --> 00:52:11,620
>> EZRA ZIGMOND：是啊，让我
打开了真正的快。

980
00:52:11,620 --> 00:52:17,570
所以，你说，如果你想拥有
一堆不同的东西，也许

981
00:52:17,570 --> 00:52:22,670
喜欢和同学们，对于一些
因此，这样的事情？

982
00:52:22,670 --> 00:52:26,870
是啊，所以我认为，
你还在，每个模型

983
00:52:26,870 --> 00:52:30,652
必须仍然有刚
分配给它的一个数据库，

984
00:52:30,652 --> 00:52:32,610
但如果你想有
不同的模式，

985
00:52:32,610 --> 00:52:35,818
分配了不同的数据库对象
它，你肯定可以做到这一点。

986
00:52:35,818 --> 00:52:43,070
所以，如果我创建了一个新的，
这样的事情，

987
00:52:43,070 --> 00:52:47,000
现在这是一个学生的
看起来奇怪的是像博客文章，

988
00:52:47,000 --> 00:52:49,390
我可以指定
数据库等于这里db_2。

989
00:52:49,390 --> 00:52:51,390
所以，我认为这是
主要的方式，你可以做到这一点。

990
00:52:51,390 --> 00:52:54,560

991
00:52:54,560 --> 00:52:56,200
>> 凉。

992
00:52:56,200 --> 00:52:58,410
其他问题吗？

993
00:52:58,410 --> 00:53:02,170
>> 所以，刚完成了一个小
位，这里有一些资源，

994
00:53:02,170 --> 00:53:06,030
这些幻灯片将在网上公布
这样你就可以真正得到这些链接。

995
00:53:06,030 --> 00:53:08,500
最好的资源是真的
对于瓶文档

996
00:53:08,500 --> 00:53:09,930
和peewee自己。

997
00:53:09,930 --> 00:53:12,940
他们写的非常好，我想。

998
00:53:12,940 --> 00:53:18,180
所以，该瓶网站在这里，并且
他们有一个快速入门教程

999
00:53:18,180 --> 00:53:20,710
将穿行类似
事情是我走过，

1000
00:53:20,710 --> 00:53:23,560
但如果你想要的任何形式的审查
那我走过去的事情，

1001
00:53:23,560 --> 00:53:26,200
或者你认为我解释
东西在一个混乱的方式，

1002
00:53:26,200 --> 00:53:28,390
他们将有类似的例子还有。

1003
00:53:28,390 --> 00:53:31,570
>> Peewee有文档，以及
他们有一个快速入门教程

1004
00:53:31,570 --> 00:53:34,650
即越过主要参数
您可能需要使用。

1005
00:53:34,650 --> 00:53:38,900
所以，这个事情我谈到了与
独特的，并指定默认值，

1006
00:53:38,900 --> 00:53:42,710
不同种类领域的
您可以使用，这些都将是那里。

1007
00:53:42,710 --> 00:53:44,690
>> 此外，如果你有
关于peewee问题，

1008
00:53:44,690 --> 00:53:47,530
并在发布的计算器，
谁做peewee实际的家伙

1009
00:53:47,530 --> 00:53:49,500
接着，有时回答这些。

1010
00:53:49,500 --> 00:53:53,200
如果你有任何问题，希望
他将能够回答这个问题，

1011
00:53:53,200 --> 00:53:54,867
因为他写了整个事情。

1012
00:53:54,867 --> 00:53:56,700
我认为这是一切
我想覆盖。

1013
00:53:56,700 --> 00:53:58,930
谢谢出来。

1014
00:53:58,930 --> 00:54:02,688