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
ダスティン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
そのようにRでのデータ分析は、
本当に基本的なものを

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
>> そしてそれはまた、本当に良いことだ
ウェブの視覚化のために。

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は、組み込み定数の束を持って
あなたが頻繁にπ電子のように使用しますことを。

119
00:06:51,870 --> 00:06:56,230
>> そして、ここでは7プラスだ
runif、1のrunifそう。

120
00:06:56,230 --> 00:07:02,450
これはのは、生成する関数である
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
中のSO典型的な割り当​​て
Rは矢印で行われます

133
00:07:40,830 --> 00:07:43,440
そのためには、より小さく、その後ハイフンです。

134
00:07:43,440 --> 00:07:47,250
だからここに私はちょうど割り当てています
変数valにする3。

135
00:07:47,250 --> 00:07:50,160
>> そして私はヴァルをプリントアウトしてい
そしてそれは3を出力します。

136
00:07:50,160 --> 00:07:53,920
Rインタプリタでデフォルトでは、
あなたのために物事を印刷します

137
00:07:53,920 --> 00:07:57,280
だから、ヴァルを印刷指定する必要はありません
いつでもあなたが何かを印刷したい。

138
00:07:57,280 --> 00:08:00,200
あなただけのヴァルを行うことができますし、
それはあなたのためにそれをやる。

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
演算子とequals
割り当てのオペレーター。

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
その後なぜならそして、これは本当に素晴らしい
あなただけのヴァルへのベクトルを割り当てる

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
また、デフォルトでは、すべての
数は2倍になります。

156
00:09:07,390 --> 00:09:13,150
>> ですから、1.1、3のCを持っている場合、
5.7負、cは関数である。

157
00:09:13,150 --> 00:09:16,760
これは、すべての3つを連結
ベクターへの数字。

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
そして、私はそれらのうちの2つを指定しています。

165
00:09:38,360 --> 00:09:43,840
だから私はにそれを割り当てる、RNORM 2をやっている
開発者は、その後、私は開発者をプリントアウトよ。

166
00:09:43,840 --> 00:09:47,350
したがって、これらは、ちょうど2つである
ランダム正常値。

167
00:09:47,350 --> 00:09:50,060
>> そして、あなたがしなければintの
あなたは、整数を気に。

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'Sを追加することができます
その後、またはそれの間に

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
だから、再び、私は連結よ
3つの文字列この時間。

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
あなたをshow--に行く
ちょうど二重の文字列を持っている

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
そして、再び、私は連結よ
彼らとその後boolsに割り当てる。

194
00:11:22,370 --> 00:11:24,590
だから、boolsはショーになるだろう
あなたは、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
これはsequence--と呼ばれている
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
>> だから、心に留めておくべき一つのことです
1から開始することで、そのRインデックス。

203
00:11:55,770 --> 00:12:00,550
ヴァルスSO 3が提供するつもりされている
あなた番目の要素。

204
00:12:00,550 --> 00:12:04,580
これは一種の異なる他からです
それはゼロから始まる言語。

205
00:12:04,580 --> 00:12:09,780
そのようにCまたはC ++で、たとえば、だ
4番目の要素を取得するつもり。

206
00:12:09,780 --> 00:12:13,280
>> そして、ここでは3〜5のvalsある。

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
私は、第三を取得するためにインデックスを作成してい
第4、第5の要素。

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
だからここにその後ヴァルスとある
第1、第3、及び第6の要素。

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
あなたにはありませんすべてを与える
第1、第3、または第6要素。

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
これが真の3回繰り返します。

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は連結しようとしている
一緒にそれらの2ブール値。

227
00:13:21,280 --> 00:13:24,090
だから、3を取得するつもりだ
TRUEsその後4 FALSEs。

228
00:13:24,090 --> 00:13:28,460
>> ときにインデックスヴァルスように、あなたがしている
、TRUE、TRUE TRUEを取得するつもり。

229
00:13:28,460 --> 00:13:31,420
だから、イエスと言うだろう、
私はそれらの3つの要素をしたい。

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
>> そして、私はここにタイプミスが実際にそこだと思う
このため、3リピートがTRUEと言っている

