Chap2　S言語のオブジェクトとその演算

コンテンツ

2.1 はじめに
2.2 S-PLUSでS言語を使うには
2.3 四則計算と比較・論理演算子
2.4 S言語におけるデータ構造
2.5 ベクトル
2.6 よく使う関数
2.7 行列
2.8 リスト
2.9 データフレーム

2.1 はじめに

S言語とは、S-PLUS の基礎となるプログラミング言語である。 S-PLUS はコアの部分はC 言語とFortran で書かれたソフトであるが、 GUI や統計解析を行うための関数は、すべてS 言語で書かれている。それゆえに、S言語を使えるようになると、GUIでS-PLUSを操作するよりも、より細かで柔軟な統計解析を行うことができるという利点がある。

S言語には、様々な有用な特徴がある。一つ目に、文法がC 言語に酷似しており、学習が容易であるという特徴がある。二つ目に、S 言語はインタプリタ言語であり、電卓のような使い方も可能である。最後に、強力なベクトル計算機能があり、統計モデルの記述が非常に容易であり、プログラミングしやすいことである。

S言語が持つ利点の恩恵を受けるには、S言語のオブジェクトについて理解しなければならない。 S言語でのオブジェクトとは、すべてのデータ、すべての関数などのことを指す。特に、関数でないものをデータオブジェクトと呼ぶ。この章では、主にデータオブジェクトについて、基本的な4つのデータ構造とデータ型、その演算について解説する。

[一番上へ]

2.2 S-PLUSでS言語を使うには

S-PLUS でS 言語を使うには、「コマンドウィンドウ」と呼ばれるものを起動しなければならない。コマンドウィンドウは、というアイコンをクリックすることによって起動される。画面の様子を図2.1に示す。

図2.1 コマンドウィンドウを起動するには

[一番上へ]

2.3 四則計算と比較・論理演算子

まず手始めとして、電卓としての使い方から入る。 S言語の四則演算子は次のとおりである。

加法	+
減法	-
乗法	*
除法	/
商	%/%
剰余	%%
べき乗	^

次に四則演算子を使った例を挙げる。なお、#とはそれ以降の文字を無視する(コメントアウト)という記号である。

> 3 + 2 　#足し算
[1] 5
> 3 - 2 　#引き算
[1] 1
> (4 + 3)*2 #かっこと掛け算
[1] 14
> 12/3 　#割り算
[1] 4
> 4 %/% 2 　#商
[1] 2
> 5 %% 3 　#剰余
[1] 2
> 2^10 #べき乗
[1] 1024

S言語の比較・論理演算子を表xに示す。よくある間違いとして、==(等しい)を=(代入)と書き間違えるので注意しなければならない。

比較演算子		論理演算子
AはBと等しい	A==B	XかつY	X&Y
AはBと等しくない	A!=B	XまたはY	X\|Y
AはBより大きい	A>B	XがTrueのときYを計算しXかつY	X&&Y
AはBより小さい	A<B
AはB以上	A>=B
AはB以下	A<=B

> 3 > 2
[1] T
> 3 < 2
[1] F
> 3 == 3
[1] T
> 3 > 2
[1] T
> 3 < 2
[1] F
> 3 >= 3
[1] T
> 3 <= 3
[1] T
> (3 > 2) & (3 < 2)
[1] F
> (3 > 2) | (3 < 2)
[1] T

[一番上へ]

2.4 S言語におけるデータ構造

S言語のデータ

統計解析を行おうとするとき、手に入れたデータがそのまま統計解析に使われることは少ない。そのデータをモデルに当てはめるためのデータ加工が必要となる。 S言語の特徴として、データ加工を容易に行うことができるという特徴がある。それは、S言語が持つデータ構造に様々な工夫がされているからである。ゆえに、S言語のデータ構造を理解することは、S言語を使って思い通りに解析を進める近道となる。

具体的に、S言語における基本的なデータ構造に説明する。 S言語で解析を進めるにあたって、よく使用するデータ構造が4つある。

ベクトル
行列
リスト
データフレーム

オブジェクト名のつけ方

C言語における変数名と同様、S言語のオブジェクト(データオブジェクト・関数)にも名前をつける必要がある。ただし、名前のつけ方には一定のルールがある。

