1
00:00:00,000 --> 00:00:00,750

2
00:00:00,750 --> 00:00:09,800
>> [音樂播放]

3
00:00:09,800 --> 00:00:13,014

4
00:00:13,014 --> 00:00:13,680
DUSTIN TRAN：你好。

5
00:00:13,680 --> 00:00:14,980
我的名字的達斯汀。

6
00:00:14,980 --> 00:00:18,419
所以我會介紹
在R.數據分析

7
00:00:18,419 --> 00:00:19,710
我自己只是一點點。

8
00:00:19,710 --> 00:00:24,320
我目前的研究生
該工程與應用科學。

9
00:00:24,320 --> 00:00:28,330
我研究的交集
機器學習和統計

10
00:00:28,330 --> 00:00:31,375
因此在研發數據分析
真正的基礎是什麼

11
00:00:31,375 --> 00:00:33,790
我每天。

12
00:00:33,790 --> 00:00:35,710
>> R是特別
良好的數據分析

13
00:00:35,710 --> 00:00:39,310
因為它是非常好的原型。

14
00:00:39,310 --> 00:00:43,590
通常，當你做一些
數據分析，很多的問題的

15
00:00:43,590 --> 00:00:44,920
要認知。

16
00:00:44,920 --> 00:00:48,700
所以你只是想有
一些很好的語言

17
00:00:48,700 --> 00:00:53,770
是做剛剛好
內置函數，而不是

18
00:00:53,770 --> 00:00:57,430
具有處理低電平的東西。

19
00:00:57,430 --> 00:01:01,040
所以，在開始的時候，我只是去
介紹什麼是R，為什麼會

20
00:01:01,040 --> 00:01:04,540
要使用它，
然後去到過的一些演示，

21
00:01:04,540 --> 00:01:07,060
而只是去從那裡。

22
00:01:07,060 --> 00:01:08,150
>> 那麼，什麼是R'

23
00:01:08,150 --> 00:01:11,180
R的只是一個語言開發
統計計算

24
00:01:11,180 --> 00:01:12,450
和可視化。

25
00:01:12,450 --> 00:01:16,000
所以，這是什麼意思的是，
這是一個非常優秀的語言

26
00:01:16,000 --> 00:01:22,400
對於與處理任何諸如此類的事情
不確定或數據可視化。

27
00:01:22,400 --> 00:01:24,850
所以，你擁有所有這些
概率分佈。

28
00:01:24,850 --> 00:01:27,140
有將要
內置函數。

29
00:01:27,140 --> 00:01:31,650
你也將有出色
繪圖包。

30
00:01:31,650 --> 00:01:34,110
>> Python是互相競爭
語言數據。

31
00:01:34,110 --> 00:01:40,020
還有一件事，我覺得是R
為更好的為可視化。

32
00:01:40,020 --> 00:01:45,200
所以你會在演示照見
也僅僅是一個很直觀的語言

33
00:01:45,200 --> 00:01:48,050
這只是工作得非常好。

34
00:01:48,050 --> 00:01:53,140
它也是免費和開源的，因為
是什麼好語言，我猜。

35
00:01:53,140 --> 00:01:55,440
>> 在這裡，一堆剛
關鍵字扔向你。

36
00:01:55,440 --> 00:02:00,450
它是動態的，這意味著如果你有一個
分配到一個對象的特定類型

37
00:02:00,450 --> 00:02:02,025
比將只在飛行修改。

38
00:02:02,025 --> 00:02:05,670
這是懶惰所以它的聰明
它是如何做計算。

39
00:02:05,670 --> 00:02:12,250
功能意味著它可以真正操作
基於關閉功能等anything--

40
00:02:12,250 --> 00:02:16,910
任何形式的操縱你
這樣做，它會根據關功能。

41
00:02:16,910 --> 00:02:20,162
>> 所以二元運算符，例如，
只是固有的功能。

42
00:02:20,162 --> 00:02:21,870
和一切
你要做的是

43
00:02:21,870 --> 00:02:24,690
將要流掉函數本身。

44
00:02:24,690 --> 00:02:27,140
然後面向對象的為好。

45
00:02:27,140 --> 00:02:30,930
>> 因此，這裡是一個XKCD情節。

46
00:02:30,930 --> 00:02:34,350
這不僅是因為我覺得自己像
XKCD是至關重要的任何形式

47
00:02:34,350 --> 00:02:37,770
介紹的，但由於
我喜歡這種感覺真的

48
00:02:37,770 --> 00:02:42,160
錘點，很多的
當你正在做一些數據的時間

49
00:02:42,160 --> 00:02:46,570
分析，問題是不
與其說它運行的速度有多快，

50
00:02:46,570 --> 00:02:49,850
不過多久，它會
帶你到編程任務。

51
00:02:49,850 --> 00:02:54,112
所以這裡只是分析是否
策略a或b是更有效的。

52
00:02:54,112 --> 00:02:55,820
這將是
你是什​​麼

53
00:02:55,820 --> 00:02:58,290
要處理很多在
那種低層次的語言

54
00:02:58,290 --> 00:03:03,440
在那裡你正在處理的賽格故障，
內存分配，初始化，

55
00:03:03,440 --> 00:03:05,270
甚至使內置函數。

56
00:03:05,270 --> 00:03:09,920
而這個東西是所有處理
非常，非常優雅的R.

57
00:03:09,920 --> 00:03:12,839
>> 所以只是這一錘
點，最大的瓶頸

58
00:03:12,839 --> 00:03:13,880
將是認知。

59
00:03:13,880 --> 00:03:17,341
這樣的數據分析是一個非常困難的問題。

60
00:03:17,341 --> 00:03:19,340
無論你正在做的
機器學習或者你

61
00:03:19,340 --> 00:03:22,550
這樣做只是某種
基本數據探索，

62
00:03:22,550 --> 00:03:25,290
你不希望有
取一個文件

63
00:03:25,290 --> 00:03:27,440
然後編譯
每一次你的東西

64
00:03:27,440 --> 00:03:31,010
想看看一列的樣子，
什麼特定的條​​目以矩陣

65
00:03:31,010 --> 00:03:32,195
看起來像。

66
00:03:32,195 --> 00:03:34,320
所以，你只是想有
一些非常漂亮的界面

67
00:03:34,320 --> 00:03:37,740
您可以運行一個簡單的函數
該指數的任何

68
00:03:37,740 --> 00:03:41,870
你想從那裡只要運行它。

69
00:03:41,870 --> 00:03:44,190
你需要域名
特定語言這一點。

70
00:03:44,190 --> 00:03:51,750
和R將真正幫助你定義
問題和解決它以這種方式。

71
00:03:51,750 --> 00:03:58,690
>> 因此，這裡是顯示編程
的R普及，因為它走了一段時間。

72
00:03:58,690 --> 00:04:04,060
所以你可以看到，像2013年或
所以它只是炸毀了極大。

73
00:04:04,060 --> 00:04:09,570
這一直只是因為
在科技產業的巨大發展趨勢

74
00:04:09,570 --> 00:04:10,590
關於大數據。

75
00:04:10,590 --> 00:04:13,010
另外，不只是該技術
行業，但真正

76
00:04:13,010 --> 00:04:16,490
任何行業that--因為
很多行業

77
00:04:16,490 --> 00:04:20,589
是那種根本
試圖解決這些問題。

78
00:04:20,589 --> 00:04:24,590
通常，你可以有一些不錯的
測量這些問題的方式

79
00:04:24,590 --> 00:04:29,720
甚至定義它們或
利用數據解決這些問題。

80
00:04:29,720 --> 00:04:35,430
所以我覺得現在R是第11
在TIOBE最流行的語言

81
00:04:35,430 --> 00:04:38,200
和它的增長至今。

82
00:04:38,200 --> 00:04:40,740

83
00:04:40,740 --> 00:04:43,080
>> 因此，這裡的一些
R的特點，具有

84
00:04:43,080 --> 00:04:46,900
包的巨大數量和
所有這些不同的東西。

85
00:04:46,900 --> 00:04:52,470
所以，任何時候你有一個
某些問題，最

86
00:04:52,470 --> 00:04:55,060
時間R將有
該功能為您服務。

87
00:04:55,060 --> 00:04:58,520
因此，無論你想
建立某種機

88
00:04:58,520 --> 00:05:02,770
所謂的學習算法
隨機森林或決策樹，

89
00:05:02,770 --> 00:05:07,530
甚至試圖採取的平均
一個函數或任何這方面的東西，

90
00:05:07,530 --> 00:05:10,000
R將有。

91
00:05:10,000 --> 00:05:14,190
>> 如果你這樣做你關心
優化，一件事是很常見

92
00:05:14,190 --> 00:05:17,430
在這之後，你就大功告成了原型
某種高級語言，

93
00:05:17,430 --> 00:05:19,810
你會拋出in--
你只會端口超過

94
00:05:19,810 --> 00:05:21,550
一些低級語言。

95
00:05:21,550 --> 00:05:26,090
有什麼好的R是，一旦你
做原型，你可以運行C ++，

96
00:05:26,090 --> 00:05:29,510
或Fortran或任何這些
較低水平的人直接進入R.

97
00:05:29,510 --> 00:05:32,320
所以，這人真的
關於R很酷的功能，

98
00:05:32,320 --> 00:05:35,930
如果你真的關心
優化點。

99
00:05:35,930 --> 00:05:39,490
>> 而且它也確實不錯
為Web可視化。

100
00:05:39,490 --> 00:05:43,530
所以D3.js，例如，是
我想另一個研討會

101
00:05:43,530 --> 00:05:45,130
我們今天提出。

102
00:05:45,130 --> 00:05:48,510
這是真正的真棒
做交互式可視化。

103
00:05:48,510 --> 00:05:54,460
和D3.js假設你有
要繪製某種數據的

104
00:05:54,460 --> 00:05:58,080
和R是能夠做一個偉大的方式
導出之前的數據分析

105
00:05:58,080 --> 00:06:04,220
交給D3.js甚至只是運行
D3.js命令為R本身，

106
00:06:04,220 --> 00:06:08,240
以及所有這些
其他庫也是如此。

107
00:06:08,240 --> 00:06:13,041
>> 所以這是剛剛出台
什麼是R和為什麼你可能會使用它。

108
00:06:13,041 --> 00:06:14,790
所以希望，我已經
相信你的東西

109
00:06:14,790 --> 00:06:18,460
大約只是想看看是什麼樣子的。

110
00:06:18,460 --> 00:06:23,930
所以，我要繼續前進，經過
關於R對象的一些基礎知識

111
00:06:23,930 --> 00:06:26,150
什麼，你真的可以做到。

112
00:06:26,150 --> 00:06:29,690
>> 因此，這裡僅僅是一個
一堆數學指令。

113
00:06:29,690 --> 00:06:35,000
所以說，you're--你想建立
語言自己只是想和你

114
00:06:35,000 --> 00:06:38,080
有一堆不同的工具。

115
00:06:38,080 --> 00:06:42,520
操作任何一種你認為你會
要的是幾乎將要在R.

116
00:06:42,520 --> 00:06:44,150
>> 因此，這裡是2加2。

117
00:06:44,150 --> 00:06:46,090
這是2倍圓周率。

118
00:06:46,090 --> 00:06:51,870
R有一堆內置常量
你會經常使用如pi，E。

