R语言学习


阅读数: 次   
× 文章目录
  1. 1. 一、基础
    1. 1.1. 1、概述
    2. 1.2. 2、Windows上安装
    3. 1.3. 3、数据类型
      1. 1.3.1. (1) Vector向量
      2. 1.3.2. (2) List列表
      3. 1.3.3. (3) Matrix矩阵
      4. 1.3.4. (4) Array数组
      5. 1.3.5. (5) Factor因子
      6. 1.3.6. (6) Data Frame 数据帧
    4. 1.4. 4、变量
      1. 1.4.1. (1) 命名
      2. 1.4.2. (2) 赋值
      3. 1.4.3. (3) 查找变量
      4. 1.4.4. (4) 删除变量
    5. 1.5. 5、运算符
      1. 1.5.1. (1) 算数运算符
      2. 1.5.2. (2) 关系运算符
      3. 1.5.3. (3) 逻辑运算符
      4. 1.5.4. (4) 其他
    6. 1.6. 6、包
      1. 1.6.1. (1) 介绍
      2. 1.6.2. (2) 常用命令
      3. 1.6.3. (3) 手动安装包
    7. 1.7. 7、数据重塑Dataframe
      1. 1.7.1. (1) 数据帧中加入行和列
      2. 1.7.2. (2) 合并数据帧
      3. 1.7.3. (3) 拆分和重组
    8. 1.8. 8、函数
      1. 1.8.1. (1) 定义
      2. 1.8.2. (2) 自定义函数和调用
    9. 1.9. 9、字符串
      1. 1.9.1. (1) 定义
      2. 1.9.2. (2) 字符串操作
    10. 1.10. 10、向量
      1. 1.10.1. (1) 序列运算符seq
      2. 1.10.2. (2) 访问向量元素
    11. 1.11. 11、列表
    12. 1.12. 12、矩阵
    13. 1.13. 13、数组
    14. 1.14. 14、因子
    15. 1.15. 15、数据帧
  2. 2. 二、dplyr包
    1. 2.1. 1、基本操作
      1. 2.1.1. (1) 筛选
      2. 2.1.2. (2) 排序arrange()
      3. 2.1.3. (3) 变形mutate()
      4. 2.1.4. (4) 汇总
    2. 2.2. 2、分组
  3. 3. Reference
  • 基础内容来自W3C，直接查看这里即可，这里只是个人学习的记录
  • 只是最近感觉有必要学习一下R，哈哈

一、基础

1、概述

  • R语言是用于统计分析，图形表示和报告的编程语言和软件环境。
  • 解释型语言

    2、Windows上安装

  • 下载地址：R-3.4.0，直接下载安装即可
  • IDE使用RStudio: 点击下载

3、数据类型

  • 使用<-进行赋值（RStudio中的快捷键是Alt+-）
  • 变量分配有R对象，R对象的数据类型变为变量的数据类型。
  • 使用class()来查看类型

    (1) Vector向量

  • 创建使用c()函数
1
2
3
> apple = c('apple', 'banana')
> print(apple)
[1] "apple"  "banana"

(2) List列表

  • 列表是一个R对象，它可以在其中包含许多不同类型的元素
1
2
3
4
5
6
7
8
9
10
> list <- list(c('apple','banana'), 1, 2.0)
> print(list)
[[1]]
[4] "apple"  "banana"
[[2]]
[5] 1
[[3]]
[6] 2

(3) Matrix矩阵

  • 矩阵被限制为二维
    1
    2
    3
    4
    5
    > 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"

(4) Array数组

  • dim指定维度，这里穿创建3x3x2的三维矩阵，输入是向量（一致循环创建）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> 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"

(5) Factor因子

  • 因子是使用向量创建的r对象。
  • nlevels函数可以得到因子中不重复值的个数
    1
    2
    3
    4
    5
    6
    > factor_content <- factor(c('green', 'red', 'green', 'yellow', 'red', 'green'))
    > print(factor_content)
    [1] green  red    green  yellow red    green 
    Levels: green red yellow
    > print(nlevels(factor_content))
    [1] 3

(6) Data Frame 数据帧

  • 数据表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > 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

  • names(data.frame对象) 查看列名

  • row.names 查看行名

4、变量

