R语言语法

向量

向量(vector)是R语言的最基本的数据类型、R语言的核心、R语言中的战斗机 ，向量是用于存储数值型、字符型或逻辑型数据的一维结构。

向量的创建

1.可以使用c()创建一个向量，如：

> a<-c(1,2,3,4,5) #存储的数据是数值型，直接用逗号隔开

> a<-c(1:5) #与第一行代码意思是一样的，因为是连续的，所以用1：5表示1到5的五个数

> b<-c("R","Rstudio") #储存的是字符型数据，字符型的数据要加双引号

> c<-c(TRUE,FALSE,T,F) #储存的数据是逻辑型的，TRUE与T是一样的，T是TRUE的简写，F是FALSE的简写

2.可以用vector()函数建立一个空向量，如：

> d<-vector(length=10) #建立了一个名字为d的空向量，长度为10

> d #我们看一下d里的内容，发现全部为FALSE，可以理解为空向量里值都为FALSE

[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

[9] FALSE FALSE

向量的索引（向量元素的提取、删除、添加）

我们有一个向量后，我想知道里面第几个第几个的内容，我们可以使用中括号[]进行索引。如：

> a<-c(1,2,3,4,5) #我这里有一个向量a

> a[2] #我查看a中第2个元素，返回结果为2

[1] 2

> a[4] #我查看a中第4个元素，返回结果是4

[1] 4

> a[c(1,3)] #我查看a中第1和第3个元素，可以使用向量的方式一次查看多个

[1] 1 3

> c<-c(TRUE,FALSE,T,F,F) #当然还有骚操作，这里有一个逻辑型向量c,我们试试用a索引它

> a[c] #结果可以看到，返回的是TRUE对应位置的元素，这个操作我不知道教材上有没有，这是我意外摸索出来的

[1] 1 3

以上讲的是查看某元素，在实际中会遇到更改或删除某些元素

1.向量中元素的更改，直接进行索引赋值，如下

> a<-c(1,2,3,4,5) #这里有一个向量a，没错又是它，它又来了，这个阿婆主真没技术含量(叹气)

> a[2]<-4 #a中第二个元素改为4

> a #看一下a中的元素，唉~~，没错它变了(窃喜)

[1] 1 4 3 4 5

> a[c(1,5)]<-7 #我把a中的第1和第5改为7

> a #再次看一下

[1] 7 4 3 4 7

2.向量中元素的删除

上面讲到索引是用[]，里面写上元素位置，位置是数字，正的！！！那么是负的会怎样呢？？？嗯！没错，负数

索引是查看删除那个位置后的结果，注意单纯的负索引出来的结果是没有改变原向量的，我们需要重新赋值，给它一个新的变量名（不用新的也行，但会把原来的覆盖掉），废话不多说，直接看如下代码：

> a #没错，又用了上面个那个向量a，up真没创意(梆梆给阿婆主两拳)

[1] 7 4 3 4 7

>

> a[-2] #我负索引以下第2个位置，返回的结果与a的区别是，把第2位删掉了

[1] 7 3 4 7

> a #我们在看一下a，返回结果尽然没有把第2为删掉，那怎么办？？那就给他一个新的名字吧！

[1] 7 4 3 4 7

>

> e<-a[-2] #既然a[-2]返回的结果是我需要的，那么直接给他一个新名字吧，让一个东西去接收它

> e #上面我们用了e去接受我们需要的，我们看一下是否赋值到了，运行这行代码后发现结果是我想要的

[1] 7 3 4 7

>

> a<-a[-2] #为啥要重新弄个新的变量名呢？用a不可以吗？肯定可以呀！俺敲着这行代码试一下(自信)

> a #查看一下a，对的是我想要的(满意)······(十分钟后)我原本的a呢？啊~~，救命，被我覆盖掉了(螺旋升天)

[1] 7 3 4 7 #所以不要轻易覆盖掉原来的变量，万一后面要用到呢？

>

> #升级以下，看看能不能用向量一次性多删几个

> a<-c(1,2,3,4,5) #这里我又用了原向量a，上面的向量a太短了

> f1<-a[c(-1,-3)]

> f1 #结果是可以的

[1] 2 4 5

> f2<-a[-c(1,3)] #上面f1是把负号放在向量里面，放外面其实也是可以的耶！

> f2

[1] 2 4 5

>

> #突发奇想，如果a[]，中括号里面的向量里面与外面都有负号呢？试一试！

> f3<-a[-c(-1,-3)]

> f3 #f3的结果显示第1位与第3位的元素，嗯~~，那就可以理解为负负得正，直接把a中的第1和3位赋值给f3

[1] 1 3

> f4<-a[-c(-1,3)] #脑子抽风了，这种行不行呢？哈！！！！它报错，对的报错了，那就不可以咯！

Error in a[-c(-1, 3)] : only 0's may be mixed with negative subscripts

3.向量元素的添加

上面我们提到了向量元素的索引与元素的删除，那能不能加元素进去呢？？答案肯定是能得，那么如何加入元素呢？这就要用到向量的素引了，看如下代码与注释：

> a<-1:5 #这里有一个向量a，我想在第2与第3个位置上加上一个元素6，如下

> g1<-c(a[1:2],6,a[3:5]) #这中方法结果是可行的，可以理解为，把a分为两部分，中间插一个6

> g1

[1] 1 2 6 3 4 5

> g2<-c(a[1:2],7,9,10,a[3:5]) #多插如几个都是可以的

> g2

[1] 1 2 7 9 10 3 4 5

> #当然比较短的向量就可以重新写一个，但是如果有几万个，上面的方法是很不错的

向量长度的获取

我有一个非常长的向量，我并不知道它的长度，我们可以使用length()函数获取向量长度，如下代码：

> a1<-99:10058

> length(a1) #运行函数后返回了向量a1的长度

[1] 9960

向量的注意要点

向量在使用之前需要进行声明，声明主要有两种：

1.变量名<-c(········)；变量名与向量元素同时确定，如：

a<-c(1,2,4,5,7,8) #使用了c(····)的形式，a就默认为一个向量

2.直接创建一个空向量，后赋值，如：

> b<-vector(length=5) #建立一个名字为b，长度为5的空向量

> b[3]<-6 #第3位元素赋值为6

> b #查看结果，可以看到第三位是6，其他为0，因为之前提到过，空向量里的值都为FALSE

[1] 0 0 6 0 0 #当里面出现数值时，其他位置的FALSE变为数字0

还需注意向量元素的类型

如何判断一个变量类型呢？我们可以使用mode()函数查看变量类型，或者使用typeof()函数

1.当向量元素同时含有数值与字符型时，返回的结果为字符型，数值型转变为了字符型，在后续处理数据时需要注意，只要出现了字符型元素，则此向量应当作字符型向量处理，如下：

> c<-c(1,3,"ABC")

> mode(c) #查看一下c是什么类型的数据，返回结果是字符型

[1] "character"

> c

[1] "1" "3" "ABC"

2.当向量元素同时含有数值型与逻辑型时，返回结果为数值型，逻辑性转变为数值型，其中FALSE转变为0，TRUE转变为1。如：

> c1<-c(1,5,FALSE,TRUE)

> mode(c1) #查看一下c是什么类型的数据，返回结果是数值型

[1] "numeric"

> c1

[1] 1 5 0 1

3.当向量同时含有数值型、逻辑型与字符型时，全部转变为字符型，如：

> c2<-c(1,5,FALSE,TRUE,"ABC")

> mode(c2) #查看一下c2是什么类型的数据，返回结果是字符型

[1] "character"

> c2

[1] "1" "5" "FALSE" "TRUE" "ABC"

总结：逻辑性可以转化为数值型与字符型，数值型可以转化为字符型，注意：字符型不可以转换为逻辑与数值型， as.数据类型()可以进行强制转换,如下

> c1<-c(1,5,FALSE,TRUE)

> as.character(c1) #将c1强制转换为字符型

[1] "1" "5" "0" "1"

> as.numeric(c1) #将c1强制转换为数值型

[1] 1 5 0 1

向量的计算

1.向量的循环补齐，使用向量相加的例子举例，（相加与相减类似）如：

> c(3,4)+c(8,9) #8+3=11，9+4=13，这是两个向量长度相同的

[1] 11 13

> c(2,4)+c(2,3,4,5,6) #2+2，3+4，4+2，5+4，6+2，能算，但长度不相同的会出现警告

[1] 4 7 6 9 8

Warning message:

In c(2, 4) + c(2, 3, 4, 5, 6) :

longer object length is not a multiple of shorter object length

2.向量相乘，使用*号。长度相同时，两向量对应元素相乘，但长度不同时会出现警告，会使用向量循环补齐的方式计算，如下：

> c(1,3)*c(3,5) #长度相同，对应元素相乘，3×1，5×3

[1] 3 15

> c(1,3,5)*c(2,4,7,8,10) #长度不同，补齐方式计算，2×1，4×3，7×5，8×1，10×3

[1] 2 12 35 8 30

Warning message:

In c(1, 3, 5) * c(2, 4, 7, 8,10) :

longer object length is not a multiple of shorter object length

3.向量取余使用%%,长度相同时，对应元素取余，长度不同时，出现警告，循环补齐式取余，请看如下代码：

> c(1,3)%%c(5,9) #1÷5余1，3÷9余3，长度相同，对应元素取余

[1] 1 3

> c(5,9)%%c(1,3) #5÷1余0，9÷3余0，长度相同，对应元素取余

[1] 0 0

> c(1,3,10)%%c(2,4,5,8,3) #长度不同，1÷2余1，3÷4余3，10÷5余0，1÷8余1，3÷3余0

[1] 1 3 0 1 0

Warning message:

In c(1, 3, 10)%%c(2, 4, 5, 8, 3) :

longer object length is not a multiple of shorter object length

向量的相关函数（部分）

与向量相关的函数有很多，不一一介绍，介绍几个比较简单常用的

1.seq()函数

seq(from,to,by=), 从什么到什么，间隔（by）为多少，（等差数列，公差就是by的值）

seq(from,to,length.out=),从什么到什么，长度为多少；详情看如下代码：

> seq(from=3,to=12,by=3) #从3到12，间隔(公差)为3

[1] 3 6 9 12

> seq(3,12,3) #from，to by 可以不写，默认

[1] 3 6 9 12

> seq(from=3,to=12,length.out=6) #从3到12，长度为6

[1] 3.0 4.8 6.6 8.4 10.2 12.0

2.rep() 函数

rep(x,time)，x重复time次，rep是重复repeat的简写

rep(x,each)，每个连续重复each次，详情如下：

> x<-c(1,3)

> rep(x,time=2) #重复两次整体x

[1] 1 3 1 3

> rep(x,each=2) #x里的元素每一个重复两次

[1] 1 1 3 3

> rep(x,2) #既不写time也不写each，默认为time

[1] 1 3 1 3

3.all()、any() 与match()函数

all()，判断元素是否都符合条件，返回逻辑值 ，只要有一个不满足，返回FALSE，看如下代码：

ang()，判断是否有元素满足条件，返回逻辑值，只要有一个满足，返回TRUE，如下代码：

> a #我用向量a举例子

[1] 1 2 3 4 5

> all(a>0) #判断a里的元素是否都大于0，返回了TRUE

[1] TRUE

> all(a>3) #判断a里的元素是否都大于3,返回了FALSE

[1] FALSE

> any(a>4) #判断a中是否有大于4的元素，返回了TRUE

[1] TRUE

> any(a>6) #判断a中是否有大于6的元素，返回了FALSE

[1] FALSE

match()，意为匹配的意思，例如：match(A,B),判断向量A的元素在向量B里是否有，若有则返回在B中的位置，若没有，则返回NA；两向量长度不等时，循环补齐时判断，要注意时哪一个向量要循环，请看如下代码：

> match(c(1,4,5),c(2,4,3)) #两向量长度相同，第二个是相同的，返回相同的位置，其他返回NA

[1] NA 2 NA

> match(c(1,4,5),c(2,4)) #长度不等，1与2判断，4与4判断，5与2判断

[1] NA 2 NA

> match(c(1,4),c(2,4,3)) #长度不等，1与2判断，4与4判断，第一个元素都判断完了，直接结束，返回结果

[1] NA 2

> match(c(1,4,5,6,2,4),c(2,4))

[1] NA 2 NA NA 1 2

NA与NULL值

NA表示存在但未知的数，NULL代表不存在的数

当数据中存在NA值是，要么删掉，但可能会让结果有偏差（尤其是在做科研时处理较大的数据时慎重考虑），要么给它一个这组数据的平均数或者是其他，看你处理什么数据与看你的需求。

NULL还有其他用法，比如在循环中创建一个向量，便于存数据。

举例如下：

> mean(c(3,5,7,9,NA)) #存在NA值，无法确定NA值的大小，返回结果也未知

[1] NA

> mean(c(3,5,7,9,NA),na.rm=T) #把NA值删掉

[1] 6

> mean(c(3,5,7,9,NULL)) #NULL值根本不存在，不影响结果

[1] 6

向量元素的筛选

以下举例几个常用函数

1.which()函数

which() 返回满足条件元素的位置，注意是返回位置，如：

> a<-c(1,5,7,4,9)

> which(a==4) #返回a等于4的元素的位置，位置为4

[1] 4

> which(a>5) #返回a大于5的元素的位置，第3与第5是大于5的

[1] 3 5

2.subset()函数

subset() 函数是返回符合条件的元素，但会忽略NA值。注意：条件应为逻辑值，否则会报错，详情看如下代码：

> x<-c(1,3,7,NA,10) #一个含有NA值的向量

> x[x>6] #用向量的索引查看一下x>6的元素

[1] 7 NA 10

> subset(x,x>6) #筛选x>6的元素，可以注意到它忽略了NA值，x>6可以理解为一个逻辑向量

[1] 7 10

3.ifelse()函数

ifelse(x,a,b) 函数判断元素x是否符合条件，如符合，返回a，若不符合，返回b。其中x为逻辑值， 如：

> X<-1:10

> Y<-ifelse(X%%2==0,1,0) #如果为偶数，返回1，奇数，返回0

> Y

[1] 0 1 0 1 0 1 0 1 0 1

进阶

> temp0<-sample(c(5,6),50,replace=T) #我用sample函数随机生成一个长度为50，元素只有5与6，随机生成

> temp0 #看一下temp0

[1] 6 5 6 5 6 5 5 6 6 6 5 6 5 5 5 6 5 6 6 6 5 6 5 6 5

[26] 6 6 6 6 5 5 5 6 5 6 5 6 5 5 6 5 5 6 6 6 6 5 6 5 5

> #我想计算一下temp0中数字5出现的次数，有多种方法

> #方法一

> temp1<-ifelse(temp0==5,1,0) #我让为5的等于1，不为5的等于0，

> sum(temp1) #求和一下，结果就为temp0中5的个数

[1] 24

>

> #方法二

> temp2<-temp0 #temp2等于temp0，防止temp0数据被更改

> temp2[temp2==5]<-1 #让元素为5的等于1

> temp2[temp2==6]<-0 #让元素为6的等于0

> sum(temp2) #求和，就是5的个数

[1] 24

>

> #方法三

> temp3<-which(temp0==5) #找向量temp0中为5的位置，并用一个向量接受它

> length(temp3) #在算temp3的长度

[1] 24

> length(which(temp0==5)) #还能简化一下上两行的代码，直接出向量temp0中为5的元素个数

[1] 24

>

> #方法多种多样，只要能出正确结果的方法都能，只是代码复杂度的问题，我不再一一列举，各位有兴趣可以自行探索

向量相等

有多种方法可以判断两向量是否相等

1.all()函数 ，返回逻辑值

2.identical（）函数，判断两向量是否相等，返回逻辑值

3.自定义函数，(自己写一个函数判断)

all()函数与identical()使用及两者区别直接请看如下代码：

> d1<-c(1,5,7,9)

> d2<-c(1,5,7,9)

> d3<-c(2,4,7,9)

> d4<-1:5

> d5<-c(1,2,3,4,5)

> all(d1,d2) #判断d1与d2是否相等，返回了TRUE，但是出现了警告

[1] TRUE

Warning messages:

1: In all(d1, d2) : coercing argument of type 'double' to logical

2: In all(d1, d2) : coercing argument of type 'double' to logical

> all(d1,d3) #判断d1与d3是否相等，返回了TRUE，但是出现了警告

[1] TRUE

Warning messages:

1: In all(d1, d3) : coercing argument of type 'double' to logical

2: In all(d1, d3) : coercing argument of type 'double' to logical

> identical(d1,d2) #判断d1与d2是否相等，返回了TRUE

[1] TRUE

> identical(d1,d3) #判断d1与d3是否相等，返回了FALSE

[1] FALSE

> all(d4,d5) #判断d4与d5是否相等，返回了TRUE，但是出现了警告

[1] TRUE

Warning message:

In all(d4, d5) : coercing argument of type 'double' to logical

> identical(d4,d5) #判断d4与d5是否相等，返回了FALSE

[1] FALSE

>

> #在对比d4与d5时，all与identical出现了不同的结果，虽然内容相同，但是定义向量的方式不同，有区别，

> #这是all与identcal的主要区别。

数据结构的查看

上面一部分,我们了解了R含有向量的数据结构，当然还有其他数据结构，比如矩阵、数据框、列表等，我们可以使用class(),

控制语句

ifelse()函数，iflese(x,a,b)，如果x为TRUE，则执行a,否者执行b

for循环

for(i in x){·········}，i在循环会取遍x中的值，例如：

> for(i in c(1,5,7)) # i 在1，5，7中从左到右依次取

+ {

+ print(i^2)

+ }

[1] 1

[1] 25

[1] 49

next与break

next在for中表示继续循环，break表示跳出循环，例如:

> for(i in c(1,5,7))

+ {

+ ifelse(i<=5,print(i^2),next)

+ }

[1] 1

[1] 25

> for(i in c(1,5,7,8))

+ {

+ ifelse(i<=7,print(i^2),break)

+ }

[1] 1

[1] 25

[1] 49

while()函数

和C语言用法一样，当括号里条件为TRUE时，执行语句

> a<-3

> while(a==3)

+ {

+ print(a+1)

+ a<-FALSE

+ }

[1] 4

repeat()函数

意为重复，搭配if、break使用，不用break跳出程序将陷入死循环

repeat

{

a<-a+1

if(a>7)

{

break

}

}

if(···){···}else{···}语句

特别注意else必须跟在第一个大括号后面，否则报错，举例如下：

> for(i in c(1,2,3,4,5))

+ {

+ if(i<=3)

+ {

+ print(i^2)

+ }else #else必须跟在第一个大括号后面

+ {

+ print(i^3)

+ }

+ }

[1] 1

[1] 4

[1] 9

[1] 64

[1] 125

逻辑运算符

和C语言差不多，&&表示与，||表示或，！表示非

函数返回值

1.利用return返回结果

2.如果没有return则返回语句最后一行执行的结果，举例如下：

> F<-function(a)

+ {

+ k<-a

+ return(k)

+ }

> F(3) #利用return返回结果

[1] 3

> F1<-function(a,b)

+ {

+ d<-a-b

+ c<-a+b

+ c

+ }

> F1(5,2) #返回最后执行的语句值

[1] 7

全局变量与局部变量

如果学过C语言好理解；如果没学过，可以把全局变量理解为在函数内部无法改变的变量，局部变量就是在函数内部的变量，具有临时性。如：

> b<-5 #全局变量

> f3<-function(x)

+ {

+ b<-7 #这个并没有改变外面那个b

+ b1<-x #局部变量，在函数外访问不到，函数返回结果后被删除

+ b2<-b+b1

+ return(b2)

+ }

> f3(9)

[1] 16

> b #b没有发生变化

[1] 5

> b1 #在函数中是局部变量，函数返回结果后被删除，所以无法找到

Error: object 'b1' not found

矩阵

矩阵（matrix) 是一种特殊的向量，包含两个附加的属性：行数和列数，R生存矩阵时按列存储。

