您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

R语言基础用法

文章目录

  • R_base
    • ref
    • base
      • 基本语法
      • 数据类型
      • 变量
      • 运算符
      • 决策 if
      • 循环
      • 数据重塑
      • 函数
      • 字符串
      • 向量
      • 列表
      • 矩阵
      • 数组
      • 因子(有点像set)
      • 数据帧

R_base

ref

w3school

base

基本语法

  • 只提供单行注释;tips:使用if(FALSE){"content"}作为多行注释的样式

  • 赋值:使用<-符号

  • 输出:print(var)

  • 运行:

    • 终端运行:终端输入R , 启动R语言解释器
    • 脚本运行:Rscript xxx.R
    if(FALSE) {
       "This is a demo for multi-line comments and it should be put inside either a single
          OR double quote"
    }
    
    myString <- "Hello, World!" # 赋值到字符串变量myString
    print ( myString)
    

数据类型

R变量是引用,存储数据地址;R变量分配有R对象;R对象包含多种数据类型。

R称为动态类型语言,类似python

变量只是保留值的存储位置。

这意味着,当你创建一个变量,你必须在内存中保留一些空间来存储它们。

变量不会声明为某种数据类型。

变量分配有 R 对象,R 对象的数据类型变为变量的数据类型。

常用R对象:

  • 矢量
  • 列表
  • 矩阵
  • 数组
  • 因子
  • 数据帧

原子向量有六种数据类型:

  • Logical(逻辑型)
    • TRUE、FALSE
  • Numeric(数字)
    • 12.3,5,999
  • Integer(整型)
    • 2L,34L,0L
  • Complex(复合型、复数)
    • 3+2i
  • Character(字符)
    • ‘a’,“good”,“True”,“23.4”
  • Raw(原型)
    • “Hello” 被存储为 48 65 6c 6c 6f

输出数据类型:print(class(var))

v <- charToRaw("Hello")
print(class(v))

# [1] "raw" 
  • Vectors 向量:使用 c() 函数

    • 可以是不同类型混合

      • 向量c(TRUE,1)具有逻辑和数值类的混合。 因此,逻辑类强制转换为数字类,使TRUE为1
    • apple <- c('red','green',"yellow")
      # Get the class of the vector.
      print(class(apple))
      
    • [1] "red"    "green"  "yellow"
      [1] "character"
      
  • Lists 列表:包含许多不同类型的元素

    • # Create a list.
      list1 <- list(c(2,5,3),21.3,sin)
      
      # Print the list.
      print(list1)
      
    • [[1]]
      [1] 2 5 3
      
      [[2]]
      [1] 21.3
      
      [[3]]
      function (x)  .Primitive("sin")
      
  • Matrices 矩阵:二维矩形数据集

    • # Create a matrix.
      M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
      print(M)
      
    •     [,1] [,2] [,3]
      [1,] "a"  "a"  "b" 
      [2,] "c"  "b"  "a"
      
  • Arrays 数组:具有任何数量的维度

    • # Create an array.
      a <- array(c('green','yellow'),dim = c(3,3,2))
      print(a)
      
    • , , 1
      
           [,1]     [,2]     [,3]    
      [1,] "green"  "yellow" "green" 
      [2,] "yellow" "green"  "yellow"
      [3,] "green"  "yellow" "green" 
      
      , , 2
      
           [,1]     [,2]     [,3]    
      [1,] "yellow" "green"  "yellow"
      [2,] "green"  "yellow" "green" 
      [3,] "yellow" "green"  "yellow"  
      
  • Factors 因子:将向量与向量中元素的不同值一起存储为标签,类似set

    • 步骤:声明一个向量,在使用factor()函数

    • # Create a vector.
      apple_colors <- c('green','green','yellow','red','red','red','green')
      
      # Create a factor object.
      factor_apple <- factor(apple_colors)
      
      # Print the factor.
      print(factor_apple)
      print(nlevels(factor_apple))
      
    • [1] green  green  yellow  red   red   red   green 
      Levels: green red yellow
      # applying the nlevels function we can know the number of distinct values
      [1] 3
      
  • Data Frames 数据帧:表格数据对象。按列声明,每列可以是不同数据类型

    • 使用 data.frame() 函数创建数据帧。

    • # Create the data frame.
      BMI <- 	data.frame(
         gender = c("Male", "Male","Female"), 
         height = c(152, 171.5, 165), 
         weight = c(81,93, 78),
         Age = c(42,38,26)
      )
      print(BMI)
      
    • gender height weight Age
      1   Male  152.0     81  42
      2   Male  171.5     93  38
      3 Female  165.0     78  26  
      