(1) 命名

  • 有效的变量名称由字母，数字和点或下划线字符组成
  • 列如：var_name2.，.var_name var.name

    (2) 赋值

  • 可以使用=, <-, ->
    • =和<-的区别是一个是传值，一个是赋值，一般使用<-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      > var.1 = c(0,1,2,3)
      > var.2 <- c("learn","R")
      > c(TRUE,1) -> var.3  
      > print(var.1)
      [1] 0 1 2 3
      > print(var.2)
      [1] "learn" "R"    
      > print(var.3)
      [1] 1 1

(3) 查找变量

  • 使用ls()函数
1
2
3
4
5
> print(ls())
 [1] "a"              "aisles"         "apple"          "BMI"            "data"          
 [6] "departments"    "factor_content" "list"           "M"              "orderp"        
[11] "orders"         "ordert"         "path"           "products"       "s"             
[16] "var.1"          "var.2"          "var.3"
  • 通过模式匹配查找
1
2
> print(ls(pattern = "var"))
[1] "var.1" "var.2" "var.3"
  • 以点.开头的变量名字会被隐藏，可以print(ls(all.name = TRUE))列出所有的

(4) 删除变量

  • 单个变量通过rm(变量名)删除
  • 删除所有变量：rm(list = ls())

5、运算符

(1) 算数运算符

  • %% : 求余
  • %/% : 相除求商
  • ^ : 指数

    (2) 关系运算符

  • 和c等语言一样

    (3) 逻辑运算符

  • & : 与and，两个&&只比较第一个（比如向量只比较第一个元素）
  • | : 或or， 两个||一样

(4) 其他

  • : 
1
2
> 2:8
[1] 2 3 4 5 6 7 8
  • %in% : 元素是否在一个向量中

6、包

(1) 介绍

  • R语言的包是R函数，编译代码和样本数据的集合。
  • 存储在R语言环境中名为“library”的目录下
  • 可用的R语言的包：点击查看

    (2) 常用命令

  • 查看库的位置：.libPaths()
  • 查看已安装所有软件包：library()
  • 当前环境加载的所有包：search()
  • 安装包：install.packages("Package Name")
  • 加载到当前R语言环境中：library("package Name", lib.loc = "path to library")

    (3) 手动安装包

  • 将包作为.zip文件保存在本地系统中的适当位置。
  • 安装：install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

7、数据重塑Dataframe

(1) 数据帧中加入行和列

  • cbind()连接多个向量
1
2
3
4
5
6
7
8
9
10
> city <- c("Tampa","Seattle","Hartford","Denver")
> state <- c("FL","WA","CT","CO")
> zipcode <- c(33602,98104,06161,80294)
> addresses <- cbind(city,state,zipcode)
> print(addresses)
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"  "6161" 
[4,] "Denver"   "CO"  "80294"
  • rbind()按行拼接

    (2) 合并数据帧

  • 使用merge()函数合并两个数据帧。 数据帧必须具有相同的列名称，在其上进行合并。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    > library(MASS)
    > merged.Pima <- merge(x = Pima.te, y = Pima.tr,
    +                      by.x = c("bp", "bmi"),
    +                      by.y = c("bp", "bmi")
    + )
    > print(merged.Pima)
       bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y age.y type.y
    1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088    31     No
    2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368    21     No
    3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295    24     No
    4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289    21     No
    5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289    21     No
    6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439    43    Yes
    7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254    36    Yes
    8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374    40     No
    9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542    29    Yes
    10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294    28     No
    11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324    55     No
    12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162    39     No
    13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162    39     No
    14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565    49    Yes
    15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565    49    Yes
    16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236    38     No
    17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598    28     No
    > nrow(merged.Pima)
    [1] 17