119
00:06:51,870 --> 00:06:56,230
>> 然後，這裡是7加
runif，所以runif 1。

120
00:06:56,230 --> 00:07:02,450
這是一個功能，是生成
1無規均勻從0到1。

121
00:07:02,450 --> 00:07:04,400
再有3到4個電源。

122
00:07:04,400 --> 00:07:06,430
有平方根。

123
00:07:06,430 --> 00:07:07,270
>> 有日誌。

124
00:07:07,270 --> 00:07:14,500
所以日誌會做基地
指數本身。

125
00:07:14,500 --> 00:07:18,337
然後，如果你指定一個基地的話，
你可以做任何基地你想要的。

126
00:07:18,337 --> 00:07:19,920
然後這裡有一些其他的命令。

127
00:07:19,920 --> 00:07:22,180
所以，你有23 MOD 2。

128
00:07:22,180 --> 00:07:24,910
那麼你有剩餘。

129
00:07:24,910 --> 00:07:27,110
那麼你有科學
如果你還記法

130
00:07:27,110 --> 00:07:34,060
要做到這更多，
更複雜的事情。

131
00:07:34,060 --> 00:07:37,320
>> 因此，這裡是分配。

132
00:07:37,320 --> 00:07:40,830
在這樣的典型任務
R被用箭頭完成

133
00:07:40,830 --> 00:07:43,440
所以它的不足，然後連字符。

134
00:07:43,440 --> 00:07:47,250
所以在這裡我只是分配
3向變量val。

135
00:07:47,250 --> 00:07:50,160
>> 然後我打印出來VAL
然後打印出3。

136
00:07:50,160 --> 00:07:53,920
默認情況下，在研發解釋，它
將打印出來的東西你

137
00:07:53,920 --> 00:07:57,280
所以你不必指定打印VAL
任何時候你要打印的東西。

138
00:07:57,280 --> 00:08:00,200
你可以做VAL和
然後它會為你做的。

139
00:08:00,200 --> 00:08:04,380
>> 此外，您還可以使用等於技術上
作為賦值運算符。

140
00:08:04,380 --> 00:08:07,190
有輕微的微妙之處
利用箭頭之間

141
00:08:07,190 --> 00:08:10,730
操作員和等於
運營商的任務。

142
00:08:10,730 --> 00:08:15,470
主要是按照慣例，每個人都
將只使用箭頭操作符。

143
00:08:15,470 --> 00:08:21,850
>> 在這裡，我這個分配
斜符號稱為1結腸癌6。

144
00:08:21,850 --> 00:08:26,010
這產生從1到6的載體。

145
00:08:26,010 --> 00:08:29,350
這真的很好，因為那時
你剛才分配向量VAL

146
00:08:29,350 --> 00:08:34,270
並且工作本身。

147
00:08:34,270 --> 00:08:37,799
>> 因此，這已經從去
single--一個非常直觀的數據

148
00:08:37,799 --> 00:08:41,070
只是雙重結構
一些類型的類型的插入載體

149
00:08:41,070 --> 00:08:45,670
並會收集所有
標值給你。

150
00:08:45,670 --> 00:08:50,770
因此，從標會後，你
具有R的對象，這是一個矢量。

151
00:08:50,770 --> 00:08:55,610
向量是任何形式的
收集同一類型的。

152
00:08:55,610 --> 00:08:58,150
因此，這裡有一堆載體。

153
00:08:58,150 --> 00:08:59,800
>> 因此，這是數字。

154
00:08:59,800 --> 00:09:02,440
數字是說雙R的方式。

155
00:09:02,440 --> 00:09:07,390
因此在默認情況下，任何
號將是一個雙。

156
00:09:07,390 --> 00:09:13,150
>> 所以，如果你有C 1.1，3，
負5.7，則c是一個函數。

157
00:09:13,150 --> 00:09:16,760
這樣可以將所有三個
號碼到載體。

158
00:09:16,760 --> 00:09:19,619
而這將be--所以如果
你注意到3本身，

159
00:09:19,619 --> 00:09:21,910
通常你會假設
這是像的整數，

160
00:09:21,910 --> 00:09:25,050
但由於所有矢量
是相同的類型，

161
00:09:25,050 --> 00:09:28,660
這是雙打的向量
或數值在此情況下。

162
00:09:28,660 --> 00:09:34,920
>> RNORM是一個函數，產生
標準正常variables--

163
00:09:34,920 --> 00:09:36,700
或標準正常值。

164
00:09:36,700 --> 00:09:38,360
和我指定他們兩個。

165
00:09:38,360 --> 00:09:43,840
所以我做RNORM 2，分配，要
開發者，然後我打印出開發者。

166
00:09:43,840 --> 00:09:47,350
因此，這些都是只有兩個
隨機正常值。

167
00:09:47,350 --> 00:09:50,060
>> 如果你這樣做，然後INTS
你關心的整數。

168
00:09:50,060 --> 00:09:54,650
所以，這只是關於內存
分配和節省內存大小。

169
00:09:54,650 --> 00:10:01,460
所以，你將不得不追加
您的號碼被資本L.

170
00:10:01,460 --> 00:10:04,170
>> 在一般情況下，這是
的r歷史符號

171
00:10:04,170 --> 00:10:06,940
對於一些所謂的長整型。

172
00:10:06,940 --> 00:10:09,880
所以大多數的時候，你會
是處理雙打。

173
00:10:09,880 --> 00:10:15,180
如果你曾經稍後會
在優化你的代碼，

174
00:10:15,180 --> 00:10:18,110
你可以只添加這些L的
之後或期間，

175
00:10:18,110 --> 00:10:22,280
如果你像預知什麼
你要做這些變量。

176
00:10:22,280 --> 00:10:25,340

177
00:10:25,340 --> 00:10:26,890
>> 因此，這裡是一個字符向量。

178
00:10:26,890 --> 00:10:31,440
所以，再一次，我串聯
三根弦這段時間。

179
00:10:31,440 --> 00:10:36,230
請注意，雙串和
單一字符串的R.同

180
00:10:36,230 --> 00:10:41,000
所以，我有亞瑟和馬文的等
當我打印出來，所有的人

181
00:10:41,000 --> 00:10:43,210
要顯示雙字符串。

182
00:10:43,210 --> 00:10:45,880
如果你也想有
雙或單串

183
00:10:45,880 --> 00:10:50,070
在你的角色，那麼你就可以
無論你的交替串。

184
00:10:50,070 --> 00:10:53,540
>> 所以馬文的對
第二元件，這是

185
00:10:53,540 --> 00:10:56,380
去展示 - 你
只是有雙串

186
00:10:56,380 --> 00:10:59,050
然後一個字符串
所以這是交替的。

187
00:10:59,050 --> 00:11:04,040
否則，如果你想使用雙
字符串操作在雙串

188
00:11:04,040 --> 00:11:07,090
當你宣布它，然後
你只需要使用轉義符。

189
00:11:07,090 --> 00:11:10,600
所以，你要做的雙反斜線字符串。

190
00:11:10,600 --> 00:11:13,330
>> 最後，我們還
有邏輯的載體。

191
00:11:13,330 --> 00:11:15,890
所以logical--所以TRUE
和FALSE，他們是

192
00:11:15,890 --> 00:11:18,880
將全部大寫。

193
00:11:18,880 --> 00:11:22,370
然後，再一次，我串聯
他們，然後分配他們的bool。

194
00:11:22,370 --> 00:11:24,590
所以布爾變量是要告訴
你TRUE，FALSE和TRUE。

195
00:11:24,590 --> 00:11:28,280

196
00:11:28,280 --> 00:11:31,620
>> 因此，這裡是矢量的索引。

197
00:11:31,620 --> 00:11:34,870
所以，在開始的時候，我
我採取了function--

198
00:11:34,870 --> 00:11:39,230
這就是所謂的序列 - 
序為2至12。

199
00:11:39,230 --> 00:11:42,490
而我2採取序列。

200
00:11:42,490 --> 00:11:46,660
所以它會做
2，4，6，8，10和12。

201
00:11:46,660 --> 00:11:50,080
然後，我索引
以獲得所述第三元件。

202
00:11:50,080 --> 00:11:55,770
>> 所以有一點要記住的是
是R指標從1開始。

203
00:11:55,770 --> 00:12:00,550
所以丘壑3是要給
你的第三個元素。

204
00:12:00,550 --> 00:12:04,580
這有點與其他的不同
它從零開始的語言。

205
00:12:04,580 --> 00:12:09,780
所以在C或C ++，例如，你
將得到的第四元素。

206
00:12:09,780 --> 00:12:13,280
>> 這裡是丘壑3〜5。

207
00:12:13,280 --> 00:12:16,030
這麼一件事是
很酷的是你

208
00:12:16,030 --> 00:12:20,410
可以在裡面生成臨時變量
然後就用它們的飛行。

209
00:12:20,410 --> 00:12:21,960
因此，這裡是3〜5。

210
00:12:21,960 --> 00:12:25,070
所以我生成一個向量
3，4和5，然後

211
00:12:25,070 --> 00:12:29,700
我索引獲得第三，
第四和第五元素。

212
00:12:29,700 --> 00:12:32,280
>> 所以同樣，你可以
只是做摘要

213
00:12:32,280 --> 00:12:35,280
任何類型的載體的
，讓你的索引。

214
00:12:35,280 --> 00:12:40,050
因此，這裡是丘壑，然後
第一，第三，第六元件。

215
00:12:40,050 --> 00:12:42,800
然後，如果你想
做一個補充，

216
00:12:42,800 --> 00:12:45,210
所以你只要做減號
事後那會

217
00:12:45,210 --> 00:12:48,600
給你的一切，是不是
第一，第三，或第六元件。

218
00:12:48,600 --> 00:12:51,590
因此，這將是4，8和10。

219
00:12:51,590 --> 00:12:54,380
>> 如果你想獲得
更先進的，

220
00:12:54,380 --> 00:12:57,610
您可以連接布爾向量。

221
00:12:57,610 --> 00:13:05,210
因此，這指數是要給你
長度為6的這個布爾向量。

222
00:13:05,210 --> 00:13:07,280
所以，代表TRUE逗號3。

223
00:13:07,280 --> 00:13:09,680
這將重複為TRUE三次。

224
00:13:09,680 --> 00:13:12,900
因此，這會給你一個
矢量TRUE，TRUE，TRUE。

225
00:13:12,900 --> 00:13:17,470
>> 代表FALSE 4--這是要給你
的FALSE，FALSE，FALSE，FALSE的向量。

226
00:13:17,470 --> 00:13:21,280
然後C是將串聯
這兩個布爾在一起。

227
00:13:21,280 --> 00:13:24,090
所以，你會得到三個
TRUEs然後4 FALSEs。

228
00:13:24,090 --> 00:13:28,460
>> 所以，當你的索引丘壑，你
會得到TRUE，TRUE，TRUE。

229
00:13:28,460 --> 00:13:31,420
所以這是怎麼回事說是，
我想這三個要素。

230
00:13:31,420 --> 00:13:33,520
然後FALSE，FALSE，
FALSE，FALSE是怎麼回事

231
00:13:33,520 --> 00:13:37,140
說沒有，我不希望這些元素
所以它不會來回報他們。

232
00:13:37,140 --> 00:13:41,490
>> 我想有實際上在這裡一個錯字
因為這是說重複TRUE 3