英大小文字、（かな文字）、数字、ピリオドを使うことができる。
英大小文字、（かな文字）、ピリオドから始める必要がある。
大文字と小文字を区別する。
文字と文字の間にスペースをはさめない。
ピリオド以外の、アンダーバー( _ )やアットマーク(@)等の記号は使用できない。
予約語(c,T,F,if,for,else,in,whileなど)は使えない。

[一番上へ]

2.5 ベクトル

ベクトルの生成

S言語におけるベクトルとは、「データが一列に並んだもの」である。ベクトルを作るには、代入演算子(イコール=、ハイフンとgraterthanサインの組合せ-&gt、アンダーバー_)と関数cを使う。関数cは、ベクトルの要素にしたいものを引数に入れることで、その要素を持つベクトルを作ることができる。例えば、要素として(1,2,3,4)を持つベクトルxを作りたい場合、 x=c(1,2,3,4)と記述すればよい。演算子:は、a:bと記述したとき、aからbまで差の絶対値が1の等差数列を作る。つまり、1:10はc(1,2,3,4,5,6,7,8,9,10)と等価である

> x = -3
> x #このとき、xは長さが1のベクトルとなる。
 [1] -3
> x = c(-1,2,10,4)
> x
 [1] -1 2 10 4
> x = 1:10
> x
 [1]  1  2  3  4  5  6  7  8  9 10

ベクトルに何が代入されているか知りたいときは、変数名を入力してEnterキーを押せばよい。

ベクトルとデータ型

ところで、数学におけるベクトルと違う点として、必ずしも数値でなくても良い点が挙げられる。例えば、character型(文字列のこと)もベクトルの要素として含むことができる。そこで、S言語においてよく使用されるデータ型について解説する。

double型（倍精度実数型)
このデータ型は数値データで、実数を表現することができる。
integer型（整数型）
このデータ型は数値データで、整数のみ表現をすることができる。
factor型（因子型）
カテゴリカルデータであることを表現するためのデータ型である。
logical型（論理型）
論理値T,F(T:True,F:False)を表現するデータ型である。
character型（文字列型）
文字列を表現するデータ型である。

あるベクトルxが持っている型を知りたいのであれば、 mode(x)とすればベクトルが持つ型を知ることができる。例として、double型とinteger型について見てみよう。 mode関数では、double型とinteger型は共に数値であるので、"numeric"と表示される。 "numeric"では、その型が"integer"なのか"double"であるのかが分からない。そこで、strage.mode(x)という関数が実装されており、詳しいデータ型が分かるようになっている。

> x 
[1]   0.3  45.1  33.2 239.6   4.9
> mode(x)
[1] "numeric"
> y = c(1,3,9,11)
> y
[1]  1  3  9 11
> mode(y)
[1] "numeric"
> storage.mode(x)       #mode関数よりもっとくわしく表示
[1] "double"
> storage.mode(y)
[1] "integer"

ベクトルでは、文字列や論理値も要素に含むことができる。

> z = c("Hello","World")
> z
[1] "Hello" "World"
> L = c(T,T,F,F)
> L
[1] T T F F
> mode(z)
[1] "character"
> mode(L)
[1] "logical"

ベクトルの演算

S言語のベクトル計算は、数学のそれとは計算方法が違う。それは、統計解析をするために都合がいいようにするためである。どこが違うのかというと、一つ目に、ベクトルの要素ごとに計算を行うということである。二つ目に、式の中の最長のベクトルにあわせて、短いベクトルを繰り返して使用するということである(これを再利用規則という)。分かりやすいように、次に例を挙げる。

> x = 1:10
> x + 3 #xの各要素に3を加える
 [1]  4  5  6  7  8  9 10 11 12 13
> y = c(-100,100)
> x + y #xの長さは10,yの長さは2なので、yを繰り返して使う。
 [1] -99 102 -97 104 -95 106 -93 108 -91 110
> 2 * x
 [1]  2  4  6  8 10 12 14 16 18 20
> x / 3
 [1] 0.3333333 0.6666667 1.0000000 1.3333333 1.6666667
 [6] 2.0000000 2.3333333 2.6666667 3.0000000 3.3333333
> x^2
 [1]   1   4   9  16  25  36  49  64  81 100
> 2^x
 [1]    2    4    8   16   32   64  128  256  512 1024