(3) 拆分和重组

  • melt()拆分数据 (以船舶的数据集为例)

    • 需要安装reshape包
    • install.packages("reshape")
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      > library(MASS)
      > print(ships)
         type year period service incidents
      1     A   60     60     127         0
      2     A   60     75      63         0
      3     A   65     60    1095         3
      4     A   65     75    1095         4
      5     A   70     60    1512         6
      6     A   70     75    3353        18
      7     A   75     60       0         0
      8     A   75     75    2244        11
      9     B   60     60   44882        39
      10    B   60     75   17176        29
      11    B   65     60   28609        58
      12    B   65     75   20370        53
      13    B   70     60    7064        12
      14    B   70     75   13099        44
      15    B   75     60       0         0
      16    B   75     75    7117        18
      17    C   60     60    1179         1
      18    C   60     75     552         1
      19    C   65     60     781         0
      20    C   65     75     676         1
      21    C   70     60     783         6
      22    C   70     75    1948         2
      23    C   75     60       0         0
      24    C   75     75     274         1
      25    D   60     60     251         0
      26    D   60     75     105         0
      27    D   65     60     288         0
      28    D   65     75     192         0
      29    D   70     60     349         2
      30    D   70     75    1208        11
      31    D   75     60       0         0
      32    D   75     75    2051         4
      33    E   60     60      45         0
      34    E   60     75       0         0
      35    E   65     60     789         7
      36    E   65     75     437         7
      37    E   70     60    1157         5
      38    E   70     75    2161        12
      39    E   75     60       0         0
      40    E   75     75     542         1

  • 拆分

    • melt()将类型和年份以外的所有列转换为多行展示
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      library(reshape)
      molten.ships <- melt(ships, id = c("type","year"))
      print(molten.ships)
            type year  variable  value
      1      A   60    period      60
      2      A   60    period      75
      3      A   65    period      60
      4      A   65    period      75
      ............
      ............
      9      B   60    period      60
      10     B   60    period      75
      11     B   65    period      60
      12     B   65    period      75
      13     B   70    period      60
      ...........
      ...........
      41     A   60    service    127
      42     A   60    service     63
      43     A   65    service   1095
      ...........
      ...........
      70     D   70    service   1208
      71     D   75    service      0
      72     D   75    service   2051
      73     E   60    service     45
      74     E   60    service      0
      75     E   65    service    789
      ...........
      ...........
      101    C   70    incidents    6
      102    C   70    incidents    2
      103    C   75    incidents    0
      104    C   75    incidents    1
      105    D   60    incidents    0
      106    D   60    incidents    0
      ...........
      ...........

  • cast()重构数据

    • 每年每种类型的船的总和
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      > recasted.ship <- cast(molten.ships, type+year~variable,sum)
      > print(recasted.ship)
         type year period service incidents
      1     A   60    135     190         0
      2     A   65    135    2190         7
      3     A   70    135    4865        24
      4     A   75    135    2244        11
      5     B   60    135   62058        68
      6     B   65    135   48979       111
      7     B   70    135   20163        56
      8     B   75    135    7117        18
      9     C   60    135    1731         2
      10    C   65    135    1457         1
      11    C   70    135    2731         8
      12    C   75    135     274         1
      13    D   60    135     356         0
      14    D   65    135     480         0
      15    D   70    135    1557        13
      16    D   75    135    2051         4
      17    E   60    135      45         0
      18    E   65    135    1226        14
      19    E   70    135    3318        17
      20    E   75    135     542         1

8、函数

(1) 定义

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

(2) 自定义函数和调用

1
2
3
4
5
6
7
8
9
10
> new.function <- function(a) {
+     for(i in 1:a) {
+         b <- i^2
+         print(b)
+     }
+ }
> new.function(3)
[1] 1
[1] 4
[1] 9

9、字符串

(1) 定义

  • 可以使用单引号或双引号
1
2
3
> s <- 'hello world!'
> print(s)
[1] "hello world!"

(2) 字符串操作

  • 连接字符串：paste(..., sep = " ", collapse = NULL)
    • ...表示要组合的任意数量的自变量。
    • sep表示参数之间的任何分隔符。 它是可选的。
    • collapse用于消除两个字符串之间的空格。但不是一个字符串的两个字内的空间。
  • 格式化字符串：format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))
    • x是向量输入。
    • digits是显示的总位数。
    • nsmall是小数点右边的最小位数。
    • 科学设置为TRUE以显示科学记数法。
    • width指示通过在开始处填充空白来显示的最小宽度。
    • justify是字符串向左，右或中心的显示。
  • 字符数：nchar()
  • 大小写：toupper() 和 tolower()
  • 截取：substring(x,first,last)

10、向量

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

    (1) 序列运算符seq

1
2
> print(seq(1, 10, by=2))
[1] 1 3 5 7 9

(2) 访问向量元素

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

  • 位置索引

    • 注意位置是从1开始的
      1
      2
      3
      4
      t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
      u <- t[c(2,3,6)]
      print(u)
      [1] "Mon" "Tue" "Fri"

  • 负数索引

    • 使用负数是丢弃掉对应正数的索引
      1
      2
      3
      x <- t[c(-2,-5)]
      print(x)
      [1] "Sun" "Tue" "Wed" "Fri" "Sat"

  • 排序

1
2
3
4
> v <- c(3,8,4,5,0,11, -9, 304)
> v.result <- sort(v)
> print(v.result)
[1]  -9   0   3   4   5   8  11 304