变量

  • 命名

    • 有字母,数字,点和下划线组成。
    • 允许._,只有.可以开头,.开头时不能跟数字,其他位置可以。
  • 赋值:使用 = , -> , <- 进行赋值

    • # 三者等价
      var = c(1,0,2)
      var -> c(1,0,2)
      c(1,0,2) -> var
      
  • 输出: print() , cat()

    • cat()函数将多个项目组合成连续打印输出。

      • print(var.1)
        cat ("var.1 is ", var.1 ,"
        ")
        cat ("var.2 is ", var.2 ,"
        ")
        
  • 变量操作

    • 查找变量

      • 工作空间中当前可用的所有变量,我们使用ls()函数. ls()函数也可以使用模式来匹配变量名

      • # 输出当前环境中所有变量(点(.)开头的变量被隐藏)
        print(ls())
        
      • # 模式匹配,输出所有带有var的变量
        print(ls(pattern = "var")) 
        
      • 使用ls()函数的“all.names = TRUE”参数列出

        • # 输出当前环境中所有变量(包括点(.)开头的变量)
          print(ls(all.name = TRUE))
          
    • 删除变量

      • 删除某个变量

        • rm(var.3)
          print(var.3)
          
          # result
          [1] "var.3"
          Error in print(var.3) : object 'var.3' not found
          
      • 删除所有变量

        • rm(list = ls())
          print(ls())
          
          # result
          character(0)
          

运算符

  • 算术运算符:操作符对向量的每个元素起作用

    • + , - , * 加减乘
    • / : 两向量相除,结果带小数
    • %% : 两个向量求余
    • %/% : 两个向量相除取整
    • ^ : 将第二向量作为第一向量的指数
  • 关系运算符:操作符对向量的每个元素起作用

    • > , <, = , <= , >= , !=
    • 返回TRUE或者FALSE
  • 逻辑运算符:它只适用于逻辑,数字或复杂类型的向量。所有大于1的数字被认为是逻辑值TRUE。将第一向量的每个元素与第二向量的相应元素进行比较。 比较的结果是布尔值。

    • 对向量每个元素操作
      • & : and
      • | : or
      • ! : not
    • 对向量第一个元素操作
      • && : and
      • || : ors
  • 赋值运算符

    • 左分配:赋值给左边
      • <- , <<- , =
    • 右分配:赋值给右边
      • -> , ->>
  • 其他运算符:用于特定目的,而不是一般的数学或逻辑计算。

    • : 它为向量按顺序创建一系列数字。左闭右闭

      • v <- 2:8
        print(v) 
        
        # result
        2 3 4 5 6 7 8
        
    • %in% 用于标识元素是否属于向量。

      • v1 <- 8
        v2 <- 12
        t <- 1:10
        print(v1 %in% t) 
        print(v2 %in% t) 
        
      • TRUE
        FALSE
        
    • %*% 用于将矩阵与其转置相乘。

      • M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
        t = M %*% t(M)
        print(t)
        
        # result
              [,1] [,2]
        [1,]   65   82
        [2,]   82  117
        

决策 if

  • if

    • 表达式

      if(boolean_expression) {
         // statement(s) will execute if the boolean expression is true.
      }
      
    • demo

      x <- 30L
      if(is.integer(x)) {
         print("X is an Integer")
      }
      
      # result
      [1] "X is an Integer"
      
  • if…else if… … else…

    • 表达式

      if(boolean_expression) {
         // statement(s) will execute if the boolean expression is true.
      } else if( boolean_expression 3) {
         // Executes when the boolean expression 3 is true.
      } else {
         // statement(s) will execute if the boolean expression is false.
      }
      
    • demo

      x <- c("what","is","truth")
      
      if("Truth" %in% x) {
         print("Truth is found")
      } else {
         print("Truth is not found")
      }
      
      # result
      [1] "Truth is not found"
      
  • switch

    • 表达式

      switch(expression, case1, case2, case3....)
      
    • demo

      x <- switch(
         3,
         "first",
         "second",
         "third",
         "fourth"
      )
      print(x)
      
      # result
      [1] "third"
      
    • demo-2

      # runif() 函数用于生成从 0 到 1 区间范围内的服从正态分布的随机数
      switch(1,2*3,sd(1:5),runif(3))  #返回(2*3,sd(1:5),runif(3))list中的第一个成分 
      switch(2,2*3,sd(1:5),runif(3))  #返回第二个成分
      switch(3,2*3,sd(1:5),runif(3))  #返回第三个成分
      
      # result
      [1] 6
      [1] 1.581139
      [1] 0.31508117 0.04610938 0.19489747
      

获取包含R包的库位置:.libPaths()

获取已安装的所有软件包列表:library()

获取当前在R环境中加载的所有包:search()

循环

循环语句

  • repeat

    • repeat { 
         commands 
         if(condition) {
            break
         }
      }
      
    • demo

      v <- c("Hello","loop")
      cnt <- 2
      
      repeat {
         print(v)
         cnt <- cnt+1
         
         if(cnt > 5) {
            break
         }
      }
      
      # result
      
      [1] "Hello" "loop" 
      [1] "Hello" "loop" 
      [1] "Hello" "loop" 
      [1] "Hello" "loop" 
      
  • while

    • while (test_expression) {
         statement
      }
      
    • demo

      v <- c("Hello","while loop")
      cnt <- 2
      
      while (cnt < 7) {
         print(v)
         cnt = cnt + 1
      }
      
      # result
      [1] "Hello"  "while loop"
      [1] "Hello"  "while loop"
      [1] "Hello"  "while loop"
      [1] "Hello"  "while loop"
      [1] "Hello"  "while loop"
      
  • for

    • for (变量 in 条件) {
         循环体
      }
      
    • demo

      v <- LETTERS[1:4]
      for ( i in v) {
         print(i)
      }
      
      # result
      [1] "A"
      [1] "B"
      [1] "C"
      [1] "D"
      

循环控制语句

  • break:跳出当前循环
  • next:跳过循环的当前迭代而不终止它时便可使用next,继续下一次迭代,相当于continue

数据重塑

数据重塑是关于改变数据被组织成行和列的方式

  • cbind() 函数连接多个向量来创建数据帧
  • rbind() 函数合并两个数据帧。即保持列,增加了行
  • merge() 函数合并两个数据帧。 数据帧必须具有相同的列名称,在其上进行合并。

函数

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

返回值:

  • 可以通过显示地调用return(),把一个值返回给主调函数。如果不是用这条语句,默认将会把最后执行的语句的值作为返回值。

  • 函数的返回值可以说任何对象,也就可以返回复杂对象。如果你的函数有多个返回值,可以把它们存储在一个列表或其他容器变量中。

内置函数:

seq()mean()max()sum(x)paste(…)

函数参数:像python一样用

调用: function_name(arg_1, arg_2,…)

字符串

单双引号的使用:

  • 单引号或双引号对中写入的任何值都被视为字符串

  • R语言存储的每个字符串都在双引号内,即使是使用单引号创建的依旧如此。

  • “xxxx‘xxxxxx”

  • ‘xxxxx"xxxxxx’

字符串操作:

  • 连接字符串 - paste() 函数

    • paste(..., sep = " ", collapse = NULL)
      
      • … 表示要组合的任意数量的自变量。
      • sep 表示参数之间的任何分隔符。它是可选的。
      • collapse 用于消除两个字符串之间的空格。 但不是一个字符串的两个字内的空间。
  • 格式化数字和字符串 - format() 函数

    • format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none")) 
      
      • x 是向量输入。
      • digits 是显示的总位数。
      • nsmall 是小数点右边的最小位数。
      • scientific设置为 TRUE 以显示科学记数法。
      • width 指示通过在开始处填充空白来显示的最小宽度。
      • justify 是字符串向左,右或中心的显示。如:justify = “c”。
  • 计算字符串中的字符数 - nchar() 函数

    • 此函数计算字符串中包含空格的字符数

    • nchar(x)
      
      • x 是向量输入。
  • 更改大小写 - toupper()和tolower()函数

    • toupper(x)
      tolower(x)
      
      • x是向量输入。
  • 提取字符串的一部分 - substring()函数

    • 以char为单位

    • substring(x,first,last)
      
      • x 是字符向量输入。
      • 首先是要提取的第一个字符的位置。
      • last 是要提取的最后一个字符的位置。

向量

向量是最基本的R语言数据对象,有六种类型的原子向量。 它们是逻辑,整数,双精度,复杂,字符和原始

  • 创建向量

    • 单元素向量

      • demo

        # Atomic vector of type character.
        print("abc");
        
        # Atomic vector of type double.
        print(12.5)
        
        # Atomic vector of type integer.
        print(63L)
        
        # Atomic vector of type logical.
        print(TRUE)
        
        # Atomic vector of type complex.
        print(2+3i)
        
        # Atomic vector of type raw.
        print(charToRaw('hello'))
        
    • 多元素向量

      • demo

        # If the final element specified does not belong to the sequence then it is discarded.
        v <- 3.8:11.4
        print(v)
        
        # Create vector with elements from 5 to 9 incrementing by 0.4.
        print(seq(5, 9, by = 0.4))
        
        # The logical and numeric values are converted to characters.
        s <- c('apple','red',5,TRUE)
        print(s)
        
        # result
        [1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8
        [1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0
        [1] "apple" "red"   "5"     "TRUE" 
        
  • 访问向量元素

    • 使用索引访问向量的元素。 t[]括号用于建立索引。 索引从位置1开始。

      # Accessing vector elements using position.
      t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
      u <- t[c(2,3,6)]
      print(u)
      
      # Accessing vector elements using logical indexing.
      v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
      print(v)
      
      # Accessing vector elements using negative indexing.
      x <- t[c(-2,-5)]
      print(x)
      
      # Accessing vector elements using 0/1 indexing.
      y <- t[c(0,0,0,0,0,0,1)]
      print(y)
      
      # result
      [1] "Mon" "Tue" "Fri"
      [1] "Sun" "Fri"
      [1] "Sun" "Tue" "Wed" "Fri" "Sat"
      [1] "Sun"
      
  • 向量操作

    • 向量运算

      • 见 运算符 部分
    • 向量元素回收

      • 对不等长的两个向量应用算术运算,则较短向量的元素被循环以完成操作。

        v1 <- c(3,8,4,5,0,11)
        v2 <- c(4,11)
        # 做运算时,V2 becomes c(4,11,4,11,4,11)
        
    • 向量元素排序

      • 向量中的元素可以使用sort()函数排序

        v <- c(3,8,4,5,0,11, -9, 304)
        sort.result <- sort(v)
        print(sort.result)
        revsort.result <- sort(v, decreasing = TRUE)
        print(revsort.result)
        
        # result
        # 数字型
        [1]  -9   0   3   4   5   8  11 304
        [1] 304  11   8   5   4   3   0  -9
        # 字符型
        [1] "Blue"   "Red"    "violet" "yellow"
        [1] "yellow" "violet" "Red"    "Blue" 
        

列表

列表是R语言对象,使用list()函数创建的。

它包含不同类型的元素,如数字,字符串,向量和其中的另一个列表。 列表还可以包含矩阵或函数作为其元素。

  • 创建列表

    • list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
      print(list_data)
      
  • 命名列表元素

    • 列表元素可以给出名称,并且可以使用这些名称访问它们

    • names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

      # Create a list containing a vector, a matrix and a list.
      list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
         list("green",12.3))
      
      # Give names to the elements in the list.
      names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
      
      # Show the list.
      print(list_data)
      
      # result
      $`1st_Quarter`
      [1] "Jan" "Feb" "Mar"
      
      $A_Matrix
           [,1] [,2] [,3]
      [1,]    3    5   -2
      [2,]    9    1    8
      
      $A_Inner_list
      $A_Inner_list[[1]]
      [1] "green"
      
      $A_Inner_list[[2]]
      [1] 12.3
      
  • 访问列表元素

    • 列表的元素可以通过列表中元素的索引访问。
    • 在命名列表的情况下,它也可以使用名称来访问。
  • 操控列表元素

    • 添加,删除和更新列表元素

    • 只能在列表的末尾添加和删除元素

    • 但我们可以更新任何元素

    # Create a list containing a vector, a matrix and a list.
    list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
       list("green",12.3))
    
    # Give names to the elements in the list.
    names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
    
    # Add element at the end of the list.
    list_data[4] <- "New element"
    print(list_data[4])
    
    # Remove the last element.
    list_data[4] <- NULL
    
    # Print the 4th Element.
    print(list_data[4])
    
    # Update the 3rd Element.
    list_data[3] <- "updated element"
    print(list_data[3])
    
    # result
    
    [[1]]
    [1] "New element"
    
    $
    NULL
    
    $`A Inner list`
    [1] "updated element"
    
  • 合并列表

    • 将所有元素放在list()函数中,使用c()函数合并多个list为一个list

      # Create two lists.
      list1 <- list(1,2,3)
      list2 <- list("Sun","Mon","Tue")
      
      # Merge the two lists.
      merged.list <- c(list1,list2)
      
      # Print the merged list.
      print(merged.list)
      
  • 列表转向量

    • 列表可以转换为向量,可以在将列表转换为向量之后应用对向量的所有算术运算

    • 使用**unlist()**函数,将列表作为输入并生成向量。

    • # Create lists.
      list1 <- list(1:5)
      print(list1)
      
      list2 <-list(10:14)
      print(list2)
      
      # Convert the lists to vectors.
      v1 <- unlist(list1)
      v2 <- unlist(list2)
      
      print(v1)
      print(v2)
      
      # Now add the vectors
      result <- v1+v2
      print(result)
      
      # result
      [[1]]
      [1] 1 2 3 4 5
      
      [[1]]
      [1] 10 11 12 13 14
      
      [1] 1 2 3 4 5
      [1] 10 11 12 13 14
      [1] 11 13 15 17 19
      

矩阵

矩阵是其中元素以二维矩形布局布置的R对象

  • 语法

    • matrix(data, nrow, ncol, byrow, dimnames)
      
      • data是成为矩阵的数据元素的输入向量。
      • nrow是要创建的行数。
      • ncol是要创建的列数。
      • byrow是一个逻辑线索。 如果为TRUE,则输入向量元素按行排列。
      • dimname是分配给行和列的名称。
  • demo

    • # Define the column and row names.
      rownames = c("row1", "row2", "row3", "row4")
      colnames = c("col1", "col2", "col3")
      
      P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
      print(P)
      
      # result
           col1 col2 col3
      row1    3    4    5
      row2    6    7    8
      row3    9   10   11
      row4   12   13   14
      
  • 访问矩阵元素

    • 使用元素的列和行索引来访问矩阵的元素

    • # Define the column and row names.
      rownames = c("row1", "row2", "row3", "row4")
      colnames = c("col1", "col2", "col3")
      
      # Create the matrix.
      P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
      
      # Access the element at 3rd column and 1st row.
      print(P[1,3])
      
      # Access the element at 2nd column and 4th row.
      print(P[4,2])
      
      # Access only the  2nd row.
      print(P[2,])
      
      # Access only the 3rd column.
      print(P[,3])
      
      # result
      [1] 5
      [1] 13
      col1 col2 col3 
         6    7    8 
      row1 row2 row3 row4 
         5    8   11   14 
      
  • 矩阵计算

    • 对于操作中涉及的矩阵,维度(行数和列数)应该相同。
    • 加减乘除,都是对应元素位置做运算
    • 乘除法的运算都是对应元素的乘除

数组

可以在两个以上维度中存储数据的R数据对象。

使用array()函数创建数组。 它使用向量作为输入,并使用dim参数中的值创建数组。

如果我们创建一个维度(2,3,4)的数组,则它创建4个矩形矩阵,每个矩阵具有2行和3列。 数组只能存储数据类型。

  • demo

    • # Create two vectors of different lengths.
      vector1 <- c(5,9,3)
      vector2 <- c(10,11,12,13,14,15)
      
      # Take these vectors as input to the array.
      result <- array(c(vector1,vector2),dim = c(3,3,2))
      print(result)
      
      # result
      , , 1
      
           [,1] [,2] [,3]
      [1,]    5   10   13
      [2,]    9   11   14
      [3,]    3   12   15
      
      , , 2
      
           [,1] [,2] [,3]
      [1,]    5   10   13
      [2,]    9   11   14
      [3,]    3   12   15
      
    • 注意:这里是按列填充

  • 命名行列

    • 使用dimnames参数给数组中的行,列和矩阵命名

      # Create two vectors of different lengths.
      vector1 <- c(5,9,3)
      vector2 <- c(10,11,12,13,14,15)
      column.names <- c("COL1","COL2","COL3")
      row.names <- c("ROW1","ROW2","ROW3")
      matrix.names <- c("Matrix1","Matrix2")
      
      # Take these vectors as input to the array.
      result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
         matrix.names))
      print(result)
      
      # result
      , , Matrix1
      
           COL1 COL2 COL3
      ROW1    5   10   13
      ROW2    9   11   14
      ROW3    3   12   15
      
      , , Matrix2
      
           COL1 COL2 COL3
      ROW1    5   10   13
      ROW2    9   11   14
      ROW3    3   12   1
      
  • 访问数组元素:类似python的切片

    • # Print the third row of the second matrix of the array.
      print(result[3,,2])
      
      # Print the element in the 1st row and 3rd column of the 1st matrix.
      print(result[1,3,1])
      
      # Print the 2nd Matrix.
      print(result[,,2])
      
  • 操作数组元素

    • 对数组元素的操作通过访问矩阵的元素来执行
  • 跨数组元素的计算

    • 使用**apply()**函数在数组中的元素上进行计算

    • 语法

      apply(x, margin, fun)
      
      • x是一个数组。
      • margin是所使用的数据集的名称。
      • fun是要应用于数组元素的函数。
    • # Create two vectors of different lengths.
      vector1 <- c(5,9,3)
      vector2 <- c(10,11,12,13,14,15)
      
      # Take these vectors as input to the array.
      new.array <- array(c(vector1,vector2),dim = c(3,3,2))
      print(new.array)
      
      # Use apply to calculate the sum of the rows across all the matrices.
      result <- apply(new.array, c(1), sum)
      print(result)
      
      # result
      , , 1
      
           [,1] [,2] [,3]
      [1,]    5   10   13
      [2,]    9   11   14
      [3,]    3   12   15
      
      , , 2
      
           [,1] [,2] [,3]
      [1,]    5   10   13
      [2,]    9   11   14
      [3,]    3   12   15
      
      [1] 56 68 60
      # 解释:
      参数c(1)不清楚
      56 = (5   10   13)*2
      