注意向量不能看成只有1列或1行的矩阵

矩阵的创建

1.利用函数matrix()函数

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,dimnames = NULL)；其中data表示要处理的数据（向量)，nrow表示行，ncol表示列，byrow表示是否按行排列，默认是列排，dimnames表示行与列的名字，默认是没有，要使用列表设置。如下代码：

> mydata<-matrix(c(1,2,3,4,5,6),nrow=2,ncol=3) #两行三列，默认按列排

> mydata

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

[1,] 1 3 5

[2,] 2 4 6

> mydata1<-matrix(c(1,2,3,4,5,6),nrow=2,ncol=3,byrow=T) #两行三列，按行排

> mydata1

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

[1,] 1 2 3

[2,] 4 5 6

> mydata3<—matrix(c(1,2,3,4,5,6),nrow=2,ncol=3,dimnames=list(c("r1","r2"),c("c1","c2","c3")))

> mydata3 #设置了名字，名字要用列表list形式，如上一行代码

c1 c2 c3

r1 1 3 5

r2 2 4 6

2.利用函数将向量接起来，函数有rbind()按行接起来、cbind()按列接起来，例子代码如下：

> mydata5<-rbind(c(1,2,3),c(4,5,6)) #按行将两个向量接起来，形成矩阵

> mydata5

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