> z = -10:-1
> z
 [1] -10  -9  -8  -7  -6  -5  -4  -3  -2  -1
> x * z #x*zは内積ではなく、要素ごとの掛け算となる。
 [1] -10 -18 -24 -28 -30 -30 -28 -24 -18 -10

比較演算子を使って、ベクトルに論理値ベクトルを代入することができる。また、論理演算子を使うことにより、論理値を使った演算をすることができる。

> x
 [1]  1  2  3  4  5  6  7  8  9 10
> x %% 2 == 0      #xが2で割り切れるもの
 [1] F T F T F T F T F T
> x %% 3 == 0      #xが3で割り切れるもの
 [1] F F T F F T F F T F
> (x %% 2 == 0) & (x %% 3 == 0)      #xが2と3で割り切れるもの
 [1] F F F F F T F F F F
> x > 5
 [1] F F F F F T T T T T
> x <= 10
 [1] T T T T T T T T T T
> x <= 7
 [1] T T T T T T T F F F
> (x > 5) & (x <= 7)
 [1] F F F F F T T F F F
> y = (x > 5) & (x <= 7)
> y
 [1] F F F F F T T F F F

要素の取り出し

ベクトルxに代入された要素を[ . ]を使うことで取り出すことができる。 [ . ]の中身には、(1)数値ベクトル(integer型)、(2)論理値ベクトル、(3)文字ベクトルを入れる。特によく使用する数値と論理値の場合について説明すると、数字を使って取り出す場合は、[ . ]に書かれた数値に対応した番号の要素が取り出され、論理値を使って取り出す場合は、T,FのうちTに対応する部分が取り出される。

要素の取り出しは、ベクトルに限らず行列・リスト・データフレームにも似たような方法で要素を取り出すので、必ず理解しておくべきことである。

> x = c(3.4, 6.2, 2.3, 9.3, -2,3, -3.2)
> x
[1]  3.4  6.2  2.3  9.3 -2.0  3.0 -3.2
> x[3] #xの3番目の要素を取り出す
[1] 2.3
> x[c(2,6,3)] #xの2,6,3番目の要素をその順番に取り出す
[1] 6.2 3.0 2.3
> 1:4
[1] 1 2 3 4 #1:4というベクトルを生成して取り出す
> x[1:4]
[1] 3.4 6.2 2.3 9.3
> x[c(-1,-2)] #1,2番目以外の要素を取り出す
[1]  2.3  9.3 -2.0  3.0 -3.2
> x[c(T,T,F,F,T,F,T)] #Tに対応する部分を取り出す
[1]  3.4  6.2 -2.0 -3.2
> x > 3 #比較演算子を使って論理値ベクトルを作る
[1] T T F T F F F
> x[x>3] #x>3がTrueである要素を取りだす
[1] 3.4 6.2 9.3
> x[x>3] = 100 #x>3である要素を100に置き換える
> x
[1]  100.0  100.0    2.3  100.0   -2.0    3.0   -3.2

NA(Not Available)とInf(Infinity)

NAとは、欠損値の事をさす。これは、データが得られなかったときや、通常想定されない計算(例えば0を0で割る)などによって生じる。 NAにどのような計算を施してもNAである。また、NAがデータに含まれていることで、関数がエラーを引き起こすことが多い。

Infとは、無限大を示す記号である。また、NAよりは少ないが、Infもデータに含まれていることで、関数がエラーを引き起こすことが多い。

ベクトル内にNAやInfが含まれているかどうかを確認する関数がある。それは、is.na(x),is.inf(x)である。

> x = c(1,3,NA,7)
> is.na(x)
[1] F F T F
> x[is.na(x)] = 100
[1] 1 3 100 7
> x = c(0,0,Inf,0)
> is.inf(x)
[1] F F T F

[一番上へ]

2.6 よく使う関数

ここで、いくつか重要な関数を紹介する。