11、列表

  • 可以通过索引和名字访问

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    > list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
    +                   list("green",12.3))
    > print(list_data)
    [[1]]
    [1] "Jan" "Feb" "Mar"
    [[2]]
         [,1] [,2] [,3]
    [1,]    3    5   -2
    [2,]    9    1    8
    [[3]]
    [[3]][[1]]
    [1] "green"
    [[3]][[2]]
    [1] 12.3
    > names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")
    > print(list_data[1])
    $`1st Quarter`
    [1] "Jan" "Feb" "Mar"
    > print(list_data$A_Matrix)
         [,1] [,2] [,3]
    [1,]    3    5   -2
    [2,]    9    1    8

  • 合并列表：merged.list <- c(list1,list2)

  • 列表转向量：v1 <- unlist(list1)

12、矩阵

  • 矩阵是其中元素以二维矩形布局布置的R对象。
  • 包含相同原子类型的元素。
  • matrix(data, nrow, ncol, byrow, dimnames)
  • data数据是成为矩阵的数据元素的输入向量。
  • nrow是要创建的行数。
  • ncol是要创建的列数。
  • byrow是一个逻辑线索。如果为TRUE，则输入向量元素按行排列。
  • dimname是分配给行和列的名称。

13、数组

14、因子

  • 因子是用于对数据进行分类并将其存储为级别的数据对象。 它们可以存储字符串和整数。
  • 它们在具有有限数量的唯一值的列中很有用。像“男性”，“女性”和True，False等。它们在统计建模的数据分析中很有用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> 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")
> 
> input_data <- data.frame(height,weight,gender)
> print(input_data)
  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
> print(input_data$height)
[1] 132 151 162 139 166 147 122

15、数据帧

  • summary()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
> 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)) 
     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  
> print(emp.data)
  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
  • 取数据前两行result <- emp.data[1:2,]
  • result <- emp.data[c(3,5),c(2,4)]
  • 扩展数据emp.data$dept <- c("IT","Operations","IT","HR","Finance")
  • 添加行：emp.finaldata <- rbind(emp.data,emp.newdata)

二、dplyr包

1、基本操作

  • 安装：install.packages("dplyr")

    (1) 筛选

  • 筛选行：filter()

    • 前面是dataframe数据，后面是筛选的条件，这里是筛选列名为eval_set的数据
    • 也可以使用管道的方式：datafame %>% filter(eval_set == “prior”)
      1
      filter(dataframe, eval_set == "prior")

  • 筛选列：select()

    • 筛选列名为user_id, product_id的列，使用负号表示去除对应的列
    • 可以使用管道的方式：ordert %>% select(user_id, product_id, reordered)
      1
      select(ordert, user_id, product_id)

(2) 排序arrange()

  • 按给定的列名依次进行排序（默认升序）

    • 管道的方式：orders_products %>% arrange(user_id, order_number, product_id)
      1
      arrange(df, user_id, order_number, product_id)

  • 降序排列

1
arrange(df, desc(ArrDelay))

(3) 变形mutate()

  • 对已有列进行数据运算并添加为新列
1
2
3
mutate(hflights_df, 
  gain = ArrDelay - DepDelay, 
  speed = Distance / AirTime * 60)

(4) 汇总

1
2
3
4
5
6
7
8
9
10
11
12
prd <- orders_products %>%
    arrange(user_id, order_number, product_id) %>%
    group_by(user_id, product_id) %>%
    mutate(product_time = row_number()) %>%
    ungroup() %>%
    group_by(product_id) %>%
    summarise(
        prod_orders = n(),
        prod_reorders = sum(reordered),
        prod_first_orders = sum(product_time == 1),
        prod_second_orders = sum(product_time == 2)
    )

2、分组

  • 当对数据集通过 group_by() 添加了分组信息后,mutate(), arrange() 和 summarise() 函数会自动对这些 tbl 类数据执行分组操作 (R语言泛型函数的优势).
1
2
3
4
5
6
7
8
9
10
11
12
prd <- orders_products %>%
    arrange(user_id, order_number, product_id) %>%
    group_by(user_id, product_id) %>%
    mutate(product_time = row_number()) %>%
    ungroup() %>%
    group_by(product_id) %>%
    summarise(
        prod_orders = n(),
        prod_reorders = sum(reordered),
        prod_first_orders = sum(product_time == 1),
        prod_second_orders = sum(product_time == 2)
    )

Reference

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次 总访客数人次

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序猿👨🏻‍💻