[1,] 1 2 3

[2,] 4 5 6

> mydata6<-cbind(c(1,2,3),c(4,5,6)) #按列将两个向量接起来，形成矩阵

> mydata6

[,1] [,2]

[1,] 1 4

[2,] 2 5

[3,] 3 6

3.强制转换为矩阵

利用as.matrix()函数强制转换为矩阵，如：

> a<-c(1,2,3,4,5,6,7,8)

> a1<-as.matrix(a) #强制转换为矩阵，但是只有一列

> a1

[,1]

[1,] 1

[2,] 2

[3,] 3

[4,] 4

[5,] 5

[6,] 6

[7,] 7

[8,] 8

4.建立一个空矩阵

直接写行列大小，如下：

> d<-matrix(nrow=3,ncol=2) #建立一个3行2列的空矩阵，内容为NA，存在但未知

> d

[,1] [,2]

[1,] NA NA

[2,] NA NA

[3,] NA NA

注意事项

当两个向量长度不相等时，会出现警告，长度不等的那个向量会用循环补齐的形式填补，如下：

> mydata7<-cbind(c(1,2,3,4,5),c(4,5)) #后一个向量短，出现警告，后面循环补上

Warning message:

In cbind(c(1, 2, 3, 4, 5), c(4, 5)) :