233
00:13:41,490 --> 00:13:47,990
重複FALSE 4，和技術上，你
只有六個要素如此重複FALSE，

234
00:13:47,990 --> 00:13:50,470
它應該是重複FALSE 3。

235
00:13:50,470 --> 00:13:55,260
我覺得R也足夠聰明，這樣的
如果你只是指定4在這裡，然後

236
00:13:55,260 --> 00:13:56,630
它甚至不會出錯了。

237
00:13:56,630 --> 00:13:58,480
它只是給你這個值。

238
00:13:58,480 --> 00:14:00,970
所以它會忽略了第四FALSE。

239
00:14:00,970 --> 00:14:05,310

240
00:14:05,310 --> 00:14:09,270
>> 因此，這裡是矢量分配。

241
00:14:09,270 --> 00:14:15,480
所以set.seed--這只是設置
種子偽隨機數。

242
00:14:15,480 --> 00:14:20,110
所以我設置的種子
42，這意味著如果我產生

243
00:14:20,110 --> 00:14:22,950
三個隨機正常
值，然後如果你

244
00:14:22,950 --> 00:14:27,400
運行set.seed你自己
電腦使用相同的值42，

245
00:14:27,400 --> 00:14:30,990
然後您還可以獲得
同樣的三個隨機法線。

246
00:14:30,990 --> 00:14:33,411
>> 因此，這是真的好
可重複性。

247
00:14:33,411 --> 00:14:35,910
通常情況下，當你做一些
排序科學分析，

248
00:14:35,910 --> 00:14:37,230
你想設置的種子。

249
00:14:37,230 --> 00:14:41,270
這樣，其他科學家可以只
重現你已經完全相同的代碼

250
00:14:41,270 --> 00:14:44,790
這樣做，因為他們將有確切
相同的隨機變量that--或隨機

251
00:14:44,790 --> 00:14:47,270
你已經取出，以及價值觀。

252
00:14:47,270 --> 00:14:49,870

253
00:14:49,870 --> 00:14:53,910
>> 這樣一來，矢量分配
這裡示出了瓦爾斯1至2。

254
00:14:53,910 --> 00:14:59,290
因此，需要前兩個元素
丘壑，然後將它們分配給0。

255
00:14:59,290 --> 00:15:03,940
然後，你也可以只是做了
類似的事情與布爾。

256
00:15:03,940 --> 00:15:09,340
>> 所以瓦爾斯不等於0--該旨意
給你一個矢量FALSE，FALSE，TRUE

257
00:15:09,340 --> 00:15:10,350
在這種情況下。

258
00:15:10,350 --> 00:15:13,770
然後，它會說什麼
那些是真實的指標，

259
00:15:13,770 --> 00:15:15,270
然後它會分配一個5。

260
00:15:15,270 --> 00:15:18,790
因此，需要第三個元素
在這裡，然後將其分配給5。

261
00:15:18,790 --> 00:15:22,300
>> 這是非常好的
相比低級語言

262
00:15:22,300 --> 00:15:25,560
在那裡你必須使用循環
做這一切矢量的東西

263
00:15:25,560 --> 00:15:30,281
因為它只是非常直觀
這是一個單一的單行。

264
00:15:30,281 --> 00:15:32,030
這有什麼了不起
矢量符號

265
00:15:32,030 --> 00:15:37,020
是，在R，這些都是排序
內置使他們幾乎一樣快

266
00:15:37,020 --> 00:15:42,490
因為這樣做在一個低級語言如
反對做一個for循環在研發

267
00:15:42,490 --> 00:15:46,317
再有它做
動態索引本身。

268
00:15:46,317 --> 00:15:48,900
而這會比做慢
這種量化的東西

269
00:15:48,900 --> 00:15:55,950
它可以並行，在那裡做
它這樣做的線程基本。

270
00:15:55,950 --> 00:15:58,650
>> 因此，這裡是矢量操作。

271
00:15:58,650 --> 00:16:04,920
所以我生成一個值1到3，
分配給該VEC 1，3至5，VEC2，

272
00:16:04,920 --> 00:16:05,950
加在一起。

273
00:16:05,950 --> 00:16:11,490
它增加了他們的組件，因此明智的
它是1加上3，2加4，等等。

274
00:16:11,490 --> 00:16:13,330
>> VEC 1次VEC2。

275
00:16:13,330 --> 00:16:16,110
這乘以2
明智的價值觀的組成部分。

276
00:16:16,110 --> 00:16:21,830
所以它的1倍3，2次
4，然後3次5。

277
00:16:21,830 --> 00:16:28,250
>> 然後，同樣，你也可以做
comparisons--邏輯比較。

278
00:16:28,250 --> 00:16:33,640
因此，它是FALSE FALSE TRUE在這
情況下，因為1是不大於3，

279
00:16:33,640 --> 00:16:35,920
圖2是不大於4。

280
00:16:35,920 --> 00:16:41,160
這是，我猜，另一個錯字，3
絕對不大於5。

281
00:16:41,160 --> 00:16:41,660
是啊。

282
00:16:41,660 --> 00:16:45,770
所以你可以做所有
這些簡單的操作

283
00:16:45,770 --> 00:16:48,350
因為他們的繼承
從自己的類。

284
00:16:48,350 --> 00:16:51,110

285
00:16:51,110 --> 00:16:52,580
>> 所以這只是個載體。

286
00:16:52,580 --> 00:16:56,530
這就是那種最根本的
ř對象，因為給定的載體，

287
00:16:56,530 --> 00:16:59,170
你可以構建更高級的對象。

288
00:16:59,170 --> 00:17:00,560
>> 所以這裡有一個矩陣。

289
00:17:00,560 --> 00:17:05,030
這在本質上是抽象
一個什麼樣的矩陣本身。

290
00:17:05,030 --> 00:17:10,099
因此，在這種情況下，它的三個不同的
矢量，其中，每一個是一列，

291
00:17:10,099 --> 00:17:12,710
或者你可以考慮
因為每一個是一排。

292
00:17:12,710 --> 00:17:18,250
>> 所以，我存儲從1矩陣
9，然後我指定3行。

293
00:17:18,250 --> 00:17:23,364
因此，1至9會給你一個向量1，
2，3，4，5，6，和一路9。

294
00:17:23,364 --> 00:17:29,250
>> 有一件事也記住的是，
ř專賣店在列的主要格式值。

295
00:17:29,250 --> 00:17:34,160
所以，換句話說，當你看到1
至9，它要儲存them--

296
00:17:34,160 --> 00:17:36,370
這將是1，2，
在第一列3，

297
00:17:36,370 --> 00:17:38,510
然後它會做4，5，
在第二列6，

298
00:17:38,510 --> 00:17:41,440
然後7，8，9，在第三列中。

299
00:17:41,440 --> 00:17:45,570
>> 這裡有一些其他的
您可以使用常用功能。

300
00:17:45,570 --> 00:17:49,650
因此昏暗的墊子，這會給你
矩陣的尺寸。

301
00:17:49,650 --> 00:17:52,620
它會回報你
維度的向量。

302
00:17:52,620 --> 00:17:55,580
因此，在這種情況下，因為
我們的矩陣為3×3，

303
00:17:55,580 --> 00:18:01,900
它會給你一個
數字矢量是3 3。

304
00:18:01,900 --> 00:18:05,270
>> 這裡只是展示
矩陣乘法。

305
00:18:05,270 --> 00:18:11,970
所以通常情況下，如果你只是做
asterisk--所以墊星號mat--

306
00:18:11,970 --> 00:18:15,380
這將是
組件明智的操作

307
00:18:15,380 --> 00:18:17,300
或者什麼所謂的阿達瑪產品。

308
00:18:17,300 --> 00:18:21,310
所以它會做的每
元素組件明智的。

309
00:18:21,310 --> 00:18:23,610
但是，如果你想
矩陣multiplication--

310
00:18:23,610 --> 00:18:29,380
所以第一行時間乘以
第二矩陣的第一列

311
00:18:29,380 --> 00:18:34,510
所以on--你會使用
這個百分比操作。

312
00:18:34,510 --> 00:18:38,110
>> 和墊噸只是一個
操作轉。

313
00:18:38,110 --> 00:18:42,590
所以我說，走在轉
的矩陣，由矩陣乘以

314
00:18:42,590 --> 00:18:43,090
本身。

315
00:18:43,090 --> 00:18:45,006
然後它會
回報給你另外3

316
00:18:45,006 --> 00:18:50,700
3矩陣，顯示
你想要的產品。

317
00:18:50,700 --> 00:18:53,750
>> 所以這是矩陣。

318
00:18:53,750 --> 00:18:56,020
這裡是所謂的數據幀。

319
00:18:56,020 --> 00:19:00,780
數據幀，你能想到的作為
一個矩陣，但是每列本身

320
00:19:00,780 --> 00:19:02,990
將是不同類型的。

321
00:19:02,990 --> 00:19:07,320
>> 那麼，什麼是真正酷的數據
幀是在數據分析本身，

322
00:19:07,320 --> 00:19:11,260
你將擁有這一切
異構數據，所有這些真的

323
00:19:11,260 --> 00:19:15,640
亂七八糟的東西，其中每一列
本身可以是不同類型的。

324
00:19:15,640 --> 00:19:21,460
所以在這裡我想說的創建
數據幀中，執行整數1至3個，

325
00:19:21,460 --> 00:19:24,750
然後也有一個特徵向量。

326
00:19:24,750 --> 00:19:28,470
這樣我就可以通過指數
這些列

327
00:19:28,470 --> 00:19:30,930
然後我會得到的值本身。

328
00:19:30,930 --> 00:19:34,370
而且你還可以做一些
對數據幀的操作。

329
00:19:34,370 --> 00:19:38,040
和大部分的時間你的時候
進行數據分析，或某種

330
00:19:38,040 --> 00:19:42,042
預處理，你會
與這些數據結構工作

331
00:19:42,042 --> 00:19:44,250
其中每個列將
是不同類型的。

332
00:19:44,250 --> 00:19:47,880

333
00:19:47,880 --> 00:19:52,970
>> 最後，所以這些基本上都是剛
在R.列出四個基本目標

334
00:19:52,970 --> 00:19:55,820
將只收取任何
你想要的其他對象。

335
00:19:55,820 --> 00:20:00,130
因此，將這種存儲到一個
您可以輕鬆地訪問變量。

336
00:20:00,130 --> 00:20:02,370
>> 所以在這裡，我要帶一個列表。

337
00:20:02,370 --> 00:20:04,460
我說的東西等於3。

338
00:20:04,460 --> 00:20:08,060
所以，我要在一個元素
列表中，這就是所謂的東西，

339
00:20:08,060 --> 00:20:10,570
而這將有值3。

340
00:20:10,570 --> 00:20:13,140
>> 我還可以創建一個矩陣。

341
00:20:13,140 --> 00:20:17,970
因此，這是1至4和端排
等於2，所以由2矩陣2。

342
00:20:17,970 --> 00:20:20,270
此外，在列表中，這就是所謂的墊子。

343
00:20:20,270 --> 00:20:24,690
moreStuff，一個字符串，
甚至另一個列表本身。

344
00:20:24,690 --> 00:20:27,710
>> 所以這是一個列表，是5和熊。

345
00:20:27,710 --> 00:20:30,990
因此它具有值5和它
有字符串熊

346
00:20:30,990 --> 00:20:32,710
和它的內部的列表的列表。