sort(x)	xを小さい順に並び替えたベクトルを作る。
order(x)	xを小さい順に並び替えたときに、それが元のベクトルの何番の要素であるかのベクトルを返す。
rev(x)	ベクトルxの順番を逆にする。
length(x)	length(x)関数は、ベクトルxの長さを求める。言い換えれば、xの持つ要素の個数を数える。
match(x,< table&gt,&ltnomatch>)	match(x,&lttable&gt,&ltnomatch>)はxの要素それぞれが、 &lttable&gtに代入されたベクトルの何番目にあたるかを示す関数である。もし&lttable&gtに見当たらない場合は、 &ltnomatch&gtに代入された値か、代入されてない場合はNAが返る。
unique(x)	unique(x)はベクトルxのうち、反復を取り除いたものを返す関数である。
seq(...)	seq(...)は":"演算子を拡張した機能を持つ関数である。複数の引数を持ち、引数の与え方で機能が変化する。詳しくは例題で解説する。
rep(...)	rep(...)は、ベクトルの要素を何回か繰り返して新しいベクトルを作る関数である。 seq(...)と同様に、引数の与え方で機能が変化する。詳しくは例題で解説する。

> x = c(1,3,5,7,3,5,7,5,7,7)
> sort(x) #xを小さい順に並び替える
 [1] 1 3 3 5 5 5 7 7 7 7
> order(x) #xの要素それぞれが、何番目に小さいか返す
 [1]  1  2  5  3  6  8  4  7  9 10
> rev(x) #順番を逆に並び替える
 [1] 7 7 5 7 5 3 7 5 3 1
> length(x) #xの長さを返す
[1] 10
> match(x,table=c(1,3,5),nomatch=0) #xの要素がtableの何番目か返す
 [1] 1 2 3 0 2 3 0 3 0 0
> unique(x) #反復を取り除いたものを返す
[1] 1 3 5 7

seq関数は、等差数列を生成する関数である。引数の与え方によって、生成されるベクトルが変化する。

> x = c(1,3,5,7,3,5,7,5,7,7) #例題のベクトルを生成
> x
 [1] 1 3 5 7 3 5 7 5 7 7
> seq(from=3,to=13) #3:13と同様の意味
 [1]  3  4  5  6  7  8  9 10 11 12 13
> seq(from=1,to=10) #1から10まで、差が1の等差数列を生成
 [1]  1  2  3  4  5  6  7  8  9 10
> seq(from=1,to=10,by=0.5) #1から10まで、差が0.5の等差数列を生成
 [1]  1.0  1.5  2.0  2.5  3.0  3.5  4.0  4.5  5.0  5.5
[11]  6.0  6.5  7.0  7.5  8.0  8.5  9.0  9.5 10.0
> seq(from=1,to=10,length=4) #1から10まで、長さが4の等差数列を生成
 [1]  1  4  7 10
> seq(from=1,to=10,length=5) #1から10まで、長さが5の等差数列を生成
 [1]  1.00  3.25  5.50  7.75 10.00
> seq(along=x) #xと同じ長さの、1から始まる等差数列を生成
 [1]  1  2  3  4  5  6  7  8  9 10
> seq(from=-10,along=x) #xと同じ長さの、-10から始まる等差数列を生成
 [1] -10  -9  -8  -7  -6  -5  -4  -3  -2  -1
> seq(to=5,along=x) #xと同じ長さの、5で終わる等差数列を生成
 [1] -4 -3 -2 -1  0  1  2  3  4  5

rep関数は、第1引数に与えられたベクトルについて、第2引数に与えられたベクトルの回数だけ繰り返したベクトルを生成する関数である。詳しくは例題を参照すること。

> rep(1,3) #1を3回繰り返す
[1] 1 1 1
> rep(c(1,2),3) #c(1,2)というベクトルを3回繰り返す
[1] 1 2 1 2 1 2
> rep(c(1,2),c(1,2)) #c(1,2)の各要素について、c(1,2)の各要素の回数だけ繰り返す
[1] 1 2 2
> rep(c(3,2),c(2,2))
[1] 3 3 2 2
> rep(c(1,2),c(2,2))
[1] 1 1 2 2
> rep(1:3,1:3)
[1] 1 2 2 3 3 3
> rep(1:3,rep(3,3))
[1] 1 1 1 2 2 2 3 3 3
> rep(1:3,seq(from=2,to=4))
[1] 1 1 2 2 2 3 3 3 3
> letters
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k"
[12] "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v"
[23] "w" "x" "y" "z"
> letters[1:3]
[1] "a" "b" "c"
> rep(letters[1:3],1:3) #文字列型でも引数に与えることができる
[1] "a" "b" "b" "c" "c" "c"
> rep(letters[1:3],rep(3,3))
[1] "a" "a" "a" "b" "b" "b" "c" "c" "c"