233
00:13:41,490 --> 00:13:47,990
そして、技術的にあなたをFALSE 4を繰り返し、
唯一の6つの要素は非常に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
3通常のランダム
値、およびその後場合

244
00:14:22,950 --> 00:14:27,400
実行自分でset.seed
同じ値42を使用しているコンピュータ、

245
00:14:27,400 --> 00:14:30,990
その後も取得
同じ3ランダム法線。

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
>> そしてそうベクトル化代入
ここ2にヴァルス1を示している。

254
00:14:53,910 --> 00:14:59,290
だから、最初の2つの要素を取り
0に割り当て、その後ヴァルスのと。

255
00:14:59,290 --> 00:15:03,940
そして、あなたはまた、単に行うことができます
ブールと同じようなもの。

256
00:15:03,940 --> 00:15:09,340
>> だから、ヴァルスは、この意志を0--と等しくない
TRUE、FALSE、あなたにベクトルFALSEを与える

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
のような低レベル言語でやっなど
Rのループのために行うのではなく

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
だから私は3に値1を生成しています、
割り当てることVEC1に、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
>> VEC1回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
だから、この中で、TRUE FALSE FALSEです
ケース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
そして、それは最も基本的なの一種です
Rオブジェクトがあるため、ベクターを与え

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
またはあなたはそれを考慮することができます
各1として行です。

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
>> また、心に留めておくべきことの一つは、ということです
Rは列優先の形式で値を格納する。

295
00:17:29,250 --> 00:17:34,160
換言すれば、あなたは1を見たとき
9に、それはthem--保存するために起こっている

296
00:17:34,160 --> 00:17:36,370
それは、2、1になるだろう
最初の列の3、

297
00:17:36,370 --> 00:17:38,510
そして、それはやる4,5
2列目の6、

298
00:17:38,510 --> 00:17:41,440
その後7,8、3列目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
そのように最初の行を掛ける
第2の行列の最初の列

311
00:18:29,380 --> 00:18:34,510
のでon--あなたが使用する
このパーセントの操作。

312
00:18:34,510 --> 00:18:38,110
>> そして、マットのtはちょうどです
転置するための操作。

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.リストの4つの不可欠のオブジェクト

334
00:19:52,970 --> 00:19:55,820
ただのを収集します
その他の目的は、あなたが欲しい。

335
00:19:55,820 --> 00:20:00,130
だから、1にこれを格納します
あなたは簡単にアクセスすることができます変数。

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
だから私は、1つの要素を持っているつもりだ
リストは、これを原料と呼ばれ、

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
これは4と終了行に1
2、SO 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-- Aを持っている
タイプ内タイプ。

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
しかし、あなたはどれだけのことを分からない場合は、
作品は、あなただけのLMの助けを行うことができます

361
00:21:20,340 --> 00:21:24,610
それはあなたにいくつかをあげる
ドキュメントのソートこと

362
00:21:24,610 --> 00:21:27,960
種類のように見える
Unixの、中のmanページ

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
ID 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
そして、あなたがすることもできます
2を比較して、それは本当だ。

414
00:24:34,170 --> 00:24:38,350
だから私は、xの場合IDをチェックしてい
等号xと通告に等しい

415
00:24:38,350 --> 00:24:39,760
それはあなたに2 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
その後、2つを取り
当時の引数。

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
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
>> ダスティン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
だから私は、Controlキーを入力してやっている。

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
OK。

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--場合、私は起こる
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。

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
>> だから、そのようにデフォルトで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--するつもりです
これがFALSEであることを前提とする。

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
この最後の1を返すつもり。

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
>> それでは、あなたは、元を持っていたとしましょう
他の場合に1が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
だから私は、1〜6または9 cはbounded.compareできる
その後、私は、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
私は私が実際に持っているとは思わない
Wi-Fiは、ここので、私はちょうど先に行きましょう

567
00:32:59,700 --> 00:33:01,970
と私は推測し、この1をスキップします。

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
ので、それらの1つは
アイリスデータセットと呼ばれる。