347
00:20:32,710 --> 00:20:35,965
所以，你可以有這些
遞歸的東西在哪裡

348
00:20:35,965 --> 00:20:38,230
你有another--一個
在類型類型。

349
00:20:38,230 --> 00:20:41,420
所以同樣，你可以有一個矩陣
在另一個矩陣等。

350
00:20:41,420 --> 00:20:44,264
和一個列表僅僅是一個很好的方法
收集和匯總的

351
00:20:44,264 --> 00:20:45,430
所有這些不同的對象。

352
00:20:45,430 --> 00:20:50,210

353
00:20:50,210 --> 00:20:57,150
>> 最後，這裡是以防萬一幫助
這是剛剛經歷了非常迅速。

354
00:20:57,150 --> 00:21:01,350
所以，任何時候你困惑
關於某種功能，

355
00:21:01,350 --> 00:21:03,510
你可以做到這一點的功能幫助。

356
00:21:03,510 --> 00:21:07,120
所以你可以做幫助矩陣
或問號矩陣。

357
00:21:07,120 --> 00:21:11,430
並幫助和問號都
只是簡寫同樣的事情

358
00:21:11,430 --> 00:21:13,040
所以他們的別名。

359
00:21:13,040 --> 00:21:16,820
>> 流明是一個函數，它
只是做一個線性模型。

360
00:21:16,820 --> 00:21:20,340
但如果你只是不知道怎麼說
作品中，你可以做流明幫助

361
00:21:20,340 --> 00:21:24,610
而且會給你一些
這類文檔的

362
00:21:24,610 --> 00:21:27,960
看起來有點像
在Unix中，在手冊頁

363
00:21:27,960 --> 00:21:34,210
你有一個簡短的說明什麼
確實如此，亦是它的參數是，

364
00:21:34,210 --> 00:21:38,850
它返回，並就如何只提示
使用它，並且一些實施例也是如此。

365
00:21:38,850 --> 00:21:41,680

366
00:21:41,680 --> 00:21:52,890
>> 因此，讓我繼續前進，顯示
使用R. OK了一些演示。

367
00:21:52,890 --> 00:21:55,470
於是我去了很
很快就在數據

368
00:21:55,470 --> 00:21:59,440
結構和某種的
op--一些操作。

369
00:21:59,440 --> 00:22:02,960
下面是一些功能。

370
00:22:02,960 --> 00:22:06,750
>> 所以在這裡我只是去
來定義的函數。

371
00:22:06,750 --> 00:22:09,970
所以，我還使用
賦值運算符在這裡，

372
00:22:09,970 --> 00:22:12,610
然後我說
聲明為一個函數。

373
00:22:12,610 --> 00:22:14,140
而它需要的x值。

374
00:22:14,140 --> 00:22:18,210
所以，這是你想要的任何值
而我要返回X本身。

375
00:22:18,210 --> 00:22:20,840
因此，這是身份的功能。

376
00:22:20,840 --> 00:22:23,670
>> 什麼是酷這個
相比其它語言

377
00:22:23,670 --> 00:22:26,330
和另一低級別
語言是X

378
00:22:26,330 --> 00:22:29,350
可以是任何類型本身
它會返回一個類型。

379
00:22:29,350 --> 00:22:35,251
所以，你可以imagine--所以讓
我只想趕緊跑了。

380
00:22:35,251 --> 00:22:35,750
抱歉。

381
00:22:35,750 --> 00:22:40,300
>> 這麼一件事我還要提到
就是這個編輯器，我使用

382
00:22:40,300 --> 00:22:41,380
被稱為rstudio。

383
00:22:41,380 --> 00:22:44,389
這是所謂的IDE。

384
00:22:44,389 --> 00:22:46,180
還有一件事是
非常好的關於這個

385
00:22:46,180 --> 00:22:51,500
的是，它包含了很多
你想通過自己做R中的事情

386
00:22:51,500 --> 00:22:53,180
只是很直觀。

387
00:22:53,180 --> 00:22:55,550
>> 因此，這裡是一個解釋控制台。

388
00:22:55,550 --> 00:23:02,160
所以同樣，你也可以得到這個
只是做一個大寫R.控制台原料

389
00:23:02,160 --> 00:23:05,630
而這正是
同樣的事情作為控制台。

390
00:23:05,630 --> 00:23:12,210
所以，我可以做ID功能X，X，X。

391
00:23:12,210 --> 00:23:16,130
和then--然後該
將被罰款本身。

392
00:23:16,130 --> 00:23:19,200

393
00:23:19,200 --> 00:23:21,740
>> 所以rstudio是偉大的
因為它有控制台。

394
00:23:21,740 --> 00:23:25,360
它也有文件
你想運行。

395
00:23:25,360 --> 00:23:28,629
然後它有一些變數
您可以在環境中看到的。

396
00:23:28,629 --> 00:23:30,420
然後，如果你有
做圖，那麼你

397
00:23:30,420 --> 00:23:33,730
可以只看到它在這裡，相對於
管理所有這些不同的窗口

398
00:23:33,730 --> 00:23:35,940
由自己決定。

399
00:23:35,940 --> 00:23:40,530
>> 其實，我個人用Vim，但我
感覺rstudio是優秀的只是

400
00:23:40,530 --> 00:23:44,640
為得到一個好主意
如何使用R.一般，

401
00:23:44,640 --> 00:23:47,040
當你試圖
學習一些新的任務，

402
00:23:47,040 --> 00:23:49,590
你不想處理
太多的事情一次。

403
00:23:49,590 --> 00:23:53,120
所以，R是只是一個very-- rstudio
是學習R的非常好的方法

404
00:23:53,120 --> 00:23:56,760
而無需處理
所有這些其他的東西。

405
00:23:56,760 --> 00:23:58,600
>> 所以在這裡我跑ID打招呼。

406
00:23:58,600 --> 00:24:00,090
這將返回打招呼。

407
00:24:00,090 --> 00:24:01,740
編號123。

408
00:24:01,740 --> 00:24:04,610
這裡是整數的向量。

409
00:24:04,610 --> 00:24:08,620
那麼同樣的，因為你可以
採取某種價值，

410
00:24:08,620 --> 00:24:16,060
你可以做回國ID
X所以它返回1234和5。

411
00:24:16,060 --> 00:24:22,210
>> 並讓我告訴你，
這確實是一個整數。

412
00:24:22,210 --> 00:24:28,800
同樣，如果你​​這樣做類
ID X，這將是整數。

413
00:24:28,800 --> 00:24:34,170
然後，你也可以
比較這兩個，這是真的。

414
00:24:34,170 --> 00:24:38,350
所以我檢查，如果ID x的
等於等於x和通知

415
00:24:38,350 --> 00:24:39,760
它給你兩個TRUEs。

416
00:24:39,760 --> 00:24:44,280
因此，這是不是說有
兩個對象相同，

417
00:24:44,280 --> 00:24:46,845
但是每個條目的
在矢量是相同的。

418
00:24:46,845 --> 00:24:50,000

419
00:24:50,000 --> 00:24:52,090
>> 這是bounded.compare。

420
00:24:52,090 --> 00:24:58,470
因此，這是稍微複雜
在於：它具有一個if條件和其他

421
00:24:58,470 --> 00:25:00,960
然後需要兩個
在一個時間參數。

422
00:25:00,960 --> 00:25:02,640
所以x是任何類型。

423
00:25:02,640 --> 00:25:06,280
而且我說這
第二個參數是一個。

424
00:25:06,280 --> 00:25:08,380
這可以是任何為好。

425
00:25:08,380 --> 00:25:12,490
但默認情況下，它會採取
5，如果你不指定任何東西。

426
00:25:12,490 --> 00:25:16,730
>> 所以在這裡我要說
如果x大於一。

427
00:25:16,730 --> 00:25:19,220
所以，如果我不指定，它
說，如果x大於5，

428
00:25:19,220 --> 00:25:20,470
然後我會返回TRUE。

429
00:25:20,470 --> 00:25:23,230
否則，我將返回FALSE。

430
00:25:23,230 --> 00:25:24,870
因此，讓我繼續前進，定義這個。

431
00:25:24,870 --> 00:25:30,600

432
00:25:30,600 --> 00:25:34,550
>> 現在我要去
運行bounded.compare 3。

433
00:25:34,550 --> 00:25:39,150
所以說，在3少
than--比5 3更大。

434
00:25:39,150 --> 00:25:41,830
不，這不是那麼FALSE。

435
00:25:41,830 --> 00:25:46,550
>> 和bounded.compare 3，我要去
用等於2來比較它。

436
00:25:46,550 --> 00:25:50,700
所以，現在我要說的是，現在我
想別的東西。

437
00:25:50,700 --> 00:25:52,750
所以我要去說，你應該是2。

438
00:25:52,750 --> 00:25:56,640
>> 我可以做這樣的
符號或者我說等於2。

439
00:25:56,640 --> 00:25:58,720
這是一個更可讀
在當你

440
00:25:58,720 --> 00:26:01,450
看著這些真的
複雜功能

441
00:26:01,450 --> 00:26:08,110
採取多種arguments--這
可幾十oftentimes--只是說

442
00:26:08,110 --> 00:26:11,140
A等於2是更可讀的
你這樣以後在未來

443
00:26:11,140 --> 00:26:13,020
你會知道你在做什麼。

444
00:26:13,020 --> 00:26:17,120
>> 因此，在這種情況下，我
俗話說比2 3更大。

445
00:26:17,120 --> 00:26:18,270
是的。

446
00:26:18,270 --> 00:26:22,350
同樣，我也只是刪除
這一點，並說，比2 3更大

447
00:26:22,350 --> 00:26:23,440
其中a等於2。

448
00:26:23,440 --> 00:26:26,230
而這也是事實。

449
00:26:26,230 --> 00:26:26,730
是嗎？

450
00:26:26,730 --> 00:26:29,670
>> 聽眾：你
按行執行行？

451
00:26:29,670 --> 00:26:30,670
>> DUSTIN TRAN：是的，我是。

452
00:26:30,670 --> 00:26:33,900
所以我在做什麼這裡是
採取這一文本document--

453
00:26:33,900 --> 00:26:39,825
什麼是偉大的關於rstudio是
我可以只運行一個short--一個快捷鍵。

454
00:26:39,825 --> 00:26:41,820
所以我在做控制輸入。

455
00:26:41,820 --> 00:26:44,850
>> 然後，我走了
文本文檔中的行

456
00:26:44,850 --> 00:26:46,710
然後將在控制台中。

457
00:26:46,710 --> 00:26:50,800
所以在這裡我要說，bounded.compare
和我做控制-X。

458
00:26:50,800 --> 00:26:52,540
所以，我可以做跑這裡。

459
00:26:52,540 --> 00:26:54,920
然後那會走
行，然後把它放在這裡。

460
00:26:54,920 --> 00:26:57,900
然後同樣地，我可以在這裡做運行。

461
00:26:57,900 --> 00:27:04,630
然後它會自顧自地定義
線成這樣的控制台。

462
00:27:04,630 --> 00:27:10,690
>> 如果你也注意到了花
括號是有類似於C的語法。

463
00:27:10,690 --> 00:27:13,910
x--如果if條件也
要使用括號，然後

464
00:27:13,910 --> 00:27:15,350
你可以使用別的。

465
00:27:15,350 --> 00:27:17,496
另外一個是，如果別人。