S言語にも、計算のための関数が非常に多く実装されている。次に示す関数はほんの一部分であるが、とりあえずこれだけ覚えれば十分である。

min(x),max(x),range(x)	min(x),max(x)はベクトルxの要素の中で最小・最大を求める。range(x)はc(min(x),max(x))と等価である。
mean(x),median(x),var(x)	ベクトルxの平均・中央値・分散を求める。
sum(x),prod(x)	ベクトルxの和・積を求める。もし、xが論理値ベクトルならば、T=1,F=0として計算する。
cumsum(x),cumprod(x)	累積和・累積積を求める。
diff(x)	diff(x)は前進差分のベクトルを返す。つまり、x[-1] - x[-length(x)]と等価である。
sqrt(x),exp(x),log(x)	ベクトルxの各要素について、平方根・指数・自然対数を求める。
sin(x),cos(x),tan(x),...	三角関数。アークサインやハイパボリックコサイン等もある。
gamma(x)	ガンマ関数。
ceiling(x),floor(x)	ceiling(x),floor(x)はそれぞれ、引数以上の最小整数、引数以下の最大整数を求める。
trunc(x),round(x)	trunc(x)はxの整数部分を求める。round(x)はxを四捨五入する。

> x = 1:10
> min(x)
[1] 1
> max(x)
[1] 10
> range(x)
[1]  1 10
> mean(x)
[1] 5.5
> median(x)
[1] 5.5
> var(x)
[1] 9.166667
> stdev(x)    #標準偏差を求める関数
[1] 3.02765
> sum(x)
[1] 55
> prod(x)
[1] 3628800

> cumsum(x)   #累積和。例えば、3番目の要素は1+2+3=6である
 [1]  1  3  6 10 15 21 28 36 45 55
> cumprod(x)  #累積積。例えば、3番目の要素は1*2*3=6である
 [1]       1       2       6      24     120     720    5040
 [8]   40320  362880 3628800