number of rows of result is not a multiple of vector length (arg 2)

> mydata7

[,1] [,2]

[1,] 1 4

[2,] 2 5

[3,] 3 4

[4,] 4 5

[5,] 5 4

> mydata8<-cbind(c(1,2),c(4,5,6,7,8)) #前面一个短，出现警告，前一个循环补齐

Warning message:

In cbind(c(1, 2), c(4, 5, 6, 7, 8)) :

number of rows of result is not a multiple of vector length (arg 1)

> mydata8

[,1] [,2]

[1,] 1 4

[2,] 2 5

[3,] 1 6

[4,] 2 7

[5,] 1 8

当向量中含有不同类型的数据时，会改变元素类型后转变为矩阵，如下:

> mydata10<-matrix(c(2,5,FALSE,TRUE),2,2) #向量含有逻辑与数值型，逻辑转为数值，2行2列按列排

> mydata10

[,1] [,2]

[1,] 2 0

[2,] 5 1

> #向量含有逻辑,字符与数值型，全部转为字符，2行3列按列排

> mydata9<-matrix(c(1,3,FALSE,TRUE,"ABC","babiQ"),2,3)

> mydata9

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

[1,] "1" "FALSE" "ABC"

[2,] "3" "TRUE" "babiQ"

矩阵的索引

使用下标和中括号来选择矩阵中的行或列或元素，矩阵名+中括号，中括号里面写需要的行与列

我有一个矩阵，名字为mymatrix，5行5列，如下：

> mymatrix<-matrix(c(1:25),5,5)

> mymatrix

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