466
00:27:17,496 --> 00:27:21,440
因此，這將是X
等於等於一，例如。

467
00:27:21,440 --> 00:27:24,190

468
00:27:24,190 --> 00:27:26,350
然後我要去
回到這裡的東西。

469
00:27:26,350 --> 00:27:29,490
>> 請注意，有兩種不同的
這裡的東西這回事。

470
00:27:29,490 --> 00:27:34,360
其一是，在這裡我指定
返回值TRUE。

471
00:27:34,360 --> 00:27:35,950
在這裡，我只是說X。

472
00:27:35,950 --> 00:27:39,970
所以R將通常默認
取最後arguments--

473
00:27:39,970 --> 00:27:43,510
或取代碼的最後一行，
這將是它的返回。

474
00:27:43,510 --> 00:27:46,920
所以在這裡，這是相同的
事情做回X。

475
00:27:46,920 --> 00:27:49,450

476
00:27:49,450 --> 00:27:50,540
>> 而剛剛給你看。

477
00:27:50,540 --> 00:27:54,000

478
00:27:54,000 --> 00:27:57,052
然後，它會工作就是這樣。

479
00:27:57,052 --> 00:27:58,260
因此，讓我繼續這樣做。

480
00:27:58,260 --> 00:28:00,630
>> 所以，如果別的。

481
00:28:00,630 --> 00:28:04,060
真的，我可以返回
什麼我想。

482
00:28:04,060 --> 00:28:06,680
所以我甚至不有
返回布爾所有的時間，

483
00:28:06,680 --> 00:28:08,410
我可以返回別的東西。

484
00:28:08,410 --> 00:28:10,670
所以我可以做回熊。

485
00:28:10,670 --> 00:28:12,989
>> 所以，如果x等於等於，
它會返回熊。

486
00:28:12,989 --> 00:28:14,530
否則，它會返回TRUE。

487
00:28:14,530 --> 00:28:19,310
我也可以做一個向量
還是真的什麼。

488
00:28:19,310 --> 00:28:22,210
>> 與通常靜態
類型化的語言，

489
00:28:22,210 --> 00:28:23,840
你必須在這裡指定一個類型。

490
00:28:23,840 --> 00:28:25,750
並發現它可以只是任何東西。

491
00:28:25,750 --> 00:28:32,400
R是智能不夠，它
只是做到這一點，它會正常工作。

492
00:28:32,400 --> 00:28:33,620
>> 因此，讓我定義這個。

493
00:28:33,620 --> 00:28:39,460

494
00:28:39,460 --> 00:28:41,230
Unexpected--哦對不起。

495
00:28:41,230 --> 00:28:44,336
這應該是一個大括號在這裡。

496
00:28:44,336 --> 00:28:44,836
好不好。

497
00:28:44,836 --> 00:28:45,336
酷。

498
00:28:45,336 --> 00:28:52,580

499
00:28:52,580 --> 00:28:54,530
行。

500
00:28:54,530 --> 00:28:58,250
所以，現在讓我們來比較3和等於3。

501
00:28:58,250 --> 00:29:01,860
所以應該return--
yeah--值熊。

502
00:29:01,860 --> 00:29:06,740
>> 所以，現在更普遍的是像
那麼其他的數據結構。

503
00:29:06,740 --> 00:29:09,110
所以，你有這個功能。

504
00:29:09,110 --> 00:29:15,360
這是去上班任何形式的
，價值就像3或任何數字

505
00:29:15,360 --> 00:29:17,500
換句話說，雙重。

506
00:29:17,500 --> 00:29:19,330
>> 但對於像一個載體。

507
00:29:19,330 --> 00:29:27,750
所以，如果你do--所以我會發生什麼
要分配VAL，比方說，4至6個。

508
00:29:27,750 --> 00:29:31,640
所以，如果我回到這，這
為4，5，6的載體。

509
00:29:31,640 --> 00:29:34,935
>> 現在，讓我們看看會發生什麼
如果我做bounded.compare VAL。

510
00:29:34,935 --> 00:29:37,680

511
00:29:37,680 --> 00:29:42,450
因此，這將會給你15 1251。

512
00:29:42,450 --> 00:29:46,440
因此，換句話說，它說
如果你看一下這個條件

513
00:29:46,440 --> 00:29:50,040
所以說，x是少
比什麼的。

514
00:29:50,040 --> 00:29:51,880
因此，這是稍微
令人困惑，因為現在

515
00:29:51,880 --> 00:29:53,379
你只是不知道發生了什麼事情。

516
00:29:53,379 --> 00:29:58,690
所以我想一件事是真的
良好只是想調試

517
00:29:58,690 --> 00:30:04,600
是，你可以做val為更大
不是，看看會發生什麼存在。

518
00:30:04,600 --> 00:30:09,720
>> 所以val--一個是默認的5等
我們只是做VAL大於5。

519
00:30:09,720 --> 00:30:14,280
所以這是一個矢量FALSE FALSE TRUE。

520
00:30:14,280 --> 00:30:17,206
所以，當你看現在
這一點，這是怎麼回事，如果說，

521
00:30:17,206 --> 00:30:20,080
然後它會給予你這個
為FALSE FALSE向量TRUE。

522
00:30:20,080 --> 00:30:23,450
>> 所以，當你通過這個入R，R
不知道你在做什麼。

523
00:30:23,450 --> 00:30:26,650
因為它需要一個單一的
值，這是一布爾值，而現在

524
00:30:26,650 --> 00:30:29,420
你給它布爾向量。

525
00:30:29,420 --> 00:30:31,970
因此，通過默認，R是剛
接下來要說什麼的挫折感，

526
00:30:31,970 --> 00:30:35,440
我會假設你
要採取的第一個元素在這裡。

527
00:30:35,440 --> 00:30:38,320
所以，我要say--我要去
假設這是假的。

528
00:30:38,320 --> 00:30:40,890
所以它會說
不，這是不對的。

529
00:30:40,890 --> 00:30:45,246
>> 同樣，這將
是VAL等於等於。

530
00:30:45,246 --> 00:30:47,244
不，對不起5。

531
00:30:47,244 --> 00:30:48,910
而它也將是錯誤的為好。

532
00:30:48,910 --> 00:30:52,410
所以它會說沒有，
事實並非如此，以及因此它的

533
00:30:52,410 --> 00:30:53,680
要返回該最後一個。

534
00:30:53,680 --> 00:30:56,420

535
00:30:56,420 --> 00:31:01,360
>> 因此，這可以是一個好事還是壞事
的事情，這取決於你如何看待它。

536
00:31:01,360 --> 00:31:05,104
因為當你
創建這些功能，

537
00:31:05,104 --> 00:31:06,770
你是不知道發生了什麼事情。

538
00:31:06,770 --> 00:31:10,210
所以有時候你會希望有一個錯誤，
或者你只是想警告。

539
00:31:10,210 --> 00:31:12,160
在這種情況下，R不這樣做。

540
00:31:12,160 --> 00:31:14,300
所以，這真的取決於
您可以根據掉什麼

541
00:31:14,300 --> 00:31:17,310
你認為語言
應該在此情況下

542
00:31:17,310 --> 00:31:22,920
如果你通過在布爾向量
當你正在做的，如果條件。

543
00:31:22,920 --> 00:31:31,733
>> 因此，讓我們說，你有原來的
之一，如果其他人返回TRUE和你

544
00:31:31,733 --> 00:31:34,190
會返回FALSE。

545
00:31:34,190 --> 00:31:39,300
抽象的這麼一種方式
這是說我

546
00:31:39,300 --> 00:31:41,530
甚至不需要這個條件的事情。

547
00:31:41,530 --> 00:31:47,220
另一件事，我可以做的就是
返回值本身。

548
00:31:47,220 --> 00:31:53,240
所以，如果你發現，如果你
做val為大於5，

549
00:31:53,240 --> 00:31:56,350
這將返回一個
矢量FALSE FALSE TRUE。

550
00:31:56,350 --> 00:31:58,850
>> 也許這就是你
想要bounded.compare。

551
00:31:58,850 --> 00:32:02,940
要返回布爾向量
它比較每個值

552
00:32:02,940 --> 00:32:04,190
對自己負責。

553
00:32:04,190 --> 00:32:11,165
所以，你可以做bounded.compare
函數x，a等於5。

554
00:32:11,165 --> 00:32:13,322

555
00:32:13,322 --> 00:32:15,363
然後，而不是做
這一點，如果其他條件，

556
00:32:15,363 --> 00:32:21,430
我只是要回
x是大於5。

557
00:32:21,430 --> 00:32:23,620
所以，如果這是真的，那麼
它會返回TRUE。

558
00:32:23,620 --> 00:32:26,830
然後，如果它不是，它是
會返回FALSE。

559
00:32:26,830 --> 00:32:30,880
>> 這將工作
任何這些結構。

560
00:32:30,880 --> 00:32:41,450
這樣我就可以bounded.compareç1 6或9
然後我會說等於6，

561
00:32:41,450 --> 00:32:42,799
例如。

562
00:32:42,799 --> 00:32:44,840
然後它會
給你正確的布爾

563
00:32:44,840 --> 00:32:48,240
矢量你設計。

564
00:32:48,240 --> 00:32:50,660
>> 所以，那些只是功能
現在讓我

565
00:32:50,660 --> 00:32:54,980
告訴你一些互動的視覺效果。

566
00:32:54,980 --> 00:32:59,700
我不認為我實際上有
無線網絡連接，在這裡，所以讓我繼續前進

567
00:32:59,700 --> 00:33:01,970
並跳過這個我猜。

568
00:33:01,970 --> 00:33:05,260
>> 但有一點很酷
但是，如果你只是

569
00:33:05,260 --> 00:33:09,600
要測試一堆
不同的數據的命令，

570
00:33:09,600 --> 00:33:13,320
有一堆不同的數據集
那些已經預先加載到R.

571
00:33:13,320 --> 00:33:15,770
所以其中之一是
所謂的虹膜數據集。

572
00:33:15,770 --> 00:33:18,910
這是最知名的1
那些在機器學習。

573
00:33:18,910 --> 00:33:23,350
你通常只是做某種
測試用例，看看你的代碼運行。

574
00:33:23,350 --> 00:33:27,520
所以讓我們只檢查虹膜是什麼。

575
00:33:27,520 --> 00:33:33,130
>> 所以這個事情是怎麼回事
成為一個數據幀。

576
00:33:33,130 --> 00:33:36,000
而且它是一種長的，因為
我剛打印出來光圈。

577
00:33:36,000 --> 00:33:38,810
它打印出整個事情。

578
00:33:38,810 --> 00:33:42,830
因此它具有所有這些不同的名稱。

579
00:33:42,830 --> 00:33:45,505
因此，虹膜是一家集
不同的花。

580
00:33:45,505 --> 00:33:48,830
在這種情況下，它告訴
你它的品種，

581
00:33:48,830 --> 00:33:54,760
所有這些不同的寬度和
在萼片和花瓣的長度。

582
00:33:54,760 --> 00:33:58,880
>> 因此，通常，如果
要打印虹膜，

583
00:33:58,880 --> 00:34:03,680
例如，你不想擁有它
做了這一切，因為這可以接管

584
00:34:03,680 --> 00:34:05,190
整個控制台。

585
00:34:05,190 --> 00:34:09,280
這麼一件事是真的
好的是頭功能。

