• R语言入门


    目录

    一、标量

    检验数据类型

    强制类型转换

    二、向量

    1.生成有规律的向量

     2.使用seq(from,to,by)生成向量

     3.rep(x,...) 生成满足条件的重复向量

     4.逻辑向量的生成

    三、矩阵 

    矩阵的拉直 

     四、数组

     五、数据框

     六、因子

     七、列表


    一、标量

    在R语言中赋值采用<-或者=

    a<-4数值类型标量
    b<-"hello"

    字符串类型标量

    c<-"t"字符类型标量
    f<-TRUE布尔类型标量

    检验数据类型

    is.numeric(a)判断a是不是数值型对象
    is.character(a)判断a是不是字符型对象

    强制类型转换

    s<-as.character(a)将a转换成字符串类型赋值给s,a本身的类型不变
    a<-as.character(a)将a转换成字符串类型赋值给a,a本身类型变成字符型变量

    二、向量

    向量使用<-c来赋值,其中,向量的每一个元素的分隔符为“,”

    num<-c(9,2,-3,5,6,7,8,9)数值型向量
    ord<-c("a","wdw","23")字符型向量
    logv1<-c(T,T,T,TF,F,F)逻辑型向量
    logv2<-c(True,TRUE,FALSE)逻辑型向量

    1.生成有规律的向量

    直接使用a:b的形式,生成从a到b的数列,如果a>b就逐项+1,否则逐项-1

    从我们下面的代码中可以看出我们冒号的优先级比×和-高

     2.使用seq(from,to,by)生成向量

    第一个参数为起始值,第二个参数为终止值,第三个数为步长

    当然我们也可以直接设置整个向量的长度来生成我们的向量 

     3.rep(x,...) 生成满足条件的重复向量

    1. rep(1,times=10)
    2. x <- c(1,2,3,4)
    3. rep(x,times=3)
    4. rep(x,length.out=10)
    5. rep(x,each=2)
    6. rep(x,times=c(1,2,2,3))
    7. rep("abc",5)
    8. y <- c("a","b","c")
    9. rep(y,2)
    10. rep(y,length.out=10)
    11. rep(y,times=c(1,2,3))

     4.逻辑向量的生成

    1. z <- c(8,3,5,7,6,2,8,9)
    2. n <- z > 5
    3. #判断z中的全部元素是不是都大于5
    4. all(z>5)
    5. #判断z中是否有元素大于5
    6. any(z>5)
    7. #从下面的结果中我们可以看出,我们的R语言的数组下表是从1开始的
    8. z[2]
    9. z[1:4]
    10. z[c(2,5,7)]
    11. #-3表示不取第三个元素
    12. z[-3]
    13. #第二个元素和第四个元素不取
    14. z[c(-2,-4)]
    15. #和上一个代码效果相同,都是第二个元素和第四个元素不取
    16. z[-c(2,4)]

    三、矩阵 

    ①矩阵是二维数组

    ②矩阵中的元素必须是相同类型的

    ③生成矩阵需要由函数matrix()实现

    mymatrix <- matrix(vector,nrow = number_of_rows,
                                    ncol = number_of_columns,
                                    byrow = logical_value,

                                    dimnames = list(char_vector_rownames, char_vector_colnames))

    从下面的运行结果中,我们会发现我们的R语言中的矩阵是默认按照列的形式摆放的。

    A <- matrix(1:20,nrow=5) 

     

     当然我们的矩阵也可以试用贴下面的方法生成

    1. values <- c(1,2,3,4)
    2. #创建行索引向量
    3. rnames <- c("r1","r2")
    4. #创建列索引向量
    5. cnames <- c("c1","c2")
    6. #指定我们的矩阵,分别将我们的数值,行数传入,
    7. #byrow默认为FALSE,意思是按照列进行摆放
    8. #如果为TRUE则为按照行进行摆放
    9. #dimnames可以指定我们列和行的名字
    10. C <- matrix(values,nrow=2,byrow=T,
    11. dimnames=list(rnames,cnames))
    12. C

     

    1. #如果我们将byrow的参数调整为F就会变成如下的形式
    2. D <- matrix(values,nrow=2,byrow=F,
    3. dimnames=list(rnames,cnames))
    4. D

     第一行代码为找到第一行第二列的数据

    第二行代码为找到第一行的全部数据

    第三行代码为找到第二列的数据

    1. C[1,2]
    2. C[1,]
    3. C[,2]

    1. #查找我们A中第二行,第二列和第四列的焦点所对应的值
    2. A[2,c(2,4)]
    3. #查找我们A中第一行和第三行与第三列和第四列的焦点所对应的值
    4. A[c(1,3),c(3,4)]
    5. #查看A的维数
    6. dim(A)
    7. #查看A的行数
    8. nrow(A)
    9. #查看A的列数
    10. ncol(A)
    11. #查看C矩阵的索引,先返回行索引,再返回列索引
    12. dimnames(C)
    13. #查看A矩阵的索引,先返回行索引,再返回列索引
    14. dimnames(A)
    15. #设置A的行列索引
    16. dimnames(A) <- list(c("one","two","three","four","five"),
    17. c("I","II","III","IV"))
    18. dimnames(A)
    19. A

     

    矩阵的拉直 

    1. #将我们的c强制类型转换为向量,然后赋值给我们的horz,也就是将我们的矩阵拉直
    2. #从下面的运行结果中可以看出,我们拉直的方式是按列拉直
    3. horz <- as.vector(C)
    4. horz
    5. C

     

    1. #生成E矩阵,行数为2
    2. E <- matrix(c("a","b","c","d","e","f","g","h"),nrow=2)
    3. E
    4. #生成G矩阵,列数为2
    5. G <- matrix(c("i","j","k","l","m","n","o","p"),nrow=2)
    6. G
    7. #竖着拼接
    8. rbind(E,G)
    9. #横着拼接
    10. cbind(E,G)
    11. #生成H矩阵
    12. H <- matrix(1:6,nrow=2)
    13. H
    14. #生成J矩阵
    15. J <- matrix(5:8,ncol=2)
    16. J
    17. #这里我们可以发现,如果我们的列数不同的话,我们是不可以竖着拼接的
    18. rbind(H,J)
    19. #这里我们的行数相同,所以可以横着拼接
    20. cbind(H,J)
    21. #
    22. cbind(E,H)

     

     

     四、数组

    ①数组与矩阵相似,但是维度必须大于2

    ②数组中的元素必须是相同类型

    ③选取数组中匀速的方式与矩阵相同

    ④数组可以通过函数array创建

    一般形式

    myarray <- array(vector, dimensions, dimnames)

    1. dim1 <- c("A1","A2")
    2. dim2 <- c("B1","B2","B3")
    3. dim3 <- c("C1","C2","C3","C4")
    4. dim1
    5. dim2
    6. dim3

    1. #将我们从1-24的数据分成两行三列的四个矩阵,其索引分别为dim1,dim2,dim3
    2. exarray <- array(1:24, c(2,3,4),
    3. dimnames=list(dim1,dim2,dim3))
    4. exarray
    5. #这里我们取出的是第三个矩阵中的第一行第二列的数据
    6. exarray[1,2,3]

     五、数据框

    数据框是由不同类型的数据列组成的类矩阵,可以理解为是一个松散的数据集

    创建指令mydata<-data.frame(col1,col2,col3,……)

    1. ID <- c(1,2,3,4)
    2. age <- c(25,34,28,52)
    3. status <- c("Poor","Improved","Excellent","Poor")
    4. diabetes <- c("Type1","Type2","Type1","Type1")
    5. patientdata <- data.frame(ID,age,diabetes,status)
    6. patientdata

     

     

    1. #提取出我们patientdata中的第一列和第二列
    2. patientdata[1:2]
    3. #当然我们也可以指定查找的索引名为具体的对象
    4. patientdata[c("diabetes","status")]
    5. #直接获得patientdata中的age列的元素
    6. patientdata$age
    7. #修改某一列的数据
    8. patientdata$age[2] <- 33
    9. patientdata$diabetes[3] <- "Type2"

    现在我们的数据表就被修改成了如下的样子 

     

     六、因子

    因子:分类变量和有序变量在R中称为因子

    分类变量:也称名义变量,变量的值没有大小关系,没有序列关系,就如同上面表格中病例的一型和二型一样

    有序变量:变量的值存在一定的顺序关系,但没有数量关系,就如同上面代码中status中的评价等地(poor,Improved,excellent)

    函数:factor(),以一个整数向量的形式存储类别值,整数的取值范围为[1,k],k为水平值的个数。

    1. #diabetes在这里存储的是我们病例的类型,默认是没有顺序的
    2. diabetes <- factor(diabetes)
    3. #status在这里存储的是治疗的效果,并且是有顺序的,但是默认的排序是按照字符的顺序来排序的
    4. status <- factor(status, ordered=T)
    5. status
    6. #我们的函数的level的排序也可以由我们自行指定
    7. status <- factor(status, ordered=T,
    8. levels=c("Poor","Improved","Excellent"))
    9. diabetes
    10. status

     

     七、列表

    列表可以看做一些对象(R中的任何数据结构)的有序集合

    创建一个列表

    mylist <- list(object1, object2,......) 

    创建一个列表,并且给列表中的每个对象命名
    mylist <- list(name1=object1, name2=object2,......)

    1. g <- "my list"
    2. h <- c(25,26,18,39)
    3. j <- matrix(1:10,nrow=5)
    4. k <- c("one", "two", "three")
    5. mylist <- list(title=g, ages=h, j, k)
    6. mylist

    获取列表中的第二个元素 

    mylist[[2]]

     

    1. #在下面的代码中,我们创建了一个列表
    2. #其中第一个元素为ID
    3. #第二个元素为名字
    4. #第三个元素为一个矩阵,并且这个矩阵为两行两三,并且传入的数据是按照行排,不是先按列来
    5. #并且指定我们的维数的索引的列表名字分别为学期名和学科的名字
    6. stu <- list(ID="12345678",name="Ün",
    7. grade=matrix(c(99,96,88,92,93,87),nrow=2,byrow=T,
    8. dimnames=list(c("第一学期","第二学期"),
    9. c("数学分析","高等代数","概率论"))))
    10. stu

    ​​​​​​​

    1. #查看列表中的ID元素
    2. stu$ID
    3. #查看列表中的名字元素
    4. stu$name
    5. #查看我们列表中的第二个元素,这里列表的下标是从1开始的,不是从0开始的,也就是我们的名字
    6. stu[[2]]
    7. #查看我们的成绩元素
    8. stu$grade
    9. #同上
    10. stu[[3]]
    11. #查看我们的成绩元素中的第二行第三列的元素
    12. stu[[3]][2,3]
    13. #查看成绩元素中的第一行第一列的数据
    14. stu$grade[1,1]
    15. #将我们的名字元素更换为李四
    16. stu$name <- "李四"
    17. #将成绩元素的第一行第二列的位置的数据改成78
    18. stu$grade[1,2] <- 78
    19. stu

     

  • 相关阅读:
    java168-java连接SQL server数据库
    计算机网络自学笔记004_Real(数据链路层002)
    【kafka】消费者与分区
    Node.js-express框架-cookie设置参数详解和举例
    git push 的应用
    leetcode刷题日记:202. Happy Number( 快乐数)和203. Remove Linked List Elements(移除链表元素)
    Ruby 之 csv 文件读写
    自动驾驶仿真:Carsim基于车辆后轴中心输出参数
    【视频教程】统计方法在变量变化及变量间关系分析中的应用
    摆闸机的应用领域和性能特点
  • 原文地址:https://blog.csdn.net/weixin_62684026/article/details/125523689