> diff(x)     #xは差が1の等差数列なので、すべて1になる
[1] 1 1 1 1 1 1 1 1 1
> sqrt(x)
 [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751
 [8] 2.828427 3.000000 3.162278
> exp(x)
 [1]     2.718282     7.389056    20.085537    54.598150
 [5]   148.413159   403.428793  1096.633158  2980.957987
 [9]  8103.083928 22026.465795
> log(x)
 [1] 0.0000000 0.6931472 1.0986123 1.3862944 1.6094379 1.7917595
 [7] 1.9459101 2.0794415 2.1972246 2.3025851

[一番上へ]

2.7 行列

行列の生成

ベクトルは1列に並んだデータであるが、行列は行と列からなるデータである。行列を作るためには、matrix(...)という関数を使う。

matrix(...)の引数にncolまたはnrowを設定すると、列または行の数が、与えられた数である行列を作成し、 1番目に与えられたベクトルの要素を左上から縦に埋めていく。

> x = 1:6
> A = matrix(x,ncol=2) #列数が2の行列を作る
> A
     [,1] [,2] 
[1,]    1    4
[2,]    2    5
[3,]    3    6
> B = matrix(x,nrow=2) #列数が2の行列を作る
> B
     [,1] [,2] [,3] 
[1,]    1    3    5
[2,]    2    4    6

また、matrix(...)の引数にbyrow=Tを設定すると、 1番目に与えられたベクトルの要素を、左上から横に埋めていくように行列を作る。

> x = 1:6
> A = matrix(x,ncol=2,byrow=T)
> A
     [,1] [,2] 
[1,]    1    2
[2,]    3    4
[3,]    5    6

cbind(...),rbind(...)でも行列を作ることができる。これらの関数は、同じ長さのベクトルを、行列の列ベクトルまたは行ベクトルであるとして行列を作る。

> x = 1:3
> y = x + 100
> x
[1] 1 2 3
> y
[1] 101 102 103
> A = cbind(x,y)
> A
     x   y 
[1,] 1 101
[2,] 2 102
[3,] 3 103
> A = rbind(x,y)
> A
  [,1] [,2] [,3] 
x    1    2    3
y  101  102  103

行列の演算

行列の転置を行うには、t(...)を使えばよい。

> A
     x   y 
[1,] 1 101
[2,] 2 102
[3,] 3 103
> t(A)
  [,1] [,2] [,3] 
x    1    2    3
y  101  102  103

行列のサイズ(縦の長さと横の長さ)が等しい行列の加減は、各行列の要素ごとに計算が行われる。（数学と同じである）

> A = matrix(1:4,ncol=2)
> B = matrix(-1:-4,ncol=2)
> A
     [,1] [,2] 
[1,]    1    3
[2,]    2    4
> B
     [,1] [,2] 
[1,]   -1   -3
[2,]   -2   -4
> A+B
     [,1] [,2] 
[1,]    0    0
[2,]    0    0
> A-B
     [,1] [,2] 
[1,]    2    6
[2,]    4    8

行列とベクトルとの加減乗除については、要素ごとの計算が基本である。（数学と同じでないときがある）

> A = matrix(1:9,ncol=3)        #長さが3の正方行列
> A
     [,1] [,2] [,3] 
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9
> A + 10                        #行列の各要素に10を加算
     [,1] [,2] [,3] 
[1,]   11   14   17
[2,]   12   15   18
[3,]   13   16   19
> A + c(-1,-2,-3)               #(-1,-2,-3)を列ベクトルとみなして、各列に加える
     [,1] [,2] [,3] 
[1,]    0    3    6
[2,]    0    3    6
[3,]    0    3    6

> 100*A
     [,1] [,2] [,3] 
[1,]  100  400  700
[2,]  200  500  800
[3,]  300  600  900
> x = c(10,100,1000)
> A/x
      [,1]  [,2]  [,3] 
[1,] 0.100 0.400 0.700
[2,] 0.020 0.050 0.080
[3,] 0.003 0.006 0.009

数学での行列積を求めるためには、%*%演算子を使う。

> A = matrix(1:4,ncol=2)
> B = matrix(0:3,ncol=2)
> A
     [,1] [,2] 
[1,]    1    3
[2,]    2    4
> B
     [,1] [,2] 
[1,]    0    2
[2,]    1    3
> A %*% B
     [,1] [,2] 
[1,]    3   11
[2,]    4   16

行列においても、論理演算を行うことができる。

> A = matrix(1:4,ncol=2)
> A
     [,1] [,2] 
[1,]    1    3
[2,]    2    4
> A > 2
     [,1] [,2] 
[1,]    F    T
[2,]    F    T

行列の抽出

ベクトルと同様、行列の要素も[...]を使うことで抽出が可能である。行列では、[&ltrow&gt,&ltcol&gt]のように指定し、要素を抽出する。ここで、&ltrow&gtまたは&ltcol&gtの片方を空欄にすると、行ベクトルまたは列ベクトルを抽出することができる。

> A = matrix(1:9,ncol=3)
> A
     [,1] [,2] [,3] 
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9
> A[2,2]        #行列Aの2行2列の要素を取り出し
[1] 5
> A[1,]         #行列Aの1行目をベクトルとして取り出し
[1] 1 4 7
> A[,2]         #行列Aの2列目をベクトルとして取り出し
[1] 4 5 6
> A[,]
     [,1] [,2] [,3] 
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

[一番上へ]

2.8 リスト

リストとは、ベクトルや行列、データフレーム、そしてリスト自身など、さまざまなデータオブジェクトをひとつの変数でまとめて保存するためのデータオブジェクトである。 S言語における統計解析では、統計の分析結果がリスト形式で保存されることが多い。このようなことのために、リストの要素を参照する操作をすることがよくある。

リストの作成

リストの作成にはlist(...)関数が使われる。この関数は、list(&ltname1>=&ltobject1&gt,&ltname2>=&ltobject2&gt,...)という形式で書かれる。ここで、&ltname1&gt,&ltname2&gt,...はリストの要素名、&ltobject1&gt,&ltobject2&gt,...は保存するデータである。

> x = letters[1:5]
> y = 1:5
> z = matrix(1:6,ncol=2)
> Lst = list(data1=x,data2=y,data3=z)
> Lst
$data1:
[1] "a" "b" "c" "d" "e"

$data2:
[1] 1 2 3 4 5

$data3:
     [,1] [,2] 
[1,]    1    4
[2,]    2    5
[3,]    3    6

リストの要素抽出

リストの要素を抽出するには、[[...]]を使用する。また、データ名を指定している(リスト表示時に$から始まる文字列)場合は、変数名$データ名とすることで抽出することができる。

> Lst
$data1:
[1] "a" "b" "c" "d" "e"

$data2:
[1] 1 2 3 4 5

$data3:
     [,1] [,2] 
[1,]    1    4
[2,]    2    5
[3,]    3    6

> Lst$data1
[1] "a" "b" "c" "d" "e"
> Lst$data1[3]
[1] "c"
> Lst[[1]][3]
[1] "c"

リストの属性

length(...),names(...)関数により、リストの属性を表示させることができる。

> Lst
$data1:
[1] "a" "b" "c" "d" "e"

$data2:
[1] 1 2 3 4 5

$data3:
     [,1] [,2] 
[1,]    1    4
[2,]    2    5
[3,]    3    6

> length(Lst)
[1] 3
> names(Lst)
[1] "data1" "data2" "data3"

[一番上へ]

2.9 データフレーム

データフレームは、行列とリストの性質を両方持っているものである。 Excelなど、スプレッドシートのデータを格納するのに適したデータ形式である。それゆえ、S-PLUSではよく使われるデータオブジェクトである。

データフレームの作成

データフレームを作成するには、data.frame(...)関数を使う。引数はリストと一緒で、&ltname>=&ltobject&gtという形でデータを指定する。このとき、リストと違う点として、&ltobject&gtにはベクトルを指定しなければならないことと、データフレームに格納するベクトルの長さがそれぞれ同じでなければならないことである。

> dfrm = data.frame(vec=1:10,let=letters[1:10])
> dfrm
   vec let 
 1   1   a
 2   2   b
 3   3   c
 4   4   d
 5   5   e
 6   6   f
 7   7   g
 8   8   h
 9   9   i
10  10   j

データフレームの属性

リストと同様、names(...)で、データフレームに含まれるベクトルの名前を取り出すことができる。

> dfrm
   vec let 
 1   1   a
 2   2   b
 3   3   c
 4   4   d
 5   5   e
> names(dfrm)
[1] "vec" "let"

データフレームに対して、names(...)関数を使うことにより、データフレームの列の名前を書き換えることができる。

> dfrm = data.frame(vec=1:5,let=letters[1:5])
> dfrm
   vec let 
 1   1   a
 2   2   b
 3   3   c
 4   4   d
 5   5   e
> dfrm2 = data.frame(1:5,letters[1:5])
> dfrm2
  X1 X2 
1  1  a
2  2  b
3  3  c
4  4  d
5  5  e
> names(dfrm)
[1] "vec" "let"
> x = names(dfrm)
> names(dfrm2) = x
> dfrm2
  vec let 
1   1   a
2   2   b
3   3   c
4   4   d
5   5   e

データフレームの要素抽出

データフレームの要素抽出の方法は、行列のように要素番号を直接指定して取り出す方法と、リストのように$を使って取り出す方法の2つ存在する。

> dfrm = data.frame(vec=1:5,let=letters[1:5])
> dfrm
  vec let 
1   1   a
2   2   b
3   3   c
4   4   d
5   5   e
> dfrm[1,2]
[1] a
Levels:
[1] "a" "b" "c" "d" "e"
> dfrm[4,1]
[1] 4
> dfrm[2,]
  vec let 
2   2   b
> dfrm[,1]
[1] 1 2 3 4 5
> dfrm$vec
[1] 1 2 3 4 5

[一番上へ]

Chap2 S言語のオブジェクトとその演算

コンテンツ

2.1 はじめに

2.2 S-PLUSでS言語を使うには

2.3 四則計算と比較・論理演算子

2.4 S言語におけるデータ構造

S言語のデータ

オブジェクト名のつけ方

2.5 ベクトル

ベクトルの生成

ベクトルとデータ型

ベクトルの演算

要素の取り出し

NA(Not Available)とInf(Infinity)

2.6 よく使う関数

2.7 行列

行列の生成

行列の演算

行列の抽出

2.8 リスト

リストの作成

リストの要素抽出

リストの属性

2.9 データフレーム

データフレームの作成

データフレームの属性

データフレームの要素抽出

Chap2　S言語のオブジェクトとその演算