586
00:34:09,280 --> 00:34:12,929
所以，如果你只是做頭
虹膜，這會給你

587
00:34:12,929 --> 00:34:17,389
第5行，或六，我猜。

588
00:34:17,389 --> 00:34:19,909
然後好了，你
可以直接在這裡指定。

589
00:34:19,909 --> 00:34:22,914
所以20--這會給
你的第一個20行。

590
00:34:22,914 --> 00:34:24,830
實際上我是那種
的驚訝，這

591
00:34:24,830 --> 00:34:28,770
給我6所以讓我繼續前進
並檢查iris--或頭部，對不起。

592
00:34:28,770 --> 00:34:31,699

593
00:34:31,699 --> 00:34:34,960
在這裡，它會給
您的文檔

594
00:34:34,960 --> 00:34:37,960
價值頭上做什麼。

595
00:34:37,960 --> 00:34:40,839
因此，它返回第一個
或最後一個對象。

596
00:34:40,839 --> 00:34:42,630
然後我要去
看一下默認值。

597
00:34:42,630 --> 00:34:47,340
然後它說的默認
法頭x和n等於6L。

598
00:34:47,340 --> 00:34:50,620
因此，這將返回前六要素。

599
00:34:50,620 --> 00:34:55,050
同樣，如果你​​在這裡看到的，我
沒有指定n等於6。

600
00:34:55,050 --> 00:34:56,840
默認情況下它使用6，我猜。

601
00:34:56,840 --> 00:35:00,130
然後，如果我要指定一個特定的
值，那麼我可以查看這一點。

602
00:35:00,130 --> 00:35:02,970

603
00:35:02,970 --> 00:35:10,592
>> 所以這是一些簡單的命令和
這裡的另一個這just--好，

604
00:35:10,592 --> 00:35:12,550
我can--這實際上是
稍微複雜一些，

605
00:35:12,550 --> 00:35:17,130
但是這只是走班
虹膜數據集的每一列。

606
00:35:17,130 --> 00:35:20,910
因此，這將告訴你什麼是所有這些
列是在它們的類型的條款。

607
00:35:20,910 --> 00:35:23,665
所以，萼片長數字，
萼片寬度的數字。

608
00:35:23,665 --> 00:35:26,540
所有這些值都只是數字
因為你可以從這個數據

609
00:35:26,540 --> 00:35:29,440
組織這些都是
一切都將數字。

610
00:35:29,440 --> 00:35:34,310
>> 和物種列
將是一個因素。

611
00:35:34,310 --> 00:35:37,270
所以通常情況下，你會認為
這就像一個字符串。

612
00:35:37,270 --> 00:35:48,830
但如果你只是做irisSpecies，
然後我會做的頭5，

613
00:35:48,830 --> 00:35:51,820
並且這是要打印
出的前五個值。

614
00:35:51,820 --> 00:35:54,150
>> 然後注意到這個水平。

615
00:35:54,150 --> 00:35:58,870
因此，這是saying--這為R的方式
具有分類變量。

616
00:35:58,870 --> 00:36:03,765
因此，而不是僅僅
具有文字串，

617
00:36:03,765 --> 00:36:06,740
它具有指定的水平
其中，這些東西都是。

618
00:36:06,740 --> 00:36:12,450
>> 所以我們可以說irisSpecies 1。

619
00:36:12,450 --> 00:36:17,690
所以，你想在這裡做什麼，我
子集這一物種列。

620
00:36:17,690 --> 00:36:21,480
因此，這需要的
種柱中，然後

621
00:36:21,480 --> 00:36:23,820
它的索引來獲得的第一個元素。

622
00:36:23,820 --> 00:36:27,140
因此，這應該給你setosa。

623
00:36:27,140 --> 00:36:28,710
它也給你的水平在這裡。

624
00:36:28,710 --> 00:36:32,812
>> 所以，你也可以比較
這向字符setosa

625
00:36:32,812 --> 00:36:34,645
而這是不會
為TRUE，因為一個

626
00:36:34,645 --> 00:36:37,940
是一種不同的類型中的另一個。

627
00:36:37,940 --> 00:36:40,590
或者，我想這是真的，因為ř
比這更聰明。

628
00:36:40,590 --> 00:36:45,420
它著眼於這一點，然後
說，也許這就是你想要的。

629
00:36:45,420 --> 00:36:51,860
所以它會說字符
串setosa是一樣的這一個。

630
00:36:51,860 --> 00:37:01,290
然後同樣，您可以
也正好抓住這些像等。

631
00:37:01,290 --> 00:37:05,580
>> 所以這只是某種
數據集的快速指令。

632
00:37:05,580 --> 00:37:08,030
因此，這裡的一些數據的探索。

633
00:37:08,030 --> 00:37:11,360
所以這是一個多一點
涉及數據分析。

634
00:37:11,360 --> 00:37:18,340
這是從一些
集訓在研發在伯克利分校。

635
00:37:18,340 --> 00:37:20,790
>> 所以，國外​​的圖書館。

636
00:37:20,790 --> 00:37:24,880
所以我打算在加載
庫，被稱為外國人。

637
00:37:24,880 --> 00:37:32,460
因此，這是要給我read.dta
所以假設我有這樣的數據集。

638
00:37:32,460 --> 00:37:39,000
這被存儲在當前
我的工作控制台目錄。

639
00:37:39,000 --> 00:37:42,190
所以讓我們只看到了什麼
工作目錄。

640
00:37:42,190 --> 00:37:44,620
>> 因此，這裡是我的工作目錄。

641
00:37:44,620 --> 00:37:50,040
和讀取點的數據，這
的事情，是說這個文件

642
00:37:50,040 --> 00:37:54,650
位於數據文件夾
這個當前工作目錄。

643
00:37:54,650 --> 00:38:00,520
並且read.dta這不是
默認命令。

644
00:38:00,520 --> 00:38:02,760
我想我在裝好了。

645
00:38:02,760 --> 00:38:04,750
IEI假設我已經裝這。

646
00:38:04,750 --> 00:38:08,115
>> 但如此read.dta不會
是一個缺省的命令。

647
00:38:08,115 --> 00:38:11,550
這就是為什麼你將有
在這個庫加載package--

648
00:38:11,550 --> 00:38:14,500
這個包所謂外。

649
00:38:14,500 --> 00:38:16,690
如果你沒有
包，我覺得

650
00:38:16,690 --> 00:38:19,180
外國是內置的一個。

651
00:38:19,180 --> 00:38:31,150
否則，你也可以
做install.packages

652
00:38:31,150 --> 00:38:33,180
這將安裝該軟件包。

653
00:38:33,180 --> 00:38:36,878
這會給你R.哦，不。

654
00:38:36,878 --> 00:38:39,830

655
00:38:39,830 --> 00:38:43,140
然後我只是要阻止
這一點，因為我已​​經擁有它。

656
00:38:43,140 --> 00:38:46,920
>> 但是，什麼是真正好的關於R
的是，包管理

657
00:38:46,920 --> 00:38:48,510
系統是非常優雅。

658
00:38:48,510 --> 00:38:52,470
因為它會保存一切
真的很好你。

659
00:38:52,470 --> 00:38:59,780
所以在這種情況下，這將存儲
它在，我相信，在這裡這個庫。

660
00:38:59,780 --> 00:39:02,390
>> 所以，任何時候你想
安裝新的軟件包，

661
00:39:02,390 --> 00:39:04,980
它只是這麼簡單
做install.packages

662
00:39:04,980 --> 00:39:07,500
和R將管理所有
包你。

663
00:39:07,500 --> 00:39:12,900
所以，你不必做一下
蟒蛇，在那裡你有外包裝

664
00:39:12,900 --> 00:39:15,330
像紙經理
你在哪裡蟒蛇

665
00:39:15,330 --> 00:39:18,310
您安裝doing--的
Python的外面包

666
00:39:18,310 --> 00:39:20,940
然後嘗試自己運行它們。

667
00:39:20,940 --> 00:39:22,210
因此，這是非常好的方式。

668
00:39:22,210 --> 00:39:25,590
>> 和install.packages需要互聯網。

669
00:39:25,590 --> 00:39:31,950
它需要從一個服務器
和存儲庫

670
00:39:31,950 --> 00:39:33,960
收集所有的
包被稱為CRAN。

671
00:39:33,960 --> 00:39:40,690
你可以指定排序鏡
你想從下載的軟件包。

672
00:39:40,690 --> 00:39:43,420
>> 所以在這裡我採取這一數據集。

673
00:39:43,420 --> 00:39:46,240
我讀它使用此功能。

674
00:39:46,240 --> 00:39:49,360
因此，讓我繼續前進，做到這一點。

675
00:39:49,360 --> 00:39:52,900
>> 因此，讓我們假設
你有這樣的數據集

676
00:39:52,900 --> 00:39:55,550
你有絕對的
不知道它是什麼。

677
00:39:55,550 --> 00:39:58,560
這實際上出現
相當經常在業內

678
00:39:58,560 --> 00:40:00,910
在那裡，你只是有這些
噸，噸亂七八糟的東西

679
00:40:00,910 --> 00:40:02,890
他們是令人難以置信的未標記。

680
00:40:02,890 --> 00:40:06,380
所以在這裡我有這個
數據集，我不知道

681
00:40:06,380 --> 00:40:08,400
它是什麼，所以我只是
顯示檢查出來。

682
00:40:08,400 --> 00:40:10,620
>> 所以，我要先做頭。

683
00:40:10,620 --> 00:40:14,190
所以，我檢查了前六
什麼這個數據集列。

684
00:40:14,190 --> 00:40:21,730
因此，這是一個國家，pres04，然後
所有這些不同的排序列。

685
00:40:21,730 --> 00:40:25,612
什麼是有趣的
在這裡，我想，是你

686
00:40:25,612 --> 00:40:27,945
會認為這看起來
像某種選舉。

687
00:40:27,945 --> 00:40:30,482

688
00:40:30,482 --> 00:40:32,190
我想剛剛從
查看文件

689
00:40:32,190 --> 00:40:41,070
名稱這是某種集合
有關候選人或選民數據

690
00:40:41,070 --> 00:40:44,920
誰投票給特定的總統
或總統候選人

691
00:40:44,920 --> 00:40:46,550
在2004年大選。

692
00:40:46,550 --> 00:40:52,920
>> 因此，這裡是值1，2
如此存儲的一種方式

693
00:40:52,920 --> 00:40:56,540
總統候選人
他們的名字。

694
00:40:56,540 --> 00:40:59,780
在這種情況下，它看起來像
他們只是整數值。

695
00:40:59,780 --> 00:41:04,030
所以，2004年，這是布什
與克里相信。

696
00:41:04,030 --> 00:41:09,010
現在，讓我們說你只是不知道
無論是1對應於布什或2

697
00:41:09,010 --> 00:41:11,703
對應於克里或與
等等等等，對不對？

698
00:41:11,703 --> 00:41:15,860
>> 而這，只是為了我，
一個相當普遍的問題。

699
00:41:15,860 --> 00:41:18,230
那麼，你可以在這種情況下怎麼辦？

700
00:41:18,230 --> 00:41:20,000
因此，讓我們檢查所有這些其他的事情。

701
00:41:20,000 --> 00:41:22,790
>> 狀態，我假設這
來自不同的狀態。

702
00:41:22,790 --> 00:41:25,100
partyid收入。

703
00:41:25,100 --> 00:41:27,710
讓我們來看看ID，然後

704
00:41:27,710 --> 00:41:32,800
因此，也許有一件事你可以做的是
看看每個觀察

705
00:41:32,800 --> 00:41:36,250
有共和黨一partyid
還是民主黨或什麼的。

706
00:41:36,250 --> 00:41:38,170
那麼就讓我們來看看什麼是partyid。

707
00:41:38,170 --> 00:41:41,946
>> 所以我要帶
DAT，然後我要去

708
00:41:41,946 --> 00:41:47,960
要做到這一點美元符號
我以前做過運營商

709
00:41:47,960 --> 00:41:50,770
並且這將
子集到該列。

710
00:41:50,770 --> 00:41:57,760
然後我將頭這
20，正好看到了這個樣子。

711
00:41:57,760 --> 00:42:00,170
>> 因此，這只是一堆港定居人士。

712
00:42:00,170 --> 00:42:02,800
因此，換句話說，必須
缺少有關這些人的數據。

713
00:42:02,800 --> 00:42:08,100
但是你也注意到這一點
的DAT partyid是一個因素

714
00:42:08,100 --> 00:42:10,030
所以這給你不同的類別。

715
00:42:10,030 --> 00:42:14,170
因此，換句話說，partyid可以採取
民主黨人，共和黨人，獨立，

716
00:42:14,170 --> 00:42:16,640
還是其他什麼東西。

717
00:42:16,640 --> 00:42:23,940
>> 因此，讓我們繼續前進，讓我們
看到這些is--哦，OK的。

718
00:42:23,940 --> 00:42:28,480
所以，我要子集
以partyid然後

719
00:42:28,480 --> 00:42:32,780
看看哪些是
民主黨人，例如。

720
00:42:32,780 --> 00:42:37,150
這是要給你一個布爾值，
TRUEs和FALSEs巨大布爾。

721
00:42:37,150 --> 00:42:41,630
>> 現在，讓我們說，我想
以子集這些傢伙。

722
00:42:41,630 --> 00:42:47,260
因此，這是要採取我的DAT和
子集的意見為準

723
00:42:47,260 --> 00:42:48,910
有partyid平等等於民主黨。

724
00:42:48,910 --> 00:42:52,830

725
00:42:52,830 --> 00:42:55,180
這是相當長的，因為
有這麼多的人。

726
00:42:55,180 --> 00:42:59,060
所以，現在，我要前往這20。

727
00:42:59,060 --> 00:43:05,690

728
00:43:05,690 --> 00:43:11,270
>> 正如你注意到，等於等號
是在你感興趣的

729
00:43:11,270 --> 00:43:13,250
already--你還包括在NAS。

730
00:43:13,250 --> 00:43:19,010
所以在這種情況下，你仍然不能得到
任何信息，因為現在你有來港定居

731
00:43:19,010 --> 00:43:22,650
而你只是想看看它的
觀察對應民主黨

732
00:43:22,650 --> 00:43:24,670
而不是這些缺失的值本身。

733
00:43:24,670 --> 00:43:27,680
所以，你將如何擺脫這些來港定居的？

734
00:43:27,680 --> 00:43:36,410
>> 所以在這裡我只是用在了我的鑰匙
游標，然後說走動。

735
00:43:36,410 --> 00:43:39,778
然後在這裡我只是去
說is.na datpartyid。

736
00:43:39,778 --> 00:43:48,970

737
00:43:48,970 --> 00:43:52,720
因此，這與和將採取
兩個不同的布爾向量

738
00:43:52,720 --> 00:43:57,160
並說這將是
TRUE和FALSE的例子。

739
00:43:57,160 --> 00:43:59,190
所以它會做這個組件明智的。

740
00:43:59,190 --> 00:44:02,910
所以在這裡我想說的起飛
數據幀，子集

741
00:44:02,910 --> 00:44:10,170
到對應於民主黨人的那些，
並刪除其中的任何不屬於NA。

742
00:44:10,170 --> 00:44:13,540
>> 因此，這will--應
給你的東西。

743
00:44:13,540 --> 00:44:16,540

744
00:44:16,540 --> 00:44:17,600
讓我們來看看is.na.

745
00:44:17,600 --> 00:44:24,670

746
00:44:24,670 --> 00:44:27,690
讓我們試著is.na datpartyid。

747
00:44:27,690 --> 00:44:36,290

748
00:44:36,290 --> 00:44:45,290
這應該給你 - 
sorry--只是一個布爾向量。

749
00:44:45,290 --> 00:44:49,260
然後，因為它是如此漫長，
我要去子集20。

750
00:44:49,260 --> 00:44:49,760
好不好。

751
00:44:49,760 --> 00:44:51,570
所以這應該工作。

752
00:44:51,570 --> 00:44:54,700
>> 而這一次也將是TRUEs。

753
00:44:54,700 --> 00:45:01,830
啊，所以我在這裡的錯誤是I'm--我
使用C ++和R互換，所以我做

754
00:45:01,830 --> 00:45:03,590
這個錯誤的所有時間。

755
00:45:03,590 --> 00:45:05,807
在與運營商的
其實你想要的。

756
00:45:05,807 --> 00:45:08,140
不希望使用兩個
＆符號，只是一個單一的之一。

757
00:45:08,140 --> 00:45:14,970

758
00:45:14,970 --> 00:45:17,010
好不好。

759
00:45:17,010 --> 00:45:18,140
>> 所以，讓我們來看看。

760
00:45:18,140 --> 00:45:20,930

761
00:45:20,930 --> 00:45:23,920
所以我們子集化的
partyid他們是民主黨

762
00:45:23,920 --> 00:45:25,300
而他們沒有缺失值。

763
00:45:25,300 --> 00:45:27,690
現在讓我們來看看
哪些，他們投票支持。

764
00:45:27,690 --> 00:45:31,530
因此，它似乎最喜歡的
他們投票支持1。

765
00:45:31,530 --> 00:45:36,090
所以我要繼續前進
並說這是克里。

766
00:45:36,090 --> 00:45:39,507
>> 同樣，你可以
還去共和黨

767
00:45:39,507 --> 00:45:41,090
並希望，這應該給你2。

768
00:45:41,090 --> 00:45:49,730

769
00:45:49,730 --> 00:45:51,770
這只是一堆不同的列。

770
00:45:51,770 --> 00:45:53,070
事實上，這是2。

771
00:45:53,070 --> 00:45:55,750
所以partyid所有共和黨，
他們大多​​投票支持2。

772
00:45:55,750 --> 00:45:58,390
>> 所以它看起來，只是
通過看這個，

773
00:45:58,390 --> 00:46:00,600
共和黨將是
一個very--或partyid

774
00:46:00,600 --> 00:46:02,790
將是一個非常
在確定大因素

775
00:46:02,790 --> 00:46:05,420
哪位候選人，他們是
會投票支持。

776
00:46:05,420 --> 00:46:07,120
這是一般的明顯事實。

777
00:46:07,120 --> 00:46:10,139
這符合您的
直覺的，當然。

778
00:46:10,139 --> 00:46:11,930
如此看來像我
時間不多了這樣

779
00:46:11,930 --> 00:46:17,040
讓我應該繼續
並展示一些快速的圖像。

780
00:46:17,040 --> 00:46:21,120
因此，這裡的東西是輕微
更複雜的可視化。

781
00:46:21,120 --> 00:46:26,450
所以在這種情況下，這是一個很
簡單只是檢查分析什麼

782
00:46:26,450 --> 00:46:28,500
'04總統是。

783
00:46:28,500 --> 00:46:33,920
>> 所以在這種情況下，假設你
要回答這個問題。

784
00:46:33,920 --> 00:46:38,540
因此，假設我們想知道投票
在2004年的總統選舉中的行為

785
00:46:38,540 --> 00:46:41,170
以及如何通過不同的比賽。

786
00:46:41,170 --> 00:46:44,380
所以，你不僅要
看到投票行為，

787
00:46:44,380 --> 00:46:47,860
但你希望每個來子集
那種種族和總結了。

788
00:46:47,860 --> 00:46:50,770
你只能告訴
通過這種複雜的符號

789
00:46:50,770 --> 00:46:52,580
這是一種越來越朦朧。

790
00:46:52,580 --> 00:46:56,390
>> 這樣的更先進的研發1
包是最近也是一種

791
00:46:56,390 --> 00:47:00,070
被稱為dplyr。

792
00:47:00,070 --> 00:47:03,060
所以它是這一個就在這裡。

793
00:47:03,060 --> 00:47:08,080
和ggg-- ggplot2是一個不錯的
做更好的可視化方式

794
00:47:08,080 --> 00:47:09,400
比內置於一體。

795
00:47:09,400 --> 00:47:11,108
>> 所以我要加載
這兩個庫。

796
00:47:11,108 --> 00:47:13,200

797
00:47:13,200 --> 00:47:16,950
然後，我會去
提前並運行此命令。

798
00:47:16,950 --> 00:47:19,050
你可以把它當作一個黑盒子。

799
00:47:19,050 --> 00:47:23,460
>> 這是怎麼回事的是，這條管道
運營商正在通過這一說法

800
00:47:23,460 --> 00:47:24,110
到這裡。

801
00:47:24,110 --> 00:47:28,070
所以我說GROUP BY DAT
種族和當時的總統04。

802
00:47:28,070 --> 00:47:31,530
然後，所有這些其他命令
被過濾，然後總結

803
00:47:31,530 --> 00:47:34,081
在那裡我做的數量和
然後我繪製在這裡。

804
00:47:34,081 --> 00:47:39,980

805
00:47:39,980 --> 00:47:42,500
OK涼爽。

806
00:47:42,500 --> 00:47:44,620
因此，讓我們繼續前進，
看看這是什麼樣子。

807
00:47:44,620 --> 00:47:52,280

808
00:47:52,280 --> 00:47:57,290
>> 因此，這裡發生了什麼，是我
剛才繪製的每個種族和然後

809
00:47:57,290 --> 00:47:59,670
哪些，他們投票支持。

810
00:47:59,670 --> 00:48:03,492
與這兩個不同的
值對應於2和1。

811
00:48:03,492 --> 00:48:05,325
如果你想更
優雅的，你也可以

812
00:48:05,325 --> 00:48:11,770
只是指定2 Kerry--或
2是布什，然後1克里。

813
00:48:11,770 --> 00:48:13,700
你也可以擁有
在你的傳奇。

814
00:48:13,700 --> 00:48:17,410
>> 而且你還可以拆分這些柱狀圖。

815
00:48:17,410 --> 00:48:19,480
因為有一件事是
，如果你注意到，

816
00:48:19,480 --> 00:48:24,560
這不是很容易識別
其中這兩個值都較大。

817
00:48:24,560 --> 00:48:27,920
這麼一件事，你會想
做的是利用這個藍色區域

818
00:48:27,920 --> 00:48:31,855
，只是將它在這裡等你
可通過側比較這兩個側面。

819
00:48:31,855 --> 00:48:34,480
我想這是我的東西
沒有時間做的事情，

820
00:48:34,480 --> 00:48:36,660
但是這也很容易做到。

821
00:48:36,660 --> 00:48:40,310
你可以看看
手冊頁ggplot的。

822
00:48:40,310 --> 00:48:47,170
所以，你可以做ggplot像
這一點，讀入該手冊頁。

