R言語入門


ベクターの語源はラテン語のvectorらしいです。ベクトル。英語読みでベクター。なんと、数学のベクトル(vector)と、割り込みベクターのベクター(vector)は同じものだったんですね。vectorですが、ラテン語で「運ぶ」という意味らしいです。学校で習うベクトルは、方向と長さを表すもんだ、と漠然と理解してはいたのですが、実は、方向、長さという二つの情報をまとめておく箱、みたいなものだったんです。

R言語は、ベクトルを使うのが楽しくなる言語です。

スポンサーリンク

R言語 インストール

LinuxへR言語をインストールするのは簡単です。

# apt-get install r-base

起動は、ただ「R」と入力します。

takk@deb9:~/tmp$ R

R version 3.3.3 (2017-03-06) -- "Another Canoe"
Copyright (C) 2017 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R は、自由なソフトウェアであり、「完全に無保証」です。
一定の条件に従えば、自由にこれを再配布することができます。
配布条件の詳細に関しては、'license()' あるいは 'licence()' と入力してください。

R は多くの貢献者による共同プロジェクトです。
詳しくは 'contributors()' と入力してください。
また、R や R のパッケージを出版物で引用する際の形式については
'citation()' と入力してください。

'demo()' と入力すればデモをみることができます。
'help()' とすればオンラインヘルプが出ます。
'help.start()' で HTML ブラウザによるヘルプがみられます。
'q()' と入力すれば R を終了します。

>

起動時の説明にある通り、終了するには、q()を実行することを覚えておきましょ。
では、使っていきます。まずはオブジェクトの代入から。
代入には”<-“を使います。

> a <- 10

R言語は関数も含めすべてがオブジェクトですので、aもオブジェクトとなります。
値を確認してみましょう。

> a
[1] 10
>

“=”や”assign”関数も使えます。

> b = 20
> b
[1] 20
>

関数を使用するには、()で囲みます。

> assign ('c',30)
> c
[1] 30
>

変数の値は、変数名を入力するだけで確認できます。;(セミコロン)を使うと、一行に複数記述できます。

> a;b;c
[1] 10
[1] 20
[1] 30
>

四則演算はそのまま書けます。

> -1 - (a + b * c) / 2
[1] -306
>

数列を作成するには、c()関数を使います。R言語ではベクトルと呼びます。

> c(1,2,3)
[1] 1 2 3
>

なぜベクトルを作るのに、c()関数なんでしょう。cは、concatenateするのcの意味です。c()関数を使った結果、ベクトルになるだけなのです。

> a <- c (1,2,3)
> b <- c (4,5,6)
> c (a,b)
[1] 1 2 3 4 5 6
>

連続する数列は:(コロン)を使うことで簡単に作れます。

> 1:10
 [1]  1  2  3  4  5  6  7  8  9 10
>

さて、ずっと気になっている結果を表示する際の[1]についてですが、これは、その行の一番最初の要素がベクトルの何番目であるかを示しています。
1~100までの数列を作ると確認できます。

