本文介绍了R语言的基本数据类型，如数字、逻辑和文本，以及向量、矩阵、列表和数据框的创建与操作。详细讲解了索引、循环结构（for和while）、条件结构和函数构建。此外，还涵盖了数据的导入导出、数据整理方法，如新建变量、过滤行、分组汇总和数据合并，以及统计学相关概念。
目录
获取路径
getwd()#获取当前工作目录
setwd("C:/rtext")#设置当前工作目录
getwd()
file.choose()#获取（查找）某一文件路径
ls()#列出当前环境对象
rm(a)#移除某一对象
数据类型
R 语言中的最基本数据类型主要有三种：数字，逻辑，文本
is.numeric(123)#判断是否为数字型
is.character("123")#判断是否为文本型
is.logical(TRUE)#判断是否为逻辑型
as.numeric('123')#将对象转化为数字型
as.logical(2.1)##将对象转化为逻辑型
a = 5
is.na(a)
as.numeric('asuka')
is.na(as.numeric('asuka'))
is.infinite(a)按对象类型来分是以下6种：向量（vector），列表（list），矩阵（matrix），数组（array），因子（factor），数据框(data.frame)
向量
#向量的生成
b <- 1:5
d <- c(1:5)
e <- c(3,5,4)
f <- c(b,e)
v6 <- seq(from=2,to=9,by=3)#构造一个从2开始，到9结束，步长为3的向量
v7 <- seq(2,9,3)#v6的简写
#向量的命名
names(v6)
v9 <- c("a","b","c")
names(v6) <- v9 #将v9中的字符串命名到v6各个元素
names(v6)
#向量的长度
length(v6)
向量索引
#根据向量元素的位置进行索引
v8 <- c(1,2,3,4)
v8[1] #提取v8第一个元素值
v8[1,2] #提取v8第一二个元素值
xy = v8[c(1,2)]
xy[-1] #显示除第一个元素外的所有元素
#根据向量元素名称进行索引
x <- c(11,22,33,44)
names(x) <- c('a','b','c','d')
x[c("c")]
矩阵
矩阵的创建：matrix(data, nrow=a, ncol = b, byrow=FALSE，dimnames)
默认byrow=F，即按列排序；
nrow为矩阵的行数目，ncol为矩阵的列数目，这两个只需要设置其中一个即可；
dimnames可以为矩阵设置行名称与列名称。
m1 <- matrix(1:6) #默认byrow=F，即按列排序
m1 <- matrix(1:6,nrow=2,byrow=F)#按列排列
m1 <- matrix(1:6,nrow=2,byrow=T)#按行排列
> m1 <- matrix(1:6,nrow=2,byrow=T,dimnames = list(c('one','two'),c('cha','math','eng')))
> m1
cha math eng
one 1 2 3
two 4 5 6查找、定义矩阵行列名称
#显示m1的行名称
colnames(m1)
#定义m1的行名称
colnames(m1) <- c('a','su','ka')
colnames(m1) <- list(c('a','su','ka'))
dim(m1) #返回m1的行列维度
ncol(m1) #返回m1的行数
nrow(m1) #返回m1的列数
矩阵索引
#利用行列数进行索引
m1[1,2] #返回向量，返回m1第一行第二列的元素
m1[1,] #返回向量，m1第一行的向量
m1[,2] #返回向量，返回第二列向量
m1[1:2,2:3] #返回矩阵，返回矩阵m1第一到二行、第二到三列
m1[c(1,2),c(2,3)] #返回矩阵，返回矩阵m1第一二行、第二三列
#利用行列名称进行索引
m1[,"su"] #返回向量，取出列名称为"su"的列
m1['one',] #返回向量
m1[c('one'),c('a','ka')] #返回矩阵
as.vector(m1) #转换成向量（按列）
列表
v1<-1:5
m1 <- matrix(1:6,nrow=2,byrow=T,dimnames = list(c('one','two'),c('cha','math','eng')))
l1 <- list(com1 = v1,com2 = m1)#生成两个成分所构成的列表（list（成分名称=成分的值，成分名称=成分的值））
> l1
> l1
$com1
[1] 1 2 3 4 5
$com2
cha math eng
one 1 2 3
two 4 5 6列表索引
> l1$com1 #返回名称为com1的向量
[1] 1 2 3 4 5
> l1[['com2']] #返回名称为com2的矩阵
cha math eng
one 1 2 3
two 4 5 6
> l1[[2]] #返回l1的第二个元素，即l1 <- list(com1 = v1,com2 = m1)中的com2
cha math eng
one 1 2 3
two 4 5 6
> l1['com1'] #返回列表
$com1
[1] 1 2 3 4 5
> l1[2] #返回列表
$com2
cha math eng
one 1 2 3
two 4 5 6新建成分与释放列表
#新建成分
l1$com3 <- 3:6 #新建成分,现在l1有com1、2、3,，3个成分了
> l1
$com1
[1] 1 2 3 4 5
$com2
cha math eng
one 1 2 3
two 4 5 6
$com3
[1] 3 4 5 6
#释放列表
unlist(l1)数据框
是特殊的列表，跟矩阵对比，矩阵只能容纳一种类型的数据，而数据框跟列表一样可以容纳多种类型的数据。
#数据框的建立
> df1 <- data.frame(c1 = 2:5,c2 = LETTERS[2:5])#构造一个第一列为c1,第二列为c2的数据框，data.frame(名称=值，)
> df1
c1 c2
1 2 B
2 3 C
3 4 D
4 5 E
#维度信息
dim(df1)#返回df1的行列维度
ncol(df1)#列数
nrow(df1)#行数
#行列名称
dimnames(df1)
rownames(df1) #返回数据框行名称
colnames(df1) #返回数据框列名称
rownames(df1) <- c('11','22','33','44') #重新定义df1的行名称
rownames(df1)
> df1
c1 c2
11 2 B
22 3 C
33 4 D
44 5 E数据框索引
#利用元素位置进行索引
> df1[1:2,2] #返回向量
[1] "B" "C"
> df1[,2] #返回向量
[1] "B" "C" "D" "E"
> df1[1,] #返回数据框
c1 c2
11 2 B
#利用行列名称进行索引
> df1[,"c2"] #返回向量
[1] "B" "C" "D" "E"
> df1['11',] #返回数据框
c1 c2
11 2 B
> df1[[2]] #返回向量
[1] "B" "C" "D" "E"
> df1$c1 #返回向量
[1] 2 3 4 5
> df1[2] #返回数据框,没有加逗号，指向的是数据框基本构成单元——列
c2
11 B
22 C
33 D
44 E
> df1['c1'] #返回数据框
c1
11 2
22 3
33 4
44 5新建列
> df1$c3 <- 1:4
> df1
c1 c2 c3
11 2 B 1
22 3 C 2
33 4 D 3
44 5 E 4
> df1$c2 <- 5:8 #对列进行修改
> df1
c1 c2 c3
11 2 5 1
22 3 6 2
33 4 7 3
44 5 8 4常用运算与函数
基本运算
> c(1:4)/c(2:5) #向量相同位置元素之间做运算
[1] 0.5000000 0.6666667 0.7500000 0.8000000
> c(1:6)/c(2:5) #循环扩展（2:5→2 3 4 5 2 3）
[1] 0.5000000 0.6666667 0.7500000 0.8000000 2.5000000 2.0000000
> exp(1) #自然常数为底的幂运算
[1] 2.718282
> log(x=25,base=5) #5为底25的对数
[1] 2
> sqrt(4) #开平方
[1] 2
> abs(-56) #绝对值
[1] 56
> sign(-5.6) #符号函数，参数为正,返回1，参数为负返回-1
[1] -1
> round(3.45679,2) #保留指定位小数,四舍五入
[1] 3.46
> signif(3.245,2) #保留指定位有效数字
[1] 3.2
> ceiling(3.2) #天花板 向上取
[1] 4
> floor(3.2) #地板 向下取
[1] 3
2 == 3 #是否等于
2 != 3 #是否不相等
2 >= 3 #大于等于
2 <= 3 #小于等于
> 2 %in% 2:5 #2是否包含于右边的向量
[1] TRUE
> (2>3) & (2 %in% 2:5) #与
[1] FALSE
> (2>3) | (2 %in% 2:5) #或
[1] TRUE
> !(2 %in% 2:5) #非
[1] FALSE向量相关函数
v2 <-c(3,2,7,4,6,8,11,21)
> max(v2) #最大值
[1] 21
> cummax(v2) #累积最大值，第n个元素代表前n个元素的最大值
[1] 3 3 7 7 7 8 11 21
> min(v2) #最小值
[1] 2
> cummin(v2) #累积最小值，第n个元素代表前n个元素的最小值
[1] 3 2 2 2 2 2 2 2
sum(v2) #求和
cumsum(v2) #累积求和
prod(v2) #乘积
cumprod(v2) #累积乘积
mean(v2) #均值
median(v2) #中位数
sd(v2) #标准差
var(v2) #方差
> rev(v2) #向量逆转
[1] 21 11 8 6 4 7 2 3
sort(v2) #向量重排，按从小到大
> v5 <- rep(v2,times=2)
> table(v5) #向量元素频数统计
v5
2 3 4 6 7 8 11 21
2 2 2 2 2 2 2 2
> unique(v5) #向量的取值水平，重复出现的元素只保留一个
[1] 3 2 7 4 6 8 11 21索引函数
> v5
[1] 3 2 7 4 6 8 11 21 3 2 7 4 6 8 11 21
> which(v5==7) #返回向量v5中等于7的元素的位置
[1] 3 11
> which.max(v5) #寻找向量最大值第一次出现的位置
[1] 8
> which.min(v5) #寻找向量最小值第一次出现的位置
[1] 2
> intersect(1:5,4:7) #交集，1:5和2:4这两个向量的交集
[1] 4 5
> setdiff(1:5,4:7) #差集
[1] 1 2 3
> union(1:5,4:7) #并集
[1] 1 2 3 4 5 6 7数据框和矩阵相关的函数
#构造数据框
> dfs <- data.frame(a=1:5,b=3:7,d=letters[1:5])
> dfs
a b d
1 1 3 a
2 2 4 b
3 3 5 c
4 4 6 d
5 5 7 e
#行列的合并
> df1 <- dfs[1:3,] #取dfs前三行作为数据框df1
> df1
a b d
1 1 3 a
2 2 4 b
3 3 5 c
> df2 <- dfs[3:5,] #取dfs第三至第五行作为数据框df2
> df2
a b d
3 3 5 c
4 4 6 d
5 5 7 e
> rbind(df1,df2) #行合并，要求列数、列名称相同
a b d
1 1 3 a
2 2 4 b
3 3 5 c
31 3 5 c
4 4 6 d
5 5 7 e
> cbind(df1,df2) #列合并，要求行数相同
a b d a b d
1 1 3 a 3 5 c
2 2 4 b 4 6 d
3 3 5 c 5 7 e
#行列运算
colMeans(dfs[,1:2]) #计算列的均值
colSums(dfs[,1:2]) #计算列的和
rowMeans(dfs[,1:2]) #计算各行的均值
rowSums(dfs[,1:2]) #计算各行的和
#apply(x,margin,function)→(作用的对象，作用的维度（1对应行，2对应列），所要使用的函数)
apply(dfs[,1:2],2,sd)#求第一二列各自的标准差
#对象结构信息
str(dfs)#告诉你对象基本信息，维度、变量、数据类型...
summary(dfs)#返回数据框一些描述性统计的指标，最大最小值、中位数...
View(dfs)#显示数据框
head(dfs,n=2)#返回数据框头两行，默认n=6
tail(dfs,n=2)#返回数据框尾两行
#矩阵的运算
m3 <- matrix(c(5,7,3,4),ncol = 2,byrow=T)
m4 <- matrix(c(5,7,3,4,8,9),ncol = 3,byrow=T)
> t(m3)#矩阵转置
[,1] [,2]
[1,] 5 3
[2,] 7 4
> m3 %*% m4 #矩阵相乘，要求左列数=右行数
[,1] [,2] [,3]
[1,] 53 91 78
[2,] 31 53 45
> solve(m3) #矩阵求逆，m3 %*% x = E,x=?
[,1] [,2]
[1,] -4 7
[2,] 3 -5
> solve(m3,m4) #m3 %*% x = m4,x=?
[,1] [,2] [,3]
[1,] 8 28 51
[2,] -5 -19 -36字符函数
#连接成字符向量
> paste(1:5,collapse = "+")#在每两个向量之间插入“+”，连接成一个字符串
[1] "1+2+3+4+5"
> paste(letters[1:5],collapse = "-")
[1] "a-b-c-d-e"
> paste(1:5,letters[1:8],sep = '~')#两个向量对应元素进行连接
[1] "1~a" "2~b" "3~c" "4~d" "5~e" "1~f" "2~g" "3~h"
> paste0(1:5,letters[1:8])#两个向量对应元素紧密连接
[1] "1a" "2b" "3c" "4d" "5e" "1f" "2g" "3h"
> month.name #包含12个月的向量
[1] "January" "February" "March" "April" "May" "June" "July" "August" "September"
[10] "October" "November" "December"
> nchar(month.name)#字符向量每个元素的字符长度
[1] 7 8 5 5 3 4 4 6 9 7 8 8
> toupper(month.name)#全部转大写
[1] "JANUARY" "FEBRUARY" "MARCH" "APRIL" "MAY" "JUNE" "JULY" "AUGUST" "SEPTEMBER"
[10] "OCTOBER" "NOVEMBER" "DECEMBER"
> tolower(month.name)#全部转小写
[1] "january" "february" "march" "april" "may" "june" "july" "august" "september"
[10] "october" "november" "december"
#字符索引
> grep("Ju",month.name)#含有某个字符的元素的索引，寻找包含字符的元素的所在位置
[1] 6 7
#字符替换
> gsub("e","000",month.name)#替换字符，在字符向量month.name中找到字符e，替换成000
[1] "January" "F000bruary" "March" "April" "May" "Jun000"
[7] "July" "August" "S000pt000mb000r" "Octob000r" "Nov000mb000r" "D000c000mb000r" 随机分布函数
随机抽样函数
> sample(1:20,12,replace = T)#随机抽样，在1:20范围内随机抽取12个，replace=T代表有放回，默认为无放回
[1] 19 9 20 18 13 10 20 11 10 1 20 13
> #由于是随机抽样，所以每次随机结果都不一样，若要保持相同结果，可以用set.seed（任意数字）来固定第一次的结果）
>
> set.seed(1)
> sample(1:20,5)#需先运行上一代码才有固定效果
[1] 4 7 1 2 13
>
> rnorm(10,mean = 1,sd = 2)#r代表生成随机数，norm代表分布，生成10个均值为1，标准差为2的随机数
[1] 4.1905616 1.6590155 -0.6409368 1.9748581 2.4766494 2.1515627 0.3892232 4.0235623 1.7796865 -0.2424812
> pnorm(1,mean = 1,sd = 2)#p代表累计概率，均值为1标准差为2的分布下，在1处的累计概率为0.5
[1] 0.5
> qnorm(0.5,mean = 1,sd = 2)#q代表分位数，
[1] 1
> dnorm(1,mean = 1,sd = 2)#d代表概率密度，x=1时的概率密度
[1] 0.1994711
> pnorm(1.96,0,1)
[1] 0.9750021
> pnorm(1.645,0,1)
[1] 0.9500151
>
> plot(x=seq(-5,7,length=1000),y=dnorm(seq(-5,7,length=1000),mean=1,sd=2),type="l",ylim=c(0,0.25))
> #seq(-5,7,length=1000)表示从-5到7之间取1000个随机数
> abline(h=0,v=1)#加入水平线，x=1的竖直线循环结构，向量化编程，泛函式编程
for循环
for(循环变量 in 循环空间(一般为向量)){语法}
{}内为每次从向量空间中取出一个值后所要进行的操作
> for (x in c(-2,3,0,4)){
+ y=abs(x)
+ z=y^3
+ print(z)
+ print("------")}
[1] 8
[1] "------"
[1] 27
[1] "------"
[1] 0
[1] "------"
[1] 64
[1] "------"while循环
while(执行循环的条件){满足条件时执行的操作}
> v1 <- 1:5
> i <- 1
> while(i <= length(v1)){
+ print(i)
+
+ print(sum(v1[1:i]))
+ i = i+1
+
+ print(i)
+ print("####")
+ }
[1] 1
[1] 1
[1] 2
[1] "####"
[1] 2
[1] 3
[1] 3
[1] "####"
[1] 3
[1] 6
[1] 4
[1] "####"
[1] 4
[1] 10
[1] 5
[1] "####"
[1] 5
[1] 15
[1] 6
[1] "####"分别用for循环和while循环求数据框df每一行的和
for循环
> df <- data.frame(c1 = 2:5,c2 = 4:7,c3 = -19:-16)
> df
c1 c2 c3
1 2 4 -19
2 3 5 -18
3 4 6 -17
4 5 7 -16
>
> for(i in 1:nrow(df)){print(sum(df[i,]))}
[1] -13
[1] -10
[1] -7
[1] -4
> rowSums(df)#同上
[1] -13 -10 -7 -4
>
while循环
> j=1
> while(j <= nrow(df)){
+ print(sum(df[j,]))
+ j=j+1
+ }
[1] -13
[1] -10
[1] -7
[1] -4跳过循环与终止循环
next:跳过这一次循环直接进入下一次循环
> for(i in 1:nrow(df)){
+ if(i==3){next}
+ print(sum(df[i,]))
+ }#跳过i=3时的循环
[1] -13
[1] -10
[1] -4
break：终止循环
> for(i in 1:nrow(df)){
+ if(i==3){break}
+ print(sum(df[i,]))
+ }#i=3时，终止循环
[1] -13
[1] -10
扫一扫
1152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
