R学习笔记_01_数据类型

摘要:介绍R语言中常用的数据结构,向量、矩阵、列表、数据库、因子等。主要是它们的创建、索引和简单的运算。

数据类型

  • 主要的数据类型:

    • 数值型:numeric
    • 逻辑型:logical(T/TRUE F/FALSE)
    • 字符型:character
    • 复数型:complex(a+bi)
    • 原味型:raw(二进制数据)
    • 缺省型:missing value(NA/not available)

    关于数据类型的详细介绍和操作参见另一篇课程笔记:R魔02_笔记_数据类型。

  • 查看数据:

    1. 查看当前系统里的数据对象,返回变量名:ls()

    2. 辨别和转换数据类型:

      类型            辨别                转换
      character       is.character()      as.character()
      complex         is.complex()        as.complex()
      double          is.double()         as.double()
      integer         is.integer()        as.integer()
      logical         is.logical()        as.logical()
      NA              is.na()             as.na()
      numeric         is.numeric()        as.numeric()
      

数据结构

  • 数据结构包括:
    • 向量
    • 矩阵
    • 数组
    • 数据框
    • 因子factor/名义或等级
  1. 向量:c()

    • 直接创建向量:同一向量中的数据必须是同一个类型的。
    > a <- c(1, -2, 3, -4, 5, 0)
    > b <- c("age","name" , "weight") 
    > C <- c(TRUE, TRUE, FALSE, FALSE) 
    
    > a <- c(2:6)     # 冒号"n:m"表示从n到m,包含n和m。
    # 等价于
    > a <- c(2, 3, 4, 5, 6)
    
    > r <- c(5:1)     #逆序
    > r
    5 4 3 2 1 
    
    # 冒号运算的结果其实也是个向量
    > 2*1:5             #表达式中:的级别最高
    [1] 2 4 6 8 10
    
    • 用函数生成向量:
    # 1. 生成有规律的序列 
    > seq(1,10,2)                   # seq(from, to, by),从1到10,间隔为2。
    [1] 1 3 5 7 9
    > seq(1, by=2, length=10)       #从1开始,间隔为2,总共要10个数。
    [1] 1 3 5 7 9 11 13 15 17 19
    
    > letters[1:30]             #生成字母序列,abcd,26个,第26之后的值为NA
    
    # 2. 重复
    > rep(c(1,2),4)                 # 向量整体4次
    [1] 1 2 1 2 1 2 1 2
    > rep(c(1,2),each=4)            # 按元素重复
    [1] 1 1 1 1 2 2 2 2
    > rep(c(1,2,3,4),c(5,3,4,2))    # 向量元素分别重复5432次。必须一样长。
    [1] 1 1 1 1 1 2 2 2 3 3 3 3 4 4
    
    • 选择向量中的元素
    > a <- c(1, -2, 3, -4, 5, 0)
    > a[3]
    [1] 3
    
    > a[2,3]            # 选择两个
    [1] -2 3
    
    > a[1:4]            # 选择多个连续
    1 -2 3 -4
    
    > a[-2]             # 去掉第2个元素
    1 3 -4 5 0
    
    # 用向量选择
    > a[c(1,3,4)]       # 一定要有c()函数,a[1,2,3]是错的
    
    # 布尔
    > a[a<3]            # 列出小于3的元素
    
    • 用which()函数选择
    which.max(a)        #()里是向量名。返回下标。
    which.min(a)
    a[which.max(a)]     #返回最大值
    which(a==2)         #所有等于2的元素,的位置/下标。
    which(a>3)
    

    注意:向量不能添加或删除元素。改变向量需要重新赋值。

    • 附:常用的向量计算函数

      sum()           #求和
      max()           #求最大值
      min()           #求最小值
      range()         #求极差(全矩)
      mean()          #均值
      median()        #中数
      var()           #方差
      sd()            #标准差
      sort()          #排序,从小到大
      rev()           #反向排列rev(sort())
      rank()          #给出向量的秩(每个元素的排名)
      prod()          #向量的连乘积
      append()        #添加元素
      replace()       #替换
      match()         #匹配
      pmatch()        #部分匹配
      all()           #判断所有
      any()           #判断部分
      
  2. 矩阵:matrix()默认按列生成

    • 创建矩阵
    > y <- matrix(1:20, nrow=5, ncol=4)
         [,1] [,2] [,3] [,4]
    [1,]    1    6   11   16
    [2,]    2    7   12   17
    [3,]    3    8   13   18
    [4,]    4    9   14   19
    [5,]    5   10   15   20
    
    > cells <- c(1,4,6,10)
    > rname <- c("r1","r2")
    > cname <- c("c1","c2")
    > mymatrix <- matrix(cells, nrow=2, ncol=2, byrow=TRUE, dimnames=list(rname, cname))
    mymatrix        #byrow=TRUE按行填充
        c1  c2
    r1  1   4
    r2  6   10
    
    > diag(1:4)                 #生成对角矩阵
       [,1] [,2] [,3] [,4]
    [1,] 1 0 0 0
    [2,] 0 2 0 0
    [3,] 0 0 3 0
    [4,] 0 0 0 4
    > diag(4)                   #4阶单位阵
       [,1] [,2] [,3] [,4]
    [1,] 1 0 0 0
    [2,] 0 1 0 0
    [3,] 0 0 1 0
    [4,] 0 0 0 1
    
    • 矩阵索引
    mymatrix <- matrix(1:20, nrow=5, ncol=4)
    > mymatrix[1,2]       #选择矩阵里的元素[行, 列]
    6
    > mymatrix[1:2,2:3]   #第1 2行,2 3列的元素
         [,1] [,2]
    [1,]    6   11
    [2,]    7   12
    
    • 矩阵的运算
    A+10                #所有元素加10
    A*2                 #所有元素乘2
    A*A                 #所有元素乘自己
    A%*%B               #矩阵相乘【A(m,n)的列数(column)与B(n,p)的行数(row)相同才行,得到是一个m行,p列的矩阵】
    dim()               #返回行、列数(如果是array,返回每个维度的行列数
    str(object)         #显示某个对象的结构
    class(object)       #显示某个对象的类或类型
    nrow()              #返回行数
    ncol()              #返回列数
    solve()             #返回逆矩阵【逆矩阵:两个矩阵相乘等于一个单位矩阵(见上)】
    solve(a,b)          #a*x=b,求x。得出的是x的值。
    as.matrix()         #把非矩阵的转换成矩阵
    is.matrix()         #辨别是否矩阵
    diag()              #返回对角元素或生成对角矩阵
    eigen()             #求特征值和特征向量
    chol()              #Choleski 分解  【???】
    svd()               #奇异值分解     【???】
    qr()                #QR 分解        【???】
    det()               #求行列式
    t()                 #矩阵转置
    apply(X, MARGIN, FUN, ...)      #对矩阵应用函数。x:矩阵名;MARGIN:运算范围,1/按行运算,2/按列运算;FUN:调用的函数。得到一个向量。
    rbind()             #合并两个或两个以上的矩阵,按行合并。(列数不变
    cbind()             #按列合并。(行数不变
    
  3. 数组:函数array()

    • 简单说一下。
    > dim1 <- c("A1","A2")
    > dim2 <- c("B1","B2","B3")
    > dim3 <- c("C1","C2","C3","C4")
    > z <- array(1:24, c(2, 3, 4), dimnames = list (dim1, dim2, dim3))
    > z
    , , C1
    
       B1 B2 B3
    A1  1  3  5
    A2  2  4  6
    
    , , C2
    
       B1 B2 B3
    A1  7  9 11
    A2  8 10 12
    
    , , C3
    
       B1 B2 B3
    A1 13 15 17
    A2 14 16 18
    
    , , C4
    
       B1 B2 B3
    A1 19 21 23
    A2 20 22 24
    
  4. 数据框:最常见的数据结构data.frame()

    • 矩阵形式的数据必须是同一类型的,但数据框中各列可以是不同类型的数据。
    • 每一列长度一致。可以是向量、因子、数据矩阵、列表、或其他数据框。
    • 字符向量会被强制转换成因子
    > patientID<-c(1,2,3,4)
    > age<-c(25,34,28,52)
    > diabetes<-c("Type1","Type2","Type1","Type1")
    > status<-c("Poor","Improved","Excellent","Poor")
    > patientdata<-data.frame(patientID, age, diabetes, status)
    > patientdata
      patientID age diabetes    status
    1         1  25    Type1      Poor
    2         2  34    Type2  Improved
    3         3  28    Type1 Excellent
    4         4  52    Type1      Poor    
    
    patientdata[1:2]           # 选取列
    patientdata[1:2,]          # 选取行
    patientdata[c("diabetes","status")]     # 用列名选取
    patientdata$age                         # 用列名选取的另一种方法
    table(patientdata$diabetes, patientdata$status)       # 名义变量做交叉列联表。
    
    • 使用attach()/detach()和with():可以不用写数据框的名字,直接用数据库中列名。
    attach(patientdata)
    summary(age)
    detach(patientdata)
    
    with(patientdata,{
        summary(age)
        })
    
  5. 因子factor()

    • 分类数据
    • factor(data, levels, labels,...)
    # factors把字符型的名义变量 变为 用数字代表类别。常用于离散型数据。
    patientID<-c(1,2,3,4)
    age<-c(25,34,28,52)
    diabetes<-c("Type1","Type2","Type1","Type1")
    status<-c("Poor","Improved","Excellent","Poor")
    diabetes<-factor(diabetes); diabetes
    status<-factor(status, order=T, levels = c("Poor", "Improved","Excellent"));status          
    # order = T,有序性因子,按字母排序。用levels设定顺序。
    patientdata<-data.frame(patientID, age, diabetes, status)
    str(patientdata)                  # 查看dataframe
    summary(patientdata)
    
  6. 列表list

    • list是一个对象的有序合集,包含的对象叫做components/分量。
    • 语句list(变量1=分量1, 变量2=分量2,……)
    • 函数length()、 mode()、 names()可以分别返回列表的长度(分量的数目)、数据类型、列表里成分的名字。
    • 元素可以不同类型。迭代。双层中括号[[]]选择元素,第一维是名称,第二维才是数值。
    # 创建列表
    #1. 使用list()
    > j <- list(name="Joe",salary=55000, union=T); j
    $name
    [1] "Joe"
    
    $salary
    [1] 55000
    
    $union
    [1] TRUE
    
    #2. 把向量转为列表形式
    z <- vector(mode="list")  
    z[["list"]] <- 3   
    
    # 列表索引
    > j$salary
    [1] 55000    
    
    j[["salary"]]           #注意单层中括号和双层中括号的区别
    j[[2]]
    j[1:2]
    
    # 增加列
    j$sex<-"M"              #增加一个叫做“sex”的列
    
    j[6:8]<-c(E,F,T);j      #增加三列,分别叫做E/F/T,位置在6到8.
    
    # 删除列
    j$sex<-NULL;j           #sex这列就不见了
    

你可能感兴趣的:(R学习笔记_01_数据类型)