572
00:33:15,770 --> 00:33:18,910
これは最もよく知られているの一つである
機械学習でのもの。

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行、または私は推測6。

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
だから、これは最初の6つの要素を返します。

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--よくだ別の1です、

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
これは、印刷しようとしている
最初の5つの値から。

614
00:35:51,820 --> 00:35:54,150
>> そして、このレベルに気づく。

615
00:35:54,150 --> 00:35:58,870
これはRの方法ですsaying--ようにするためです
のカテゴリ変数を持つ。

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
これは行っていない
1ので、真である

626
00:36:34,645 --> 00:36:37,940
他の異なるタイプのものである。

627
00:36:37,940 --> 00:36:40,590
または私はRので、それが真実であると思います
それよりも、よりインテリジェントである。

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
これはいくつかから取得され
バークレーのためのRでBootcampの。

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
だから、中に何かをする必要はありません
あなたが外部のパッケージを持っているのPython、

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
だから私は、最初の6をチェック
このデータセットが何であるかの列。

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
そして今、あなたが、単に知らないとしましょう
ブッシュまたは2に1対応しているかどうか

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
それではのPartyIdを見てみましょう。

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
>> だから、これはNASのちょうど束である。

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
この場合には、あなたはまだ取得することはできません
今あなたは、NASを持っているので、すべての情報

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
それでは、どのように、これらのNASの取り除くでしょうか？

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
そして、これは与える必要がありyou--
ただブールベクトルをsorry--。

749
00:44:45,290 --> 00:44:49,260
そして、それはとても長いですので、
私は20にサブセットするつもりです。

750
00:44:49,260 --> 00:44:49,760
OK。

751
00:44:49,760 --> 00:44:51,570
だから、これは動作するはずです。

752
00:44:51,570 --> 00:44:54,700
>> そして、この1はまたTRUEsになります。

753
00:44:54,700 --> 00:45:01,830
ここに私のエラーがI'm--私ということですので、ああ
C ++とRは同じ意味ので、私はmakeを使用

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
次の2つを使用する必要はありません
アンパサンド、単一1。

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

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

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
>> だから、より高度なRの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
だから私は、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
これを特定するのは非常に簡単ではありません
これら2つの値のどちらが大きいです。

817
00:48:24,560 --> 00:48:27,920
だから、あなたがしたいと思います一つのことは、
何この青い部分を取ることです。

818
00:48:27,920 --> 00:48:31,855
ちょうどあなたのでここでそれを上に移動
サイドことによって、これらの2つの側面を比較することができます。

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のmanページ。

822
00:48:40,310 --> 00:48:47,170
だから、同じようにggplot行うことができます
それとはこのmanページに読み込ま。

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
それでは、我々はこれらの3を持っているとしましょう
パッケージは、私は、これらをロードするつもりです。

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、次いで
このYは、ラベル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
この1はYであるべき

839
00:49:58,440 --> 00:50:03,420
>> したがって、この場合には、得られる
分位、中央値、同様にmaxes。

840
00:50:03,420 --> 00:50:07,130
この場合、データYは、あなたが見ることができます
それだけで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
OKああ。

849
00:50:31,468 --> 00:50:35,840

850
00:50:35,840 --> 00:50:36,340
OK。

851
00:50:36,340 --> 00:50:37,590
>> だから、これはそれがどのように見えるかです。

852
00:50:37,590 --> 00:50:46,310
だから、私は指定されたイエローのように思える
0、その後赤のように私は1Sとして指定。

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
だからここLMである。

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--
のは、我々はnrowを持ってsee--てみましょう。

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
したがって、この1はどのように非常に似ています
よくニューラルネットワークは、実行

897
00:53:26,430 --> 00:53:27,900
しかしそれははるかにスムーズにだ。

898
00:53:27,900 --> 00:53:35,740
そして、これはオフ基づいています
what--方法のSVMの仕事。

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
あなたがビデオが好きなら、その後
バークレーは素晴らしいBootcampのを持ってい

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、これは
私たちのコミュニティのTwitter。

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