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