[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

矩阵每一行前或列首都有一个中括号括起来的，可以理解为这一行或列

1.mymartix[i,]，返回矩阵mymatrix中第i行元素，如：

> mymatrix[3,] #返回第三行元素

[1] 3 8 13 18 23

2.mymartix[,j]，返回矩阵mymatrix中第j列元素，如：

> mymatrix[,5] #返回第5列元素

[1] 21 22 23 24 25

3.mymartix[i,j]，返回矩阵mymatrix中第i行第j列元素，如：

> mymatrix[2,2] #返回第2行第2列元素

[1] 7

4.mymatrix[i,-j]，返回第i行,但排除第j列元素，如：

> mymatrix[2,-3] #返回第2行,但排除第3列元素

[1] 2 7 17 22

5.mymatrix[-i,j]，返回第j列，但排除第i行元素，如：

> mymatrix[-3,2] #返回第2列，但排除第3行元素

[1] 6 7 9 10

6.mymatrix[c(m,n),c(p,k)]，返回第m和n行，第p和k列元素，如：

> mymatrix[c(1,3),c(3,5)] #返回第1和3行，第3和5列元素

[,1] [,2]

[1,] 11 21

[2,] 13 23

7.mymatrix[-c(m,n),c(p,k)]，返回第p和k列，但排除第m和n行元素，如：

> mymatrix[-c(1,3),c(3,5)] #返回第3和5列，但排除第1和3行元素

[,1] [,2]

[1,] 12 22

[2,] 14 24

[3,] 15 25

8.当矩阵有行列名时，可以通过行与列名进行提取元素，如:

> mymatrix3#这里有一个矩阵

c1 c2 c3 c4 c5 行均值

r1 1 6 11 16 21 11

r2 2 7 12 17 22 12

r3 3 8 13 18 23 13

r4 4 9 14 19 24 14

r5 5 10 15 20 25 15

列均值 3 8 13 18 23 NA

> mymatrix3["r1","c2"]#返回列名c2，行名为r1的元素

[1] 6

> mymatrix3[c("r2","r4"),c("c3","c5")]#返回行名为r2与r4,列名为c3与c5的元素

c3 c5

r2 12 22

r4 14 24

drop处理意外降维

上面矩阵的引用1~5条，从一个矩阵中提取的结果都为向量，如果说，我取一行或一列后返回结果要求是矩阵，虽然说可以先取后转变为矩阵，但相对还是麻烦了，我们可以加入drop防止降维，如：

> mymatrix<-matrix(c(1:25),5,5)

> mymatrix[2,] #直接取就会降维为向量

[1] 2 7 12 17 22

> mymatrix[2,,drop=F] #如果要求取出是矩阵，则加入drop=F

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

[1,] 2 7 12 17 22

矩阵相关操作及相关函数（部分）

1.转置，函数t(),如：

> mymatrix<-matrix(c(1:25),5,5) #我这里有一个矩阵

> mymatrix

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

[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

> mymatrix1<-t(mymatrix) #对函数进行转置，返回结果如下

> mymatrix1

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

[1,] 1 2 3 4 5

[2,] 6 7 8 9 10

[3,] 11 12 13 14 15

[4,] 16 17 18 19 20

[5,] 21 22 23 24 25

2.横向或纵向合并矩阵

cbind()函数横向合并矩阵

rbind()函数纵向合并矩阵，举例如下：

> M<-matrix(c(1,2,3,4),2,2)

> N<-matrix(c(5,6,7,8),2,2) #建立了两个矩阵M,N，如下

> M

[,1] [,2]

[1,] 1 3

[2,] 2 4

> N

[,1] [,2]

[1,] 5 7

[2,] 6 8

> cbind(M,N)#横向合并矩阵M,N

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

[1,] 1 3 5 7

[2,] 2 4 6 8

> rbind(M,N)#纵向合并矩阵M,N

[,1] [,2]

[1,] 1 3

[2,] 2 4

[3,] 5 7

[4,] 6 8

3.对各列或行求和或求均值

colSums()对各列求和，rowSums()对各行求和

colMeans()对各列求均值，rowMeans()对各行求均值，举例如下：

> mymatrix#以这个矩阵举例

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

[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

> colSums(mymatrix)#对各列求和

[1] 15 40 65 90 115

> rowSums(mymatrix)#对各行求和

[1] 55 60 65 70 75

> colMeans(mymatrix)#对各列求均值

[1] 3 8 13 18 23

> rowMeans(mymatrix)#对各行求均值

[1] 11 12 13 14 15

4.计算行列式

det()函数，计算行列式，举例如下：

> M

[,1] [,2]

[1,] 1 3

[2,] 2 4

> det(M)

[1] -2

5.矩阵相乘

使用%*%进行矩阵相乘，举例如下：

> M

[,1] [,2]

[1,] 1 3

[2,] 2 4

> N

[,1] [,2]

[1,] 5 7

[2,] 6 8

> K<-M%*%N#两矩阵相乘

> K

[,1] [,2]

[1,] 23 31

[2,] 34 46

6.设置行列名

设置行列名有三种以上方式，这里介绍三种常用的

在创建矩阵时设置行列名，如

> #使用dimnames，以列表的形式设置行列名

> fa<-matrix(c(2,3,4,5),2,2,dimnames =list(c("第一行","第二行"),c("第一列","第二列")))

> fa

第一列 第二列

第一行 2 4

第二行 3 5

在外部使用dimnames()函数设置行列名

> fa1<-matrix(c(6,7,8,9),2,2) #矩阵原先未设置行列名

> a<-c("第一行","第二行")

> b<-c("第一列","第二列")

> dimnames(fa1)<-list(a,b) #使用dimnames函数设置行列名

> fa1

第一列 第二列

第一行 6 8

第二行 7 9

使用函数rownames()设置行名，使用colnames()设置列名

> fa2<-matrix(c(1,3,5,7),2,2) #行列未命名的矩阵

> rownames(fa2)<-c("A1","A2") #对行命名

> colnames(fa2)<-c("B1","B2")#对列命名

> fa2

B1 B2

A1 1 5

A2 3 7

apply()函数

apply(m,dimcode,f,fargs) 允许用户在各行各列调用函数

m 矩阵，dimcode 1代表行， 2代表列，f函数，frags可选参数，函数大于一个参考时使用用“，”隔开。

> mymatrix<-matrix(c(1:25),5,5)#建立了一个矩阵

> mymatrix

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

[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

>

> mymatrix_rowmean<-apply(mymatrix,1,mean) #对行求均值

> mymatrix_colmean<-apply(mymatrix,2,mean) #队列求均值

> mymatrix_rowmean1<-matrix(mymatrix_rowmean,length(mymatrix_rowmean),1) #转换为一列的矩阵

> mymatrix_colmean1<-matrix(mymatrix_colmean,1,length(mymatrix_colmean)) #转换为一行的矩阵

> mymatrix_colmean1[6]<-NA #矩阵右下角有个空，用NA值填一下，方便连接

> mymatrix2<-cbind(mymatrix,mymatrix_rowmean1) #按列把两个矩阵接起来

> mymatrix3<-rbind(mymatrix2,mymatrix_colmean1) #按列把两个矩阵接起来

> a<-c("r1","r2","r3","r4","r5","列均值")

> b<-c("c1","c2","c3","c4","c5","行均值")

> dimnames(mymatrix3)<-list(a,b) #设置行列名

> mymatrix3#展示结果

c1 c2 c3 c4 c5 行均值

r1 1 6 11 16 21 11

r2 2 7 12 17 22 12

r3 3 8 13 18 23 13

r4 4 9 14 19 24 14

r5 5 10 15 20 25 15

列均值 3 8 13 18 23 NA

数据结构的查看

上面一部分,我们了解了R含有向量，矩阵数据结构，当然还有其他数据结构，比如数据框、列表等，我们可以使用class(),如：

> mymatrix<-matrix(c(1:25),5,5)

> class(mymatrix)

[1] "matrix" "array"

> a<-c(1,2)

> class(a)

[1] "numeric"

判断对象是否是矩阵

1.使用attributes()函数，若是矩阵返回一个维度，若不是，返回NULL值，如下：

> mymatrix<-matrix(c(1:25),5,5)

> attributes(mymatrix) #返回维度，5行5列

$dim

[1] 5 5

> attributes(mymatrix[2,]) #向量无维度，返回NULL值

NULL

2.使用is.matrix()函数，如：

> mymatrix<-matrix(c(1:25),5,5)

> is.matrix(mymatrix) #判断mymatrix是不是一个矩阵，若是返回TRUE,不是返回FALSE

[1] TRUE

> is.vector(mymatrix[2,])#判断mymatrix[2,]是不是向量，是返回TRUE，不是返回FALSE

[1] TRUE

列表

列表（list） 是R的数据类型中最为复杂的一种。一般来说，列表就是一些对象（或成分，component）的有序集合。列表允许整合若干（可能无关的）对象到单个对象名下。

列表允许以一种简单的方式组织和重新调用不相干的信息。

许多R函数的运行结果都是以列表的形式返回的。函数需要返回两个以上变量时需采用list形式返回。

列表的创建

使用list(·····)创建列表，list(object1,object2······)其中的object可以是到目前为止提到的任何数据类型，比如：向量，矩阵，列表等。下面举个例子，如：

> d<-"our one list " #单个字符

> d1<-c(1,2,4,7,9) #向量

> d2<-matrix(c(2,4,6,8),2,2,byrow=T) #矩阵

> ourlist<-list(d,d1,d2) #建立列表

> ourlist #查看列表

[[1]]

[1] "our one list "

[[2]]

[1] 1 2 4 7 9

[[3]]

[,1] [,2]

[1,] 2 4

[2,] 6 8

声明列表

之前提过如何建立一个空向量，现在建立（声明）一个空列表也差不多，如下：

> ourlist2<-list() #建立或声明一个空向量

> mode(ourlist2) #查看一下类型，返回结果是列表

[1] "list"

标签或者对象名的命名

每一个列表组件都可设置标签，就像向量的变量名或矩阵的行列名一样，标签会显示在$的后面。命名的方式很简单直接在建立列表时直接命名，如

> d<-"our one list "

> d1<-c(1,2,4,7,9)

> d2<-matrix(c(2,4,6,8),2,2,byrow=T)

> d3<-list(c(1,2),c(3,4)) #列表

> ourlist3<-list("字符"=d,d1=d1,juzhen=d2,d3) #注意我这里列表里嵌套了一个列表

> #第一个组件名字是“字符”，第二个是d1，第三个是juzhen

>

> ourlist3 #$符号的后面是标签（组件名），如果没有标签的那个，$号会变成[[数字]]，如第4个

$字符

[1] "our one list "

$d1

[1] 1 2 4 7 9

$juzhen

[,1] [,2]

[1,] 2 4

[2,] 6 8

[[4]]

[[4]][[1]]

[1] 1 2

[[4]][[2]]

[1] 3 4

删除标签

这里讲的删除标签是删除列表中的所有标签，有两个函数可以使用

使用unname()函数去掉标签，如：

> listxx<-list(d3=c(2,4,6,8),d4=c(1,3,5,7))

> listxx

$d3

[1] 2 4 6 8

$d4

[1] 1 3 5 7

> unname(listxx) #去掉标签

[[1]]

[1] 2 4 6 8

[[2]]

[1] 1 3 5 7

使用NULL

> listxx1<-list(d5=c(2,4,6,8),d6=c(1,3,5,7))

> listxx1 #这个列表是有标签的

$d5

[1] 2 4 6 8

$d6

[1] 1 3 5 7

> names(listxx1)<-NULL#给标签一个NULL值

> listxx1#列表标签被删除

[[1]]

[1] 2 4 6 8

[[2]]

[1] 1 3 5 7

鬼点子

既然我们上面看到了使用names()<-NULL,可以删掉标签，那么如果把NULL值换成向量是不是可以更换列表标签呢？（这是我写这篇文章的时候突发奇想的，之前并不知道），我直接试了一下，如下：

> listxx2<-list(D1=c(2,4,6,8),D2=c(1,3,5,7))

> listxx2#兄弟们，这是可以的

$D1 ##### #####

[1] 2 4 6 8 ### ### ### ###

$D2

[1] 1 3 5 7 ## ##

## ##

> names(listxx2)<-c("f1","f2") ## ##

> listxx2##########

$f1

[1] 2 4 6 8

$f2

[1] 1 3 5 7

列表元素的索引

列表元素的索引有多种，一是索引列表某组件，二是索引列表中某组件里的内容

一、索引列表某组件

1.如果有标签，可以通过标签索引一个组件整体，方法与向量，矩阵的访问差不多，如，我们用上面例子，ourlist3举例：

> ourlist3["字符"] #中括号里写标签，注意要用双引号

$字符

[1] "our one list "

> ourlist3[1] #直接中括号里一个数字，这个数字代表的是列表里第几个组件

$字符

[1] "our one list "

2.无论有无标签，都可以直接用组件序号索引，如

> ourlist4<-list(c(1,2),c(3,5)) #有一个列表，没有给组件设置标签

> ourlist4[2] #直接可以中括号里写组件序号索引一整个组件

[[1]]

[1] 3 5

> class(ourlist4[2])#class一下，ourlist4[2]是一个列表

[1] "list"

二、索引列表某组件中的内容

1.如果有标签，有两种方式索引组件内容

使用$符号索引组件内容，变量名+$+标签 ，如：

> ourlist5<-list(a=c(1,2),b=c(3,5),c(5,6)) #这里有一个列表，两个有标签

> ourlist5 #查看一下，是我预期结果

$a

[1] 1 2

$b

[1] 3 5

[[3]]

[1] 5 6

> ourlist5$a #使用$符号加标签索引

[1] 1 2

> ourlist5$b

[1] 3 5

> class(ourlist5$a) #class一下ourlist5$4,它是数值型内容

[1] "numeric"

使用两个中括号，中括号里写标签，标签要用双引号，如：

> ourlist5<-list(a=c(1,2),b=c(3,5),c(5,6))

> ourlist5[["a"]] #两个中括号，中括号里写标签，标签要用双引号

[1] 1 2

> ourlist5[["b"]]

[1] 3 5

2.无论有无标签，都可用两个中括号，中括号里写组件序号索引组件内容 ，如

> ourlist5<-list(a=c(1,2),b=c(3,5),c(5,6))

> ourlist5[[1]] #两个中括号，中括号里写组件序号访问

[1] 1 2

> ourlist5[[3]]

[1] 5 6

列表元素的增减

1.增加元素

当我有一个列表，已经创建完毕，但还需加入元素时，可以直接通过索引的方式赋值，如：

方法一，通过两个中括号的方式，本来没有第三个的，直接加一个进去，R灰常银杏话（nice）

> ourlist6<-list(a=c(1,2),b=c(3,5)

+ )

> ourlist6[[3]]<-TRUE#第三个给它一个TRUE

> ourlist6

$a

[1] 1 2

$b

[1] 3 5

[[3]]

[1] TRUE

方法二，通过$符号，直接标签与内容一次性直接加进去。

> ourlist7<-list(a=c("很好","非常好"),b=c("good","nice"))

> ourlist7$c<-"好极了"#

> ourlist7

$a

[1] "很好" "非常好"

$b

[1] "good" "nice"

$c

[1] "好极了"

2.减元素

把你不需要的，直接赋值为NULL，之前提过NULL表示啥也没有，请直接看代码，如;

> ourlist7#我这里有一个列表，他有三个元素

$a

[1] "很好" "非常好"

$b

[1] "good" "nice"

$c

[1] "好极了"

> ourlist7$b=NULL #现在把第二个删掉，赋给它一个NULL值，看如下结果

> ourlist7

$a

[1] "很好" "非常好"

$c

[1] "好极了"

当然仿照向量使用负索引也是可以的，如：

> ourlist8<-list(a=c("很好","非常好"),b=c("good","nice"))

> #这里使用另一个变量ourlist9来接受它，因为和向量一样，负索引不会对原来的有影响

> ourlist9<-ourlist8[-2]

> ourlist9

$a

[1] "很好" "非常好"

>

>

> ourlist8#ourlist8是没有改变的，ourlist9是ourlist8删了第二项后的

$a

[1] "很好" "非常好"

$b

[1] "good" "nice"

获取标签

直接使用names()函数获取列表所有标签，如：

> ourlist8<-list(a=c("很好","非常好"),b=c("good","nice"))

> names(ourlist8)#返回结果是列表所有标签，如果列表好多标签，可以选择你需要的标签索引元素

[1] "a" "b"

解除列表

直接使用unlist()函数解除列表，（可以理解为一个列表让它散架）

> ourlist8<-list(a=c("很好","非常好"),b=c("good","nice"))

> unlist(ourlist8)#返回结果是字符型向量，标签会各自显示在上方

a1 a2 b1 b2

"很好" "非常好" "good" "nice"

> class(unlist(ourlist8))

[1] "character"

列表相关函数（部分）

1.lapply()函数

lapply()-list apply 给每个组件执行给定函数，返回列表，和矩阵apply()类似，同属于apply家族

使用方法：lapply(目标列表，函数)，举例如下 ：

> listaa1<-list(a1=c(1,3,5,7,9),a2=c(2,4,6,8,10))

> lapply(listaa1,mean) #对每一个组件执行求均值

$a1

[1] 5

$a2

[1] 6

> lapply(listaa1,max) #返回组件内容中的最大值

$a1

[1] 9

$a2

[1] 10

2.sapply()函数

与lapply()一样，只是返回的结果类型是向量，举例如下

> listaa1<-list(a1=c(1,3,5,7,9),a2=c(2,4,6,8,10))

> sapply(listaa1,mean) #返回结果是向量，标签与返回值竖一一对应

a1 a2

5 6

> class(sapply(listaa1,mean))

[1] "numeric"

数据框

数据框的创建

数据框类似矩阵，有行列两个维度。数据框允许不同的列可以包含不同类型的数据。注意：数据框可以看成每个组件长度相同的列表。。个人见解：数据框就像excel表格一样，比矩阵高级一点。很多东西都可以参考矩阵。

x<-data.frame(col1, col2, col3，……) 其中的列向量col1, col2, col3,… 可为任何类型（如字符型、数值型或逻辑型）。数据框可以看成每个组件长度相同的列表，数据框类似矩阵，有行列两个维度。建议数据框在Rstudio的左上角框里查看。数据框的创建举例如下：

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> #name,性别,age 是列名

> mydata1

name 性别 age

1 李华 男 18

2 张三 女 19

3 李怡 女 20

数据框的索引

数据框的索引与矩阵的索引差不多

1.索引一整各组件

使用一个中括号索引，中括号里写第几列序号，如：

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> mydata1[3]#索引第三列的age元素

age

1 18

2 19

3 20

> class(mydata1[3])#索引的结果是一个数据框

[1] "data.frame"

使用列名索引，与列表，矩阵相同，如：

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> mydata1["name"] #列名索引

name

1 李华

2 张三

3 李怡

> mydata1[c("age","name")]#这里使用了向量索引了两列

age name

1 18 李华

2 19 张三

3 20 李怡

> class(mydata1["name"])#索引的结果是一个数据框

[1] "data.frame"

> #当然还可以像矩阵一样索引多列多行，如：

> mydata1[,c(1,3)]#索引1，3列

name age

1 李华 18

2 张三 19

3 李怡 20

> mydata1[,c("name","age")] #使用列名索引1，3列

name age

1 李华 18

2 张三 19

3 李怡 20

> mydata1[c(1,2),c("name","age")]#索引特定的行列

name age

1 李华 18

2 张三 19

2.索引组件里的元素，和列表相同，如：

使用两个中括号，中括号里写列的序号或者是列名（列名要引号），如

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> mydata1[[2]]#中括号里写所需的列序号

[1] "男" "女" "女"

> mydata1[["性别"]]#中括号写列名，列名要加引号，因为它是字符型

[1] "男" "女" "女"

> class(mydata1[["性别"]])#索引后返回结果是字符型向量

[1] "character"

使用$符号索引，与列表相同

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> mydata1$性别

[1] "男" "女" "女"

> class(mydata1$性别)#索引后返回结果是字符型向量

[1] "character"

数据框有两个维度，可以返回多行多列的结果，具体操作方式与矩阵 相同，这里不过多阐述（怕读者读了睡觉）

数据框行列名的获取与更改

数据框行列名的读取与编辑有多种方式，这里介绍两种常用的

数据框列名的读取与更改

1.可以通过colnames(<数据框>)来读取并编辑列名称。 这种方式很银杏话（dog）,既可以单个读取或更改，也可以大量读取或更改，请看如下代码：

列名读取，colnames(数据框)[···]或者colnames(数据框)

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> colnames(mydata1)[1]#读取第一列列名，读取哪个中括号里就写几

[1] "name"

> colnames(mydata1)[c(1,2)] #我使用向量读取了两个

[1] "name" "性别"

> colnames(mydata1) #读取数据框所有列名

[1] "name" "性别" "age"

列名更改，colnames(数据框)[···]或者colnames(数据框)<-c(···)

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> colnames(mydata1)[1]<-"a"#更改第一列列名，要改第几个中括号里就写几

> mydata1

a 性别 age

1 李华 男 18

2 张三 女 19

3 李怡 女 20

> colnames(mydata1)[3]<-"c"#更改第三列列名

> mydata1

a 性别 c

1 李华 男 18

2 张三 女 19

3 李怡 女 20

> colnames(mydata1)<-c("a1","b","c1") #注意没有中括号了，我使用一个向量全部改了

> mydata1

a1 b c1

1 李华 男 18

2 张三 女 19

3 李怡 女 20

数据框行名的读取与更改

可以通过row.names(<数据框>)来读取并更改行名称

行名读取，row.names(数据框)[···]或row.names(数据框)，举例如下：

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> #读取所有行名，因为我没有设置行名，所以系统帮你默认了数字（可以在Rstudio左上角框里看到

> row.names(mydata1)

[1] "1" "2" "3"

> row.names(mydata1)[2]#还可以查看第几个第几个你想看的行名

[1] "2"

> row.names(mydata1)[c(2,3)]#多行中括号里就用向量

[1] "2" "3"

行名更改,row.names(mydata1)<-c(···)，举例如下：

> mydata1<-data.frame(name=c("李华","张三","李怡"),"性别"=c("男","女","女"),age=c(18,19,20))

> mydata1

name 性别 age

1 李华 男 18

2 张三 女 19

3 李怡 女 20

> #从上面的结果看到，我没有设置行名，系统默认了一个，往往按大部分需求是要改的

> row.names(mydata1)<-c("r1","r2","r3") #更改行名，结果如下：

> mydata1

name 性别 age

r1 李华 男 18

r2 张三 女 19

r3 李怡 女 20

数据框元素的增减

1.数据框元素的增加

和矩阵一样，也可以使用rbind()与cbind()函数添加行列，但需注意数据框使用rbind()时添加的行是数据框或列表。

添加列，举例如下：

> mydata2<-data.frame(name=c("李小华","张大三","李佳怡"),"性别"=c("男","男","女"),age=c(18,19,20)) #这里有一个数据框

> mydata2

name 性别 age

1 李小华 男 18

2 张大三 男 19

3 李佳怡 女 20

> higth<-c(175,173,167) #这里创建了一个身高的向量

> mydata3<-cbind(mydata2,higth) #按列合并，返回结果如下

> mydata3

name 性别 age higth

1 李小华 男 18 175

2 张大三 男 19 173

3 李佳怡 女 20 167

添加行，注意数据框使用rbind时添加的行是数据框或列表。举例如下：

> #这里直接沿用上面的例子

> mydata3

name 性别 age higth

1 李小华 男 18 175

2 张大三 男 19 173

3 李佳怡 女 20 167

> a<-data.frame(name="陈永鸿","性别"="男",age=21,higth=177) #要加入的新数据框code>

> a#看一下是不是我需要的

name 性别 age higth

1 陈永鸿 男 21 177

> rbind(mydata3,a)#按行合并数据框

name 性别 age higth

1 李小华 男 18 175

2 张大三 男 19 173

3 李佳怡 女 20 167

4 陈永鸿 男 21 177

2.数据框元素的删除

数据框元素的删除有多种方式，但方法与矩阵的差不多 ，直接看代码，如下：

使用负索引

> mydata2<-data.frame(name=c("李小华","张大三","李佳怡"),"性别"=c("男","男","女"),age=c(18,19,20))

> mydata2

name 性别 age

1 李小华 男 18

2 张大三 男 19

3 李佳怡 女 20

> #负索引的形式，但也要覆盖或这建立新数据框储存

> mydata4<-mydata2[-2,] #删掉第二行

> mydata4

name 性别 age

1 李小华 男 18

3 李佳怡 女 20

> mydata5<-mydata2[-3,-3] #删除第三行第三列

> mydata5

name 性别

1 李小华 男

2 张大三 男

赋予NULL值

> mydata2

name 性别 age

1 李小华 男 18

2 张大三 男 19

3 李佳怡 女 20

> mydata6<-mydata2

> #好像不可以使用NULL值取删除行，如果有同志会操作的可以在评论区留言

> mydata6[2,]<-NULL

Error in x[[jj]][iseq] <- vjj : replacement has length zero

> mydata6[,2]<-NULL #给第二列一个NULL值

> mydata6#查看mydata6,与删除前对比就是删除了第三列

name age

1 李小华 18

2 张大三 19

3 李佳怡 20

> mydata7<-mydata2

> mydata7[,"age"]<-NULL #使用列名也是可以的(呕心沥血)

> mydata7

name 性别

1 李小华 男

2 张大三 男

3 李佳怡 女

数据框相关函数

这里我直接用代码展示区域，我使用<code>box()函数描绘各区域边框，部分参数如下：

> par(oma=c(3,3,3,3)) #请把注意里放在par函数与box函数上，其他函数后面会提及

> lines1<-plot61<-plot(a,b,type="b",pch=23,col="blue",col.axis=2,xlim=c(0,40),ylim=c(5,65),col.main=2,col.sub="blue",main="红色框里的为plot区域",sub="plot61")code>

> lines2<-lines(c(5,10,20,25,32,35),c(5,25,35,45,50,55),type="b",pch=21,col="red")code>

> legend("topleft",inset=0.05,cex=0.8,title="lines",c("lines1","lines2"),pch=c(23,21),text.col=2)code>

> text(27,60,"lines1",col="blue")code>

> text(35,45,"lines2",col="red")code>

> box(which="plot",col="red",lwd=2)code>

> box(which="inner",col="black",lwd=4)code>

> box(which="figure",col="blue",lwd=3)code>

> box(which="outer",col="green",lwd=5)code>

红色框内为plot区域，蓝色内部为plot area区域，蓝色与红色之间为margin区域，绿色与蓝色之间为out margin area区域，结果如下：

par有许多参数，其中与plot部分一样，比如：col;lwd;lty;font;cex等，常用参数如下：