> 1:100
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
 [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
 [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
 [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
 [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100
>

101~200だとこのような結果です。

> 101:200
  [1] 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
 [19] 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
 [37] 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
 [55] 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
 [73] 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
 [91] 191 192 193 194 195 196 197 198 199 200
>

代入したオブジェクトの一覧を得るには、ls()を使います。

> a <- 10
> b <- 20
> c <- 30
> d <- 40
> ls()
[1] "a" "b" "c" "d"
>

R言語 ベクトル

ベクトルを使っていきたいと思います。R言語のベクトルは、複数の要素が格納できるオブジェクトです。他言語でいうところのリストや配列に当たります。
他言語で最初の要素のアクセスは、a[0] = 10、というように、0始まりの番号を使いますが、R言語では、1始まりの番号を使います。オブジェクトaの最初の要素は、a[1]となります。BASICでいうと、OPTION BASE 1の状態です。ただし、Rで起動した直後の状態では、aというオブジェクトは存在しません。

> a[1]=10
 a[1] = 10 でエラー:  オブジェクト 'a' がありません
>

aをベクトルとして初期化するには、vector関数を使います。

> a = vector()

こうすることで、aがベクトルとなりましたので、添え字を使ってアクセス可能となります。

> a[1] = 10
> a
[1] 10
>

先頭から順に入れていかないと、NA(Not Available)(欠損値)になります。

> a[3] = 30
> a
[1] 10 NA 30
>

ベクトル要素の追加は、添え字ではなく、append関数を使った方がよいでしょう。

> b = vector()
> b = append(b,10)
> b = append(b,20)
> b
[1] 10 20
>

ベクトル内の全要素は、同一型となるため、数値しかないベクトルに文字列を追加すると、すべて文字列に変換されます。

> b
[1] 10 20
>
> b = append(b,"Thirty")
> b
[1] "10"     "20"     "Thirty"
>

つづく

R言語 ベクトルで数列

いろんな数列を作ります。

1から10までの自然数

> a=1:10
> a
 [1]  1  2  3  4  5  6  7  8  9 10
>

連番だとこんなに簡単に作れるのに、c()関数はすごく面倒な気がします。R言語を勉強していけば、c()をわざわざ使う意味というのがが分かるのかもしれませんが。

2から20までの偶数

> a=(1:10)*2
> a
 [1]  2  4  6  8 10 12 14 16 18 20
>

とても簡単に、ベクトルに格納されている値すべてが2倍されたので、初めて見たときは感動しました。

> a=(1:10)*2-1
> a
 [1]  1  3  5  7  9 11 13 15 17 19
>

パターンの繰り返し

> rep(c(1,5,0),3)
[1] 1 5 0 1 5 0 1 5 0
> a=rep(c(1,5,0),3)
> a
[1] 1 5 0 1 5 0 1 5 0
>

あえて短い関数名なんでしょうか。repはrepeatとすぐに想像つきませんでした。

ランダム

> a=sample(1:10)
> a
 [1]  9  4  2  6  5  1 10  7  3  8
>

これも、shuffleじゃないんですね。sampleという関数名は新鮮です。

平方数

> (function(x)return(x*x))(1:10)
 [1]   1   4   9  16  25  36  49  64  81 100
>

もっと良い方法があるのかもしれませんが思いつかず、無名関数を仕方なく使いました。

円周率一文字ずつ

> a=strsplit(gsub("\\.","",as.character(pi)),"")
> a
[[1]]
 [1] "3" "1" "4" "1" "5" "9" "2" "6" "5" "3" "5" "8" "9" "7" "9"

>

でもこのままでは、ベクトルではなくリストので、unlistを使ってベクトルにします。as.integerは、整数化。

> b=as.integer(unlist(a))
> b
 [1] 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
>

R言語を使えば、とても簡単に数列生成ができますね。

R言語 配列

配列もベクトルと同じく入れ物なのですが、次元数が自由に設定できます。

配列はarray関数で作ります。

> a = array(dim=c(2,6))
> a
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]   NA   NA   NA   NA   NA   NA
[2,]   NA   NA   NA   NA   NA   NA
>

値を指定していないので、配列の中は空です。
初期値ありで配列を作るには、ベクトルで値を指定すればよいです。

> a = array(1:12,c(3,4))
> a
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
>

初期値が配列数よりも少ない場合は、繰り返しパターンで初期化されます。

> a = array(c(1,5,10),c(5,5))
> a
     [,1] [,2] [,3] [,4] [,5]
[1,]    1   10    5    1   10
[2,]    5    1   10    5    1
[3,]   10    5    1   10    5
[4,]    1   10    5    1   10
[5,]    5    1   10    5    1
>

3次元配列。

> a = array(0,c(2,3,4))
> a
, , 1

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0

, , 2

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0

, , 3

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0

, , 4

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0

>

次元を指定しないと、一次元配列になります。

> a=array(1:10)
> a
 [1]  1  2  3  4  5  6  7  8  9 10
>

一見ベクトルのように見えますが、これは一次元配列です。
is.vector、is.arrayで確認してみましょう。

> is.vector(a)
[1] FALSE
> is.array(a)
[1] TRUE
>

配列からベクトルを抽出できます。

> b = a[1:10]
> b
 [1]  1  2  3  4  5  6  7  8  9 10
> is.vector(b)
[1] FALSE
> is.array(b)
[1] TRUE
>

配列の変換をするには、いったんベクトルに戻してから配列を作り直せばよいみたいです。

> a = array(1:12,c(3,4))
> a
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
> b = array(a[1:12],c(2,2,3))
> b
, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

, , 3

     [,1] [,2]
[1,]    9   11
[2,]   10   12

>

R言語 行列

ベクトル、配列の次は、行列です。行列の生成にはmatrixを使います。

> a = matrix(1:12, nrow=3, ncol=4)
> a
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
>

行列の掛け算をします。
\[
a = \left(
\begin{array}{cc}
1 & 2 &3
\end{array}
\right)
\]
\[
b = \left(
\begin{array}{cc}
4 \\
5 \\
6
\end{array}
\right)
\]
\[
a \times b =
\]
行列の積をするには、%”%を使います。

> a=matrix(1:3,nrow=1,ncol=3)
> a
     [,1] [,2] [,3]
[1,]    1    2    3
> b=matrix(4:6,nrow=3,ncol=1)
> b
     [,1]
[1,]    4
[2,]    5
[3,]    6
> a %*% b
     [,1]
[1,]   32

計算できない行列にすると、このようにエラーがでます。

> b=matrix(4:5,nrow=2,ncol=1)
> b
     [,1]
[1,]    4
[2,]    5
> a %*% b
 a %*% b でエラー:  適切な引数ではありません
>

スカラーとの積は、普通に*を使います。

> a
     [,1] [,2] [,3]
[1,]    1    2    3
> a * 3
     [,1] [,2] [,3]
[1,]    3    6    9
>

別の行列でも確認してみましょう。
\[
a = \left(
\begin{array}{cc}
1 & 3 & 5\\
2 & 4 & 6
\end{array}
\right)
\]
\[
b = \left(
\begin{array}{cc}
10 \\
20 \\
30
\end{array}
\right)
\]

> a = matrix(1:6,nrow=2,ncol=3)
> b = matrix(c(10,20,30), nrow=3,ncol=1)
> a
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
> b
     [,1]
[1,]   10
[2,]   20
[3,]   30
> a %*% b
     [,1]
[1,]  220
[2,]  280
>

各要素ごとの計算は、四則演算の記号がそのまま使えます。

> a = matrix (1:4, nrow=2,ncol=2)
> b = matrix (11:14, nrow=2,ncol=2)
> a
     [,1] [,2]
[1,]    1    3
[2,]    2    4
> b
     [,1] [,2]
[1,]   11   13
[2,]   12   14

各要素の和。

> a + b
     [,1] [,2]
[1,]   12   16
[2,]   14   18

各要素の積

> a * b
     [,1] [,2]
[1,]   11   39
[2,]   24   56

R言語 データフレーム

データフレームは、いわゆるRDBのテーブルみたいなものですね。Excelの表という覚え方でもいいかもしれません。

> a = c("あなご","いくら","うに")
> b = c(200,300,400)
> a
[1] "あなご" "いくら" "うに"
> b
[1] 200 300 400
> dt = data.frame (a,b)
> dt
       a   b
1 あなご 200
2 いくら 300
3   うに 400
>

列アクセスは配列のように番号を指定します。

> dt[1]
       a
1 あなご
2 いくら
3   うに
> dt[2]
    b
1 200
2 300
3 400
>

配列と似てるからといって、勝手に次元を増やしてアクセスできません。

> dt[1][1]
       a
1 あなご
2 いくら
3   うに
>

列をベクトルで抽出するには、,(カンマ)を指定します。

> f1 = dt[,1]
> f2 = dt[,2]
> f1
[1] あなご いくら うに
Levels: あなご いくら うに
> f2
[1] 200 300 400
>

行を取り出すには、subset関数を使います。

> dt
       a   b
1 あなご 200
2 いくら 300
3   うに 400
> subset(dt,b == 300)
       a   b
2 いくら 300
>
> subset(dt,b < 350)
       a   b
1 あなご 200
2 いくら 300
>

SQLのwhere節のようですね。

> subset(dt,b >= 300,select=a)
       a
2 いくら
3   うに
>

列を増やしてみます。

> dt
       a   b
1 あなご 200
2 いくら 300
3   うに 400
> name = dt[,1]
> price = dt[,2]
> qty = c(5,10,15)
> dt = data.frame(name,price,qty)
> dt
    name price qty
1 あなご   200   5
2 いくら   300  10
3   うに   400  15
>

priceが300以上のnameとqtyを抽出。

> subset(dt,price>=300,select=c(name,qty))
    name qty
2 いくら  10
3   うに  15
>

R言語 表

ナンバーズ3は、1994年ぐらいから始まってもう4751回みたいです。
私はナンバーズ3ミニをよく買いますが、ミニだと00~99の数字で、毎回100分の1の確率で当たります。00~99までの数字をランダムに4751回発生させると各番号はどれぐらいの頻度になるでしょう。まずはlinuxコマンドで頻度表を作ってみます。

takk@deb9:~/tmp$ seq 4751 | perl -pe 's/^.*$/int rand 100/e' | sort | uniq -c | awk '{print $2,$1}' | sort -n
0 52
1 44
2 53
3 49
4 37

(省略)

94 49
95 51
96 50
97 39
98 40
takk@deb9:~/tmp$

seq,perl,sort,uniq,awk。コマンドがたくさん使われるしコマンドが長いです。
R言語の表を使ってみます。

> numbers3 = sample(0:99,4000,TRUE)
> numbers3
   [1] 91 37 14 65 19 87 14 65 62 75  9 69 42 63 69  9 56 43 17 44 46 48 23 93
  [25] 72 40 74 39 39 87  5 81 58 56  1 42  8 20 81  6 92 76 37 61 42 15 41  8
  [49] 51 98 66 61 14 81 93 83 52 85 86 42 29 92 25  9 88  3 55 68 84 27 84 30
  [73] 18 80 48 42 77 57 10 60 79 34 42 23 16 35 65  4 87 10 32 43  0 71 10 25

(省略)

[4657]  5 32 44 22 84 64 93 36 51 16 65 81 10 39 78 15 95 58 36 68 72 45 48 46
[4681]  9 76 38 59 57 76 17 81 64 46 77 78 50 14 12 24 85 13 14 74 56 78  7 86
[4705]  0 72 19 28 90 27 52 19 20 76 82 75 39 77 95 56 58 30 37 69  0 50 45 96
[4729] 53 70 38 40 28 17 50 77 31 58 11 18 55 47 32 16 46 78 63 63 91 21 53
>

サンプルデータを作るのは1関数で済みました。
次に頻度表です。

> a = table(numbers3)
> a
numbers3
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
44 46 40 49 44 45 51 46 30 47 48 41 60 46 56 37 45 41 42 42 51 57 38 53 57 51
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
43 45 46 42 43 48 64 47 53 52 47 52 48 66 46 41 45 49 50 49 47 47 57 42 37 47
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
54 45 45 45 52 41 53 45 45 59 54 50 51 44 40 60 55 41 45 50 46 51 49 44 59 40
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
40 42 40 57 35 49 45 64 44 32 57 55 48 40 53 46 45 45 51 45 46 49
>

これも1関数で済みました。なんて簡潔なんでしょう。
見栄えは悪いですが、0~99の番号の下の数字が出現頻度です。

データフレームの形にして確認してみます。

> (data.frame(a))
    numbers3 Freq
1          0   44
2          1   46
3          2   40
4          3   49
5          4   44

(省略)

96        95   45
97        96   51
98        97   45
99        98   46
100       99   49
>

R言語は統計解析をするツールなので、簡単にできて当然なのでしょう。

R言語 リスト

リストはいろんなオブジェクトを格納できます。
(+は入力継続のプロンプトです)

> lis = list(
+ a=1:10,
+ b=array(1:12,c(3,4)),
+ c=matrix(1:4,nrow=2,ncol=2),
+ d=data.frame(c("あなご","いくら","うに"),c(300,400,500)),
+ e=table(sample(1:10,10)))
>

このように、ベクトル、配列、行列、データフレーム、表、ごちゃまぜで格納できます。
参照は配列のようにアクセスできます。1はじまりです。

> lis[1]
$a
 [1]  1  2  3  4  5  6  7  8  9 10

> lis[2]
$b
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

> lis[3]
$c
     [,1] [,2]
[1,]    1    3
[2,]    2    4

> lis[4]
$d
  c..あなご....いくら....うに.. c.300..400..500.
1                        あなご              300
2                        いくら              400
3                          うに              500

> lis[5]
$e

 1  2  3  4  5  6  7  8  9 10
 1  1  1  1  1  1  1  1  1  1

>

[]で参照するときは、リストが返ります。

> is.list(lis[1])
[1] TRUE
> is.list(lis[2])
[1] TRUE
> is.list(lis[3])
[1] TRUE
> is.list(lis[4])
[1] TRUE
> is.list(lis[5])
[1] TRUE
>

元のオブジェクトを取得するには、[[]]を使います。

> is.vector(lis[[1]])
[1] TRUE
> is.array(lis[[2]])
[1] TRUE
> is.matrix(lis[[3]])
[1] TRUE
> is.data.frame(lis[[4]])
[1] TRUE
> is.table(lis[[5]])
[1] TRUE
>

R言語 ファイル読み込み1

ファイル読み込みします。

まずR起動前に、読み込み用のサンプルファイルを作ります。

takk@deb9:~/r$ seq 25 | pr -t5J | tee sample1.txt
1       6       11      16      21
2       7       12      17      22
3       8       13      18      23
4       9       14      19      24
5       10      15      20      25
takk@deb9:~/r$

Rを起動。

takk@deb9:~/r$R

(省略)

>

ファイルを読み込んでみます。

> a=scan("sample1.txt")
Read 25 items
> a
 [1]  1  6 11 16 21  2  7 12 17 22  3  8 13 18 23  4  9 14 19 24  5 10 15 20 25
>

なっ何でしょうか。てっきりテキストファイルをそのまま読み込んで文字列で表示してくれると思ってましたが、違うようです。
ベクトルなんでしょうか。

> is.vector(a)
[1] TRUE

ベクトルでした。各要素に直接アクセスして元々の1~25という数を取り出せますね。

> a[2]
[1] 6
>

数値ではなく元ファイルのように文字列で読み込むにはどうするんでしょうか。
what引数にcharacter()を指定します。

> scan("sample1.txt",what=character())
Read 25 items
 [1] "1"  "6"  "11" "16" "21" "2"  "7"  "12" "17" "22" "3"  "8"  "13" "18" "23"
[16] "4"  "9"  "14" "19" "24" "5"  "10" "15" "20" "25"
>

文字列のベクトルになりました。

さらに、セパレータを改行にします。 sep=”\n”です。

> scan("sample1.txt",what=character(),sep="\n")
Read 5 items
[1] "1\t6\t11\t16\t21"  "2\t7\t12\t17\t22"  "3\t8\t13\t18\t23"
[4] "4\t9\t14\t19\t24"  "5\t10\t15\t20\t25"
>

これで元ファイルと同じ形ですね。

R言語 ファイル書き込み1

ファイル書き込みです。
ベクトルをwrite関数でファイルに書き込むと、

> a=1:10
> write(a,"out.txt")
> q()
Save workspace image? [y/n/c]: n
takk@deb9:~/r$ cat out.txt
1 2 3 4 5
6 7 8 9 10
takk@deb9:~/r$

このように見やすい形でテキストファイルに書き込まれます。

毎行書きたい場合は、セパレータを改行にすればよいです。

> a=1:10
> write(a,"out.txt",sep="\n")
> q()
Save workspace image? [y/n/c]: n
takk@deb9:~/r$ cat out.txt
1
2
3
4
5
6
7
8
9
10
takk@deb9:~/r$

文字列を書き込むには、writeLinesを使います。

> a=c("HELLO1","HELLO2","HELLO3")
> writeLines(a,"out.txt")
> q()
Save workspace image? [y/n/c]: n
takk@deb9:~/r$ cat out.txt
HELLO1
HELLO2
HELLO3
takk@deb9:~/r$

ではreadLinesとwriteLinesを使い、ファイルをコピーしてみましょう。

takk@deb9:~/r$ cat sample1.txt
1       6       11      16      21
2       7       12      17      22
3       8       13      18      23
4       9       14      19      24
5       10      15      20      25
takk@deb9:~/r$ R

(起動メッセージ省略)

> a=readLines("sample1.txt")
> writeLines(a,"sample2.txt")
> q()
Save workspace image? [y/n/c]: n
takk@deb9:~/r$ diff sample1.txt sample2.txt
takk@deb9:~/r$ cat sample2.txt
1       6       11      16      21
2       7       12      17      22
3       8       13      18      23
4       9       14      19      24
5       10      15      20      25
takk@deb9:~/r$

sample1.txtとsample2.txtは一致しました。

R言語 ファイル読み込み2

R言語、ファイル読み込み続きです。
最初に読み込むファイル作成。

takk@deb9:~/r$ seq 25 | pr -t5J > sample.txt
takk@deb9:~/r$ cat sample.txt
1       6       11      16      21
2       7       12      17      22
3       8       13      18      23
4       9       14      19      24
5       10      15      20      25
takk@deb9:~/r$

read.table()を使い、sample.txtを読み込みます。

> a=read.table("sample.txt")
> a
  V1 V2 V3 V4 V5
1  1  6 11 16 21
2  2  7 12 17 22
3  3  8 13 18 23
4  4  9 14 19 24
5  5 10 15 20 25
>

read.table()というぐらいだから、表として読み込まれたと思いましたが、リスト、データフレームのようです。

> is.table(a)
[1] FALSE
> is.list(a)
[1] TRUE
> is.data.frame(a)
[1] TRUE
>

アクセスはデータフレーム同様です。

> a[1]
  V1
1  1
2  2
3  3
4  4
5  5
> a[,1]
[1] 1 2 3 4 5
> a[2,3]
[1] 12
>

sample.txtはタブ区切りフォーマットなので、read.delim()も使えます。

> b=read.delim("sample.txt")
> b
  X1 X6 X11 X16 X21
1  2  7  12  17  22
2  3  8  13  18  23
3  4  9  14  19  24
4  5 10  15  20  25
> is.data.frame(b)
[1] TRUE
> is.array(b)
[1] FALSE
> is.list(b)
[1] TRUE
>

カンマ区切りデータの場合は、 read.csv()が使えます。
samplet.txtは、タブ区切りデータなので、これに使用するとおかしな形で読み込まれます。

> c=read.csv("sample.txt")
> c
      X1.6.11.16.21
1  2\t7\t12\t17\t22
2  3\t8\t13\t18\t23
3  4\t9\t14\t19\t24
4 5\t10\t15\t20\t25
>

区切り文字がカンマのファイルを読み込んでみます。

> q()
takk@deb9:~/r$ tr '$\t' , < sample.txt > sample2.txt
takk@deb9:~/r$ R

(省略)

> d=read.csv("sample2.txt")
> d
  X1 X6 X11 X16 X21
1  2  7  12  17  22
2  3  8  13  18  23
3  4  9  14  19  24
4  5 10  15  20  25
> d[1]
  X1
1  2
2  3
3  4
4  5
> d[,1]
[1] 2 3 4 5
>

一行目がタイトルになってしまいました。

一行目をヘッダーとして扱わないようにheader=FALSEを指定します。

> e=read.csv("sample2.txt",header=FALSE)
> e
  V1 V2 V3 V4 V5
1  1  6 11 16 21
2  2  7 12 17 22
3  3  8 13 18 23
4  4  9 14 19 24
5  5 10 15 20 25
> e[1]
  V1
1  1
2  2
3  3
4  4
5  5
> e[,1]
[1] 1 2 3 4 5
>

今度は正しく読めました。

コメント

タイトルとURLをコピーしました