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，但我
感觉rst​​udio是优秀的只是

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