823
00:48:47,170 --> 00:48:51,920
>> 所以，讓我迅速
告訴你一些很酷的事情。

824
00:48:51,920 --> 00:48:57,610
讓我們繼續前進，去to--只是一個
應用機器學習。

825
00:48:57,610 --> 00:49:02,450
因此，讓我們說我們有這三個
封裝所以我打算在加載這些。

826
00:49:02,450 --> 00:49:05,500

827
00:49:05,500 --> 00:49:09,170
因此，這只是輸出一些
信息後，我裝的東西。

828
00:49:09,170 --> 00:49:15,220
所以我說這句話的read.csv，
此數據集，現在

829
00:49:15,220 --> 00:49:18,940
我要繼續前進，並期待和
看看這是什麼數據集內。

830
00:49:18,940 --> 00:49:22,080
>> 因此，第一個20的觀察。

831
00:49:22,080 --> 00:49:27,190
所以我只是有X1，X2，和Y.因此，
似乎像一堆這些值

832
00:49:27,190 --> 00:49:31,640
是從也許20到80左右。

833
00:49:31,640 --> 00:49:37,700
然後同樣的X2，然後
此ý似乎是標籤0和1。

834
00:49:37,700 --> 00:49:49,500
>> 為了驗證這一點，我可以
只是做匯總數據X1。

835
00:49:49,500 --> 00:49:51,660
然後同樣的
所有這些其他列。

836
00:49:51,660 --> 00:49:55,300
所以總結的快捷方式
只是顯示你快速的價值觀。

837
00:49:55,300 --> 00:49:56,330
哦，對不起。

838
00:49:56,330 --> 00:49:58,440
這應該是Y.

839
00:49:58,440 --> 00:50:03,420
>> 所以在這種情況下，給出了
分位數，中位數，馬克塞斯為好。

840
00:50:03,420 --> 00:50:07,130
在這種情況下，DATAY，可以看到
它只是將是0和1。

841
00:50:07,130 --> 00:50:10,100
也平均在說
0.6，只是意味著它

842
00:50:10,100 --> 00:50:13,380
好像我比0以上1秒。

843
00:50:13,380 --> 00:50:16,160
>> 因此，讓我繼續前進，顯示
你這是什麼樣子。

844
00:50:16,160 --> 00:50:17,470
所以我只是要繪製這樣。

845
00:50:17,470 --> 00:50:22,852

846
00:50:22,852 --> 00:50:24,636
讓我們來看看如何清除此。

847
00:50:24,636 --> 00:50:30,492

848
00:50:30,492 --> 00:50:31,468
哦確定。

849
00:50:31,468 --> 00:50:35,840

850
00:50:35,840 --> 00:50:36,340
好不好。

851
00:50:36,340 --> 00:50:37,590
>> 因此，這是什麼樣子。

852
00:50:37,590 --> 00:50:46,310
所以好像我指定的黃色
為0，然後衝我指定為1秒。

853
00:50:46,310 --> 00:50:52,190
所以在這裡它看起來像
標註點和它

854
00:50:52,190 --> 00:50:56,410
好像你只是想要一些
這類群集在此的。

855
00:50:56,410 --> 00:51:01,020
>> 並讓我繼續前進，顯示
您其中的一些內置的功能。

856
00:51:01,020 --> 00:51:03,580
因此，這裡是流明。

857
00:51:03,580 --> 00:51:06,060
因此，這只是試圖
以適應線路於此。

858
00:51:06,060 --> 00:51:08,640
那麼，什麼是最好的方法
我能適應這樣的行

859
00:51:08,640 --> 00:51:14,020
它將最好分開
這種集群。

860
00:51:14,020 --> 00:51:21,790
理想情況下，你可以看到
我只是運行這些命令

861
00:51:21,790 --> 00:51:25,450
然後，我要去
提前並添加行。

862
00:51:25,450 --> 00:51:28,970
>> 因此，這似乎是最好的猜測。

863
00:51:28,970 --> 00:51:34,150
它採取的最好的一個最小化
在試圖將這一行的錯誤。

864
00:51:34,150 --> 00:51:40,000
很顯然，這看起來種
不錯，但不是最好的。

865
00:51:40,000 --> 00:51:43,130
和線性模型，在
一般情況下，將要

866
00:51:43,130 --> 00:51:46,811
真正偉大的理論，只是排序
機器的建築基礎的

867
00:51:46,811 --> 00:51:47,310
學習。

868
00:51:47,310 --> 00:51:50,330
但在實踐中，你會
想要做一些更普遍。

869
00:51:50,330 --> 00:51:54,280
>> 所以，你可以嘗試運行
一些所謂的神經網絡。

870
00:51:54,280 --> 00:51:57,110
這些東西
越來越普遍。

871
00:51:57,110 --> 00:52:00,530
他們只是工作飛馳
用於大型數據集。

872
00:52:00,530 --> 00:52:07,080
因此，在這種情況下，我們僅have--
讓我們see--我們有nrow。

873
00:52:07,080 --> 00:52:09,010
所以nrow只是說行數。

874
00:52:09,010 --> 00:52:11,790
因此，在這種情況下，我
有100個觀測值。

875
00:52:11,790 --> 00:52:15,010
>> 因此，讓我繼續前進，
使一個神經網絡。

876
00:52:15,010 --> 00:52:18,620
因此，這是非常好的
因為我只能說NNET

877
00:52:18,620 --> 00:52:21,767
然後我回歸Y.
所以Y是該列。

878
00:52:21,767 --> 00:52:23,850
然後回歸它
其他兩個變量。

879
00:52:23,850 --> 00:52:27,360
因此，這是短
符號為X1和X2。

880
00:52:27,360 --> 00:52:29,741
>> 因此，讓我們繼續前進並運行此。

881
00:52:29,741 --> 00:52:30,240
哦，對不起。

882
00:52:30,240 --> 00:52:32,260
我需要運行這件事。

883
00:52:32,260 --> 00:52:37,500
而這僅僅是印刷符號
如何迅速或不能很快就

884
00:52:37,500 --> 00:52:38,460
收斂。

885
00:52:38,460 --> 00:52:41,420
所以看起來它沒有收斂。

886
00:52:41,420 --> 00:52:44,970
因此，讓我繼續前進，打印
出了這個樣子。

887
00:52:44,970 --> 00:52:51,260
>> 看到這裡的圖片，這裡是
輪廓呈現，以及它如何適應。

888
00:52:51,260 --> 00:52:56,380
這是just--你可以看到
這一點，這是非常，非常漂亮。

889
00:52:56,380 --> 00:52:59,400
它甚至可能是
過學習，但你也可以

890
00:52:59,400 --> 00:53:03,390
考慮到這一點與其他
技術，如交叉驗證。

891
00:53:03,390 --> 00:53:06,180
而這些也被內置到R.

892
00:53:06,180 --> 00:53:09,170
>> 並讓我告訴你
支持向量機。

893
00:53:09,170 --> 00:53:12,470
這是另一種常見的真
技術，機器學習。

894
00:53:12,470 --> 00:53:18,550
它是非常相似的線性模型，但
它使用什麼叫做核方法。

895
00:53:18,550 --> 00:53:22,790
讓我們來看看如何好，做。

896
00:53:22,790 --> 00:53:26,430
所以這個人是非常類似於如何
還有一個神經網絡進行，

897
00:53:26,430 --> 00:53:27,900
但它更順暢。

898
00:53:27,900 --> 00:53:35,740
而這是基於關
對what--支持向量機是如何工作的。

899
00:53:35,740 --> 00:53:40,250
>> 所以，這只是一個非常
一些快速概述

900
00:53:40,250 --> 00:53:43,822
的內置功能，你可以做
而也有一些數據探索。

901
00:53:43,822 --> 00:53:45,905
所以，讓我繼續前進
並返回到幻燈片。

902
00:53:45,905 --> 00:53:50,290

903
00:53:50,290 --> 00:53:53,670
>> 所以，很顯然，這是
不是很全面。

904
00:53:53,670 --> 00:53:57,140
這真的只是一個傳情
顯示你什麼，你真的可以做R.

905
00:53:57,140 --> 00:53:59,100
所以，如果你只是想
要了解更多信息，點擊這裡

906
00:53:59,100 --> 00:54:01,210
是一群不同的資源。

907
00:54:01,210 --> 00:54:06,890
>> 所以，如果你喜歡的教科書或者你
只是喜歡閱讀網上的東西，

908
00:54:06,890 --> 00:54:09,670
那麼這是一個夢幻般的
一個接哈德利韋翰，

909
00:54:09,670 --> 00:54:13,010
誰也創造了這一切
真的很酷包。

910
00:54:13,010 --> 00:54:17,420
如果你喜歡的視頻，然後
伯克利有一個真棒集訓

911
00:54:17,420 --> 00:54:21,060
這是several--這是種很長。

912
00:54:21,060 --> 00:54:24,210
它會教你幾乎
一切你想知道R.

913
00:54:24,210 --> 00:54:27,770
>> 同樣，還有Codeacademy
而所有這些其他類型

914
00:54:27,770 --> 00:54:29,414
互動網站。

915
00:54:29,414 --> 00:54:31,580
它們也越來越
common--越來越普遍。

916
00:54:31,580 --> 00:54:33,749
所以，這是非常相似Codeacademy。

917
00:54:33,749 --> 00:54:35,790
最後，如果你只是
希望社區和幫助，

918
00:54:35,790 --> 00:54:38,800
這些都是一堆
事情你可以去。

919
00:54:38,800 --> 00:54:40,880
很顯然，我們仍然
使用郵件列表，只

920
00:54:40,880 --> 00:54:44,860
像幾乎所有其他
編程語言社區。

921
00:54:44,860 --> 00:54:47,880
和#rstats，這是
我們的社區微博。

922
00:54:47,880 --> 00:54:49,580
這實際上相當普遍。

923
00:54:49,580 --> 00:54:50,850
然後用戶！

924
00:54:50,850 --> 00:54:52,340
只是我們的會議。

925
00:54:52,340 --> 00:54:55,390
>> 然後，當然，你可以
使用所有這些其他的Q＆A的事，

926
00:54:55,390 --> 00:54:57,680
像堆棧溢出，
谷歌，然後GitHub上。

927
00:54:57,680 --> 00:55:00,490
因為大多數這些包
和很多社區

928
00:55:00,490 --> 00:55:03,420
圍繞發展將集中
代碼，因為它是開源的。

929
00:55:03,420 --> 00:55:05,856
它只是真的在GitHub上好看。

930
00:55:05,856 --> 00:55:08,730
最後，你可以，如果我聯繫
你只要有任何簡單的問題。

931
00:55:08,730 --> 00:55:13,530
所以，你可以找到我的Twitter在這裡，
我的網站，只是我的電子郵件。

932
00:55:13,530 --> 00:55:17,840
所以希望，這是
something--只有很短的傳情

933
00:55:17,840 --> 00:55:20,900
什麼R是真正能夠做到的事情。

934
00:55:20,900 --> 00:55:23,990
並希望，你只要
看看這三個環節

935
00:55:23,990 --> 00:55:25,760
看看你可以做更多。

936
00:55:25,760 --> 00:55:28,130
我想這只是它。

937
00:55:28,130 --> 00:55:28,630
謝謝。

938
00:55:28,630 --> 00:55:30,780
>> [掌聲]

939
00:55:30,780 --> 00:55:31,968