因子(有点像set)

使用**factor()**函数通过将向量作为输入创建因子。

因子是用于对数据进行分类并将其存储为Levels的数据对象。

它们可以存储字符串和整数。

它们在具有有限数量的唯一值的列中很有用。

它们在统计建模的数据分析中很有用。

  • demo

    • 基本用法(它的Level类似集合set的概念)

      # Create a vector as input.
      data <- c("East","West","East","North","North","East","West","West","West","East","North")
      
      print(data)
      print(is.factor(data))
      
      # Apply the factor function.
      factor_data <- factor(data)
      
      print(factor_data)
      print(is.factor(factor_data))
      
      # result
      [1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
      [1] FALSE
      [1] East  West  East  North North East  West  West  West  	  East  North
      	Levels: East North West
      [1] TRUE
      
    • 数据帧(就是表格数据)的因子

      • 对数据帧的文本数据列,R语言默认视为分类数据并在其上创建因子

      • # Create the vectors for data frame.
        height <- c(132,151,162,139,166,147,122)
        weight <- c(48,49,66,53,67,52,40)
        gender <- c("male","male","female","female","male","female","male")
        
        # Create the data frame.
        input_data <- data.frame(height,weight,gender)
        print(input_data)
        
        # Test if the gender column is a factor.
        print(is.factor(input_data$gender))
        
        # Print the gender column so see the levels.
        print(input_data$gender)
        
        # result
          height weight gender
        1    132     48   male
        2    151     49   male
        3    162     66 female
        4    139     53 female
        5    166     67   male
        6    147     52 female
        7    122     40   male
        [1] TRUE
        [1] male   male   female female male   female male  
        Levels: female male
        
        # result
          height weight gender
        1    132     48   male
        2    151     49   male
        3    162     66 female
        4    139     53 female
        5    166     67   male
        6    147     52 female
        7    122     40   male
        [1] TRUE
        [1] male   male   female female male   female male  
        Levels: female male
        
    • 更改级别顺序

      • 在factor()函数中,使用levels = c( )参数规定

        data <- c("East","West","East","North","North","East","West","West","West","East","North")
        # Create the factors
        factor_data <- factor(data)
        print(factor_data)
        
        # Apply the factor function with required order of the level.
        new_order_data <- factor(factor_data,levels = c("East","West","North"))
        print(new_order_data)
        
        # result
         [1] East  West  East  North North East  West  West  West  East  North
        Levels: East North West
         [1] East  West  East  North North East  West  West  West  East  North
        Levels: East West North
        
    • 生成因子级别

      • 使用**gl()**函数生成因子级别。它需要两个整数作为输入,指示每个级别有多少级别和多少次。

      • 语法

        gl(n, k, labels)
        
        • n是给出级数的整数。
        • k是给出复制数目的整数。
        • labels是所得因子水平的标签向量。
      • demo

        # 3级,每级复制4个,具体的元素见labels
        v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
        print(v)
        
        # result
        Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston Boston  Boston  Boston 
        Levels: Tampa Seattle Boston
        

数据帧

数据帧是表或二维阵列状结构,理解成表格就好了

  • 特性

    • 列名称应为非空。
    • 行名称应该是唯一的。
    • 存储在数据帧中的数据可以是数字,因子或字符类型。
    • 每个列应包含相同数量的数据项。
  • 创建数据帧

    • # Create the data frame.
      emp.data <- data.frame(
         emp_id = c (1:5), 
         emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
         salary = c(623.3,515.2,611.0,729.0,843.25), 
         
         start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
            "2015-03-27")),
         stringsAsFactors = FALSE
      )
      # Print the data frame.			
      print(emp.data) 
      
      # result
       emp_id    emp_name     salary     start_date
      1     1     Rick        623.30     2012-01-01
      2     2     Dan         515.20     2013-09-23
      3     3     Michelle    611.00     2014-11-15
      4     4     Ryan        729.00     2014-05-11
      5     5     Gary        843.25     2015-03-27
      
  • 获取数据帧结构

    • 使用str()函数可以看到数据帧的结构。

      # Create the data frame.
      emp.data <- data.frame(
         emp_id = c (1:5), 
         emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
         salary = c(623.3,515.2,611.0,729.0,843.25), 
         
         start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
            "2015-03-27")),
         stringsAsFactors = FALSE
      )
      # Get the structure of the data frame.
      str(emp.data)
      
      # result
      'data.frame':   5 obs. of  4 variables:
       $ emp_id    : int  1 2 3 4 5
       $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
       $ salary    : num  623 515 611 729 843
       $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...
      
  • 数据帧的数据摘要

    • 应用**summary()**函数获取数据的统计摘要和性质

      # Create the data frame.
      emp.data <- data.frame(
         emp_id = c (1:5), 
         emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
         salary = c(623.3,515.2,611.0,729.0,843.25), 
         
         start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
            "2015-03-27")),
         stringsAsFactors = FALSE
      )
      # Print the summary.
      print(summary(emp.data)) 
      
      # result
          emp_id    emp_name             salary        start_date        
       Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01  
       1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23  
       Median :3   Mode  :character   Median :623.3   Median :2014-05-11  
       Mean   :3                      Mean   :664.4   Mean   :2014-01-14  
       3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15  
       Max.   :5                      Max.   :843.2   Max.   :2015-03-27 
      
  • 从数据帧提取数据

    • # 提取1,2行
      result <- emp.data[1:2,]
      # 用第2和第4列提取第3和第5行
      result <- emp.data[c(3,5),c(2,4)]
      
  • 扩展数据帧

    • 通过添加列和行来扩展数据帧。

    • 使用新的列名称添加列

      # Add the "dept" coulmn.
      emp.data$dept <- c("IT","Operations","IT","HR","Finance")
      v <- emp.data
      print(v)
      
    • 将更多行永久添加到现有数据帧,结构要一致,使用**rbind()**函数。

      等同于添加多个结构一样的数据帧

      # Create the first data frame.
      emp.data <- data.frame(
         emp_id = c (1:5), 
         emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
         salary = c(623.3,515.2,611.0,729.0,843.25), 
         
         start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
            "2015-03-27")),
         dept = c("IT","Operations","IT","HR","Finance"),
         stringsAsFactors = FALSE
      )
      
      # Create the second data frame
      emp.newdata <- 	data.frame(
         emp_id = c (6:8), 
         emp_name = c("Rasmi","Pranab","Tusar"),
         salary = c(578.0,722.5,632.8), 
         start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
         dept = c("IT","Operations","Fianance"),
         stringsAsFactors = FALSE
      )
      
      # Bind the two data frames.
      emp.finaldata <- rbind(emp.data,emp.newdata)
      print(emp.finaldata)
      
      # result
        emp_id     emp_name    salary     start_date       dept
      1      1     Rick        623.30     2012-01-01       IT
      2      2     Dan         515.20     2013-09-23       Operations
      3      3     Michelle    611.00     2014-11-15       IT
      4      4     Ryan        729.00     2014-05-11       HR
      5      5     Gary        843.25     2015-03-27       Finance
      6      6     Rasmi       578.00     2013-05-21       IT
      7      7     Pranab      722.50     2013-07-30       Operations
      8      8     Tusar       632.80     2014-06-17       Fianance
      

分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进