零基础学 R语言

R语言

1.什么R？

• R是用于统计分析、绘图的语言和操作环境（AT&T贝尔实验室开发的一种用来进行数据探索、统计分析和作图的解释型语言）
• R是基于S语言的一个GNU项目
• 功能:数据存储和处理系统;数组运算工具(其向量、矩阵运算方面功能尤其强大);完整连贯的统计分析工具;优秀的统计制图功能;简便而强大的编程语言:可操纵数据的输入和输出，可实现分支、循环，用户可自定义功能贝尔实验室。

2.怎么使用？

环境安装

https://cloud.r-project.org/bin/windows/base/ 或者百度

界面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bXIuj4cc-1617272465327)(C:\Users\white\AppData\Roaming\Typora\typora-user-images\image-20210401103458427.png)]

3.怎么玩？

一.基础 R 语言的变量

1. R 语言有效变量名称由字母，数字以及点号.或下划线_组成。变量名称以 字母或点开头。
2. 变量赋值 最新版本的 R 语言的赋值可以使用左箭头 <-、等号 = 、右箭 头 -> 赋值:

> var.1 = c(1,2,3)
> print(var.1)
[1] 1 2 3
> var.2 <- c(1,2,3)
> print(var.2)
[1] 1 2 3 
> print(ls())  //查看已定义的变量可以使用 ls()函数：
[1] "var.1" "var.2"
> rm(var.2)   //删除变量可以使用 rm()函数
> print(ls())
[1] "var.1"
>cat(1,"+",1,"=",2)   //cat()函数拼接
1 + 1 = 2 

sink("r_test.txt", split=TRUE) # 控制台同样输出   //sink()函数可以把控制台输出的文字直接输出到文件中去：
for (i in 1:5)
print(i)
sink() #取消输出到文件
sink("r_test.txt", append=TRUE) # 控制台不输出，追加写入文件
print("RUNOOB")	

//从文件读入文字  但是如果纯粹的想将某个文件中的内容 读取为字符串，可以使用 readLines 函数

• 数学运算符

• 关系运算符 （向量之间的比较）

  v<-c(2,3,4,5)
  t<-c(1,2,6,7)
  print(v>t)
  [1] TRUE TRUE FALSE FALSE
  print(v [1] FALSE FALSE TRUE TRUE
  print(v==t)
  [1] FALSE FALSE FALSE FALSE
  print(v!=t)
  [1] TRUE TRUE TRUE TRUE
  print(v>=t)
  [1] TRUE TRUE FALSE FALSE
  print(v<=t)
  [1] FALSE FALSE TRUE TRUE

• 逻辑运算符 : 注意：# &&、||只对第一个元素进行比较

  • > v <- c(3,0,TRUE,2+2i)
    > t <- c(1,3,TRUE,2+3i)
    > print(v&&t)
    [1] TRUE
    > print(v||t)
    [1] TRUE
    > print(v|t)
    [1] TRUE TRUE TRUE TRUE
    

• 赋值运算符

  • R 语言变量可以使用向左，向右或等于操作符来赋值
  • 向左赋值: <− = <<−
  • 向右赋值： −> = −>>

• R 语言还包含了一些特别的运算符

  • : 冒号运算符，用于创建一系列数字的向量。

  • %in% 用于判断元素是否在向量里，返回布尔值，有的话返 回 TRUE，没有返回 FALSE。

  • %*% 用于矩阵与它转置的矩阵相乘。

  eg:

  > v <- 1:10
  > print(v)
   [1]  1  2  3  4  5  6  7  8  9 10
  > v1 <- 3
  > print(v1 %in% v)
  [1] TRUE
  
  //建立矩阵时注意nrow 与 矩阵是否时对应的关系，true必须大写
  
  > M = matrix(c(2,3,45,6,7),nrow  = 2,ncol = 3,byrow = true)
  Error in matrix(c(2, 3, 45, 6, 7), nrow = 2, ncol = 3, byrow = true) : 
    找不到对象'true'
  > M = matrix(c(2,3,45,6,7),nrow  = 2,ncol = 3,byrow = TRUE)
  Warning message:
  In matrix(c(2, 3, 45, 6, 7), nrow = 2, ncol = 3, byrow = TRUE) :
    数据长度[5]不是矩阵行数[2]的整倍
  > M = matrix(c(2,3,45,6,7,9),nrow  = 2,ncol = 3,byrow = TRUE)
  > t = M %*% t(M)
  > print(t)
       [,1] [,2]
  [1,] 2038  438
  [2,]  438  166
  

• 数学函数

  • sqrt(n) n 的平方根10 exp(n) 自然常数 e 的 n 次方， log(m,n) m 的对数函数，返回 n 的几次方等于 m log10(m) 相当于 log(m,10)
  • round (n) 对 n 四舍五入取整 (n, m) 对 n 保留 m 位小数四舍五入 ceiling (n) 对 n 向上取整 floor (n) 对 n 向下取整
  • R 中的 round 函数有些情况下可能会"舍掉五

• 概率分布函数：

  • dnorm(x, mean = 0, sd = 1, log = FALSE) 
    #的返回值是正态分布概 率密度函数值，比如 dnorm（z）则表示：标准正态分布密度函数 f（x）在 x=z 处的函数值。
    > dnorm(0)
    [1] 0.3989423
    
    pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) 
    #返回值是正态分布的分布函数值，比如 pnorm（z）等价于 P[X ≤ z] 
    > pnorm(0)
    [1] 0.5
    
    qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
    #返回值是给定概率 p 后的下分位点。 (4)rnorm(n, mean = 0, sd = 1) 的返回值是 n 个正态分布随机数构成的 向量。
    > qnorm(0)
    [1] -Inf
    
    > rnorm(3,5,2)
    [1] 3.738724 3.633434 3.107824
    # 产生 3 个平均值为 5，标准差为 2 的正态随机数
    #这四个都是用来计算正态分布的函数。它们的名字都以 norm 结尾，
    #代表"正态分布"。分布函数名字的前缀有四种：
    #d - 概率密度函数
    #p - 概率密度积分函数（从无限小到 x 的积分）
    #q - 分位数函数
    #r - 随机数函数（常用于概率仿真
    

二.R 语言之数据类型

R 语言中的最基本数据类型主要有三种：

• 数字：科学 ，一般
• 逻辑：逻辑类型常量值只有 TRUE 和 FALSE。注意：R 语言区分大小写，true 或 True 不能代表 TRUE。
• 文本：中常出现的字符串（String），常量用双引号包含。在 R 语言中，文本常量既可以用单引号包含，也可以用双引号包含

对象类型来分是以下 6 种（后面会详细介绍这几种类型）：

向量 （vector），列表（list），矩阵（matrix），数组（array），因子（factor)， 数据框（data.frame)。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gojJs4Nv-1617272465328)(D:\typora\working\R语言.assets\image-20210401113636905.png)]

1. c()是一个创造向量的函数 :如果将一个二维向量和三维向量做运算，将失去数学意 义

   1. R 语言中的"下标"不代表偏移量，而代表第几个，之前讲述的常用的数学运算函数，如 sqrt 、exp 等，同样可以用 于对向量作标量运算。"向量"作为线性表结构，应该具备一些常用的线性 表处理函数

      > a = c(1,2,3)
      > a[2]  # 其他基本控制长度请查阅相关资料
      [1] 2
      #sort() rev() order()  
      

   2. 向量排序：order() 函数返回的是一个向量排序之后的下标向量

      sum	求和
      mean	平均值
      var	方差
      sd	标准差
      min/max	最大最小
      range	取值范围

   3. 向量生成 :

      1. 有间隙的等差数列，可以用 seq()

         seq(1, 9, 2)
         

      2. seq 还可以生成从 m 到 n 的等差数列，只需要指定 m, n 以及数列的 长度： > seq(0, 1, length.out=3) [1] 0.0 0.5 1.0

         seq(0, 1, length.out=3)
         

      3. rep 是 repeat（重复）的意思，可以用于产生重复出现的数字序列

         > rep(0, 5)
         

      4. NA 代表的是"缺失"，NULL 代表的是"不存在"。NA 缺失就想占位符，代 表这里没有一个值，但位置存在。NULL 代表的就是数据不存在。

   4. 逻辑型向量

      > c(1, 2, 3) > 2
      [1] FALSE FALSE  TRUE
      
      > vector = c(10, 40, 78, 64, 53, 62, 69, 70)
      > print(vector[which(vector >= 50 & vector <70)])
      [1] 64 53 62 69
      #all() 用于检查逻辑向量是否全部为 TRUE，any() 用于检查逻辑向量是
      #否含有 TRUE。
      
   • 字符串：字符串数据类型本身并不复杂，注重介绍字符串的操作函数：

   toupper/tolower	转换为大/小写
   nchar	统计字节长度 nchar(“中文”, type=“bytes”) type=“char” 总计字符数量
   substr/substring	截取字符串 从 1 到 5 // 从 5 到结束
   as.numeric as.character	字符串转换为数字/字符串
   strsplit (“2019;10;1”, “;”)	分隔符拆分字符串
   gsub ("/", “-”, “2019/10/1”)	gsub

   • 矩阵

     • 矩阵的生成：

       > v = c(1,2,3,4,5,6)
       > matrix(v,2,3)
            [,1] [,2] [,3]
       [1,]    1    3    5
       [2,]    2    4    6
       #如果想按行填充，需要指定 byrow 属性
       #矩阵中的每一个值都可以被直接访问
       > m1 = matrix(v,2,3,byrow=TRUE)
       > m1[2,3]
       [1] 6
       #矩阵通过字符串向量 每一个列和每一行都可以设定名称
       > colnames(m1) = c("x","y","z")
       > rownames(m1) = c("a","b")
       > m1
         x y z
       a 1 2 3
       b 4 5 6
       > m1[,"y"]    #y列
       a b 
       2 5 
       > m1["a",]    #a列
       x y z 
       1 2 3 
       

     • 矩阵的四则运算

       > m1 = matrix(c(2,4),1,2) (c(...),对应的行数,列数)
       > m2 = matrix(c(3,4),2,1)
       > m1 %*% m2
            [,1]
       [1,]   22
       #逆矩阵
       sovle(正常矩阵)
       > A = matrix(c(1, 3, 2, 4), 2, 2)
       > solve(A)
            [,1] [,2]
       [1,] -2.0  1.0
       [2,]  1.5 -0.5
       #apply() 函数可以将矩阵的每一行或每一列当作向量来进行操作
       > A = matrix(c(1, 3, 2, 4), 2, 2)
       > apply(A, 1, sum) # 第二个参数为 1 按行操作，第二个参数为 2 按列操作       用 sum() 函数
       [1] 3 7		  #1+2 3+4
       

三.R 语言之控制结构

• if -else if --else语句

• if (boolean_expression) {
   // 布尔表达式为真将执行的语句  由一个布尔表达式后跟一个或多个语句组成
  }
  x <- c("google","runoob","taobao")
  if("runoob" %in% x) {
  	print("包含 runoob")
  } else if{
  	print("不包含 runoob")
  }else{
      print("Error")
  }
  

• switch 语句

  • you.like<-"runoob"
    switch(you.like, google="www.google.com", 
    runoob = "www.runoob.com", 
    taobao = "www.taobao.com")
    

• 循环

  **R 语言提供的循环类型有: **

  ​ repeat 循环：repeat 循环会一直执行代码，直到条件语句为 false 时才退出循 环，退出要使用到 break 语句。

  v <- c("Google","Runoob")
  cnt <- 2
  repeat {
      print(v)
      cnt <- cnt+1
  if(cnt > 5) {
  	break
  	}
  }
  

  ​ while 循环

  v <- c("Google","Runoob")
  cnt <- 2
  while (cnt < 7) {
      print(v)
      cnt = cnt + 1
  }
  

  ​ for 循环

  v <- LETTERS[1:4]
  for ( i in v) {
      print(i)
  }
  

  **R 语言提供的循环控制语句有： **

  ​ **break 语句 **:

  ​ Next 语句:

  #26 个字母的前面 6 个字母，在字母为 D 的时候跳过
  当前的循环，进行下一次循环
  v <- LETTERS[1:6]
  for ( i in v) {
      if (i == "D") { # D 不会输出，跳过这次循环，进入下一次
          next
       }
       print(i)
  }
  

四. 函数

• R 语言中的函数定义使用 function 关键字

  • #函数名                       形式参数列表
    function_name <- function(arg_1, arg_2, ...) {
     // 函数体            
    }
    

  • 内置函数 ：。。。

  • 自定义函数

    # 定义一个函数，用于计数一个系列到平方值
    new.function <- function(a) {  #a 去掉为无参函数
        for(i in 1:a) {
            b <- i^2
            print(b)
        }
    }
    
    # 调用函数，并传递参数
    new.function(6)
    # 函数参数，可以按函数创建时的顺序来传递，也可以不按顺序，但需要指定参数名：
    
    # 创建函数
    new.function <- function(a,b,c) {
    result <- a * b + c
    print(result)
    }
    # 不带参数名
    new.function(5,3,11)
    # 带参数名
    new.function(a = 11, b = 5, c = 3)
    

  • 懒惰计算的函数：懒惰计算将推迟计算工作直到系统需要这些计算的结果。如果不需要结果，将不用进 行计算。默认情况下，R 函数对参数计算是懒惰，就是只有我们在计算它的时候才会调用

    new.function <- function(a, b) {
        print(a^2)
        print(a)
        print(b) # 使用到 b，但未传入，所以会报错
    }
    # 传入一个参数
    new.function(6)
    

五.字符串

(1)单引号字符串中可以包含双引号。

(2)单引号字符串中不可以包含单引号。

(3)双引号字符串中可以包含单引号。

(4)双引号字符串中不可以包含双引号。

    a <- '使用单引号'
    print(a)
    b <- "使用双引号"
    print(b)
    c <- "双引号字符串中可以包含单引号（'） "
    print(c)
    d <- '单引号字符串中可以包含双引号（"） '
    print(d)

• paste() 函数: 用于使用指定对分隔符来对字符串进行连接，默认对分隔符为空格

paste(..., sep = " ", collapse = NULL)
#... ： 字符串列表； sep ： 分隔符，默认为空格；collapse ： 两个或者更多字
#符串对象根据元素对应关系拼接到一起，在字符串进行连接后，再使用 collapse 指定对连接符进行连接。
a <- "Google"
b <- 'Runoob'
c <- "Taobao"
print(paste(letters[1:6],1:6, sep = "", collapse = "="))

• format() 函数 ： 用于格式化字符串，format() 可作用于字符串或数字。

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre",
"none"))
#	x ： 输入对向量
#	digits ： 显示的位数
#	nsmall ： 小数点右边显示的最少位数
#	scientific ： 设置科学计数法
#	width ： 通过开头填充空白来显示最小的宽度
#	justify：设置位置，显示可以是左边、右边、中间等。
result <- format(c(6, 13.14521), scientific = TRUE)
result <- format("Runoob", width = 10, justify = "c")

• nchar() 函数：用于计数字符串或数字列表的长度。

• toupper() & tolower() 函数：用于将字符串的字母转化为大写或者小写。

• substring() 函数：用于截取字符串。

substring(x,first,last)
	x ： 向量或字符串
    first ： 开始截取的位置
    last： 结束截取的位置

六.列表

列表是 R 语言的对象集合，可以用来保存不同类型的数据，可以是数字、字符串、向 量、另一个列表等，当然还可以包含矩阵和函数。

list_data <- list("runoob", "google", c(11,22,33), 123, 51.23, 119.1)

• names() 函数给列表的元素命名：

# 列表包含向量、矩阵、列表
list_data <- list(c("Google","Runoob","Taobao"), matrix(c(1,2,3,4,5,6), nr
ow = 2),list("runoob",12.3))
# 给列表元素设置名字
names(list_data) <- c("Sites", "Numbers", "Lists")

• 访问列表 : 列表中的元素可以使用索引来访问，如果使用来 names() 函数命名后，我们还可以 使用对应名字来访问

  # 访问列表的第三个元素
  print(list_data[3])
  # 访问第一个向量元素
  print(list_data$Numbers)
  # 添加元素
  list_data[4] <- "新元素"
  print(list_data[4])
  # 删除元素
  list_data[4] <- NULL
  # 删除后输出为 NULL
  print(list_data[4])
  # 更新元素
  list_data[3] <- "我替换来第三个元素"
  

• 合并列表 : 可以使用 c() 函数将多个列表合并为一个列表：

list1 <- list(1,2,3)
list2 <- list("you","live","here")
# 合并列表
merged.list <- c(list1,list2)

• 列表转换为向量 : unlist() 函数，将列表转换为向量

# 创建列表
list1 <- list(1:5)
# 转换为向量
v1 <- unlist(list1)

七.矩阵

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8UA7lfJB-1617272465330)(D:\typora\working\R语言.assets\image-20210401131032549.png)]

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,dimnames = NULL)

#  data 向量，矩阵的数据
#  nrow 行数
#  ncol 列数
#  byrow 逻辑值，为 FALSE 按列排列，为 TRUE 按行排列
#  dimname 设置行和列的名称

• 转置矩阵 : t() 函数，可以实现矩阵的行列互换

# 创建一个 2 行 3 列的矩阵
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t(M)
     [,1] [,2]
[1,]    2    1
[2,]    6   10
[3,]    5    4

• 访问矩阵元素

# 定义行和列的名称
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)
# 获取第一行第三列的元素
print(P[1,3])
# 获取第四行第二列的元素
print(P[4,2])
# 获取第二行
print(P[2,])
# 获取第三列
print(P[,3])

• 矩阵计算 :。矩阵的乘法则较为复杂。两个矩阵可以相乘，当且仅当第一个矩阵的列数等于第二 个矩阵的行数。
• 矩阵加减法 :查阅其它资料，多练习
• 矩阵乘除法

八.数组

1. 数组创建 ：R 语言数组创建使用 array() 函数，该函数使用向量作为输入参数，可以使用 dim 设置数组维度。

   array() 函数语法格式如下： array(data = NA, dim = length(data), dimnames = NULL）

   ​ data 向量，数组元素。

   ​ dim 数组的维度，默认是一维数组。

    	dimnames 维度的名称，必须是个列表，默认情况下是不设置名称的。
   

vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# 创建数组
result <- array(c(vector1,vector2),dim = c(3,3,2))
> print( result)
, , 1                         , , 2

     [,1] [,2] [,3]                   [,1] [,2] [,3]
[1,]    5   10   13             [1,]    5   10   13
[2,]    9   11   14             [2,]    9   11   14
[3,]    3   12   15             [3,]    3   12   15
#  使用 dimnames 参数来设置各个维度的名称
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.na
mes,column.names,matrix.names))

#获取数组元素，可以通过使用元素的列索引和行索引
print(result[3,,2])
# 显示数组第一个矩阵中第一行第三列的元素
print(result[1,3,1])

• .操作数组元素

  vector1 <- c(5,9,3)
  vector2 <- c(10,11,12,13,14,15)
  # 创建数组
  array1 <- array(c(vector1,vector2),dim = c(3,3,2))
  matrix1 <- array1[,,2]
  

• 跨纬度计算: apply(x, margin, fun)

  x 数组 margin 数据名称 fun 计算函数

# 创建两个不同长度的向量
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
# 创建数组
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
# 计算数组中所有矩阵第一行 的数字之和
result <- apply(new.array, c(1), sum)

九.因子

因子用于存储不同类别的数据类型

R 语言创建因子使用 factor() 函数，向量作为输入参数。 factor() 函数语法格式：

factor(x = character(), levels, labels = levels, exclude = NA, ordered = is.ordered(x), nmax = NA)
#   x：向量。
#   levels：指定各水平值, 不指定时由 x 的不同值来求得。
#   labels：水平的标签, 不指定时用各水平值的对应字符串。
#   exclude：排除的字符。
#   ordered：逻辑值，用于指定水平是否有序。
#   nmax：水平的上限数量。

因子水平标签 :使用 labels 参数为每个因子水平添加标签，labels 参数的字符顺序，要和 levels 参数的字符顺序保持一致

sex=factor(c('f','m','f','f','m'),levels=c('f','m'),labels=c('female','male'),ordered=TRUE)

生成因子水平 : gl() 函数来生成因子水平

gl(n, k, length = n*k, labels = seq_len(n), ordered = FALSE)
#   n: 设置 level 的个数
#   k: 设置每个 level 重复的次数
#   length: 设置长度
#   labels: 设置 level 的值
#   ordered: 设置是否 level 是排列好顺序的，布尔值。

v <- gl(3, 4, labels = c("you", "com","to"))

十.数据框

类似表格：数据框是 R 语言的数据结构，是特殊的二 维列表。数据框每一列都有一个唯一的列名，长度都是相等的，同一列的数据类型需要一 致，不同列的数据类型可以不一样

data.frame(…, row.names = NULL, check.rows = FALSE,check.names = TRUE, fix.empty.names = TRUE,stringsAsFactors = default.stringsAsFactors()
           
#  …: 列向量，可以是任何类型（字符型、数值型、逻辑型），一般以 tag = value 的
#  形式表示，也可以是 value。
#  row.names: 行名，默认为 NULL，可以设置为单个数字、字符或字符串和数字的向量。
#  check.rows: 检测行的名称和长度是否一致。
#  check.names: 检测数据框的变量名是否合法。
#  fix.empty.names: 设置未命名的参数是否自动设置名字。
#  stringsAsFactors: 布尔值，字符是否转换为因子，factory-fresh 的默认值是 TRUE，
#  可以通过设置选项（stringsAsFactors=FALSE）来修改。
table = data.frame(
 姓名 = c("张三", "李四"),
 工号 = c("001","002"),
 月薪 = c(1000, 2000)
)
#  数据框的数据结构可以通过 str() 函数来展示
str(table)
# summary() 可以显示数据框的概要信息
summary(table)
#提取指定的列
result <- data.frame(table$姓名,table$月薪)
#提取
table[1:2,]
# 读取第 2 、3 行的第 1 、2 列数据：
result <- table[c(2,3),c(1,2)]
 #  可以对已有的数据框进行扩展，以下实例添加部门列：
 # 添加部门列
table$部门 <- c("运营","技术","编辑")

• cbind() 函数将多个向量合成一个数据框

sites <- c("you","com","bao")
likes <- c(222,111,123)
cbind(sites,likes)

• 两个数据框进行合并可以使用 rbind() 函数

table = data.frame(
姓名 = c("张三", "李四","王五"),
工号 = c("001","002","003"),
月薪 = c(1000, 2000,3000)
)
newtable = data.frame(
姓名 = c("小明", "小白"),
工号 = c("101","102"),
月薪 = c(5000, 7000)
)
# 合并两个数据框
result <- rbind(table,newtable)

十一.数据重塑

合并数据框：R 语言合并数据框使用 merge()函数。

merge() 函数语法格式如下：

merge(x, y, …)
# data.frame 方法
merge(x, y, by = intersect(names(x), names(y)),
 by.x = by, by.y = by, all = FALSE, all.x = all, all.y = all,
 sort = TRUE, suffixes = c(".x",".y"), no.dups = TRUE,
 incomparables = NULL, …)
#   x, y： 数据框
#   by, by.x, by.y：指定两个数据框中匹配列名称，默认使用两个数据框中相同列名称。
#   all：逻辑值; all = L 是 all.x = L 和 all.y = L 的简写，L 可以是 TRUE 或 FALSE。
#   all.x：逻辑值，默认为 FALSE。如果为 TRUE, 显示 x 中匹配的行，即便 y 中没有对
#   应匹配的行，y 中没有匹配的行用 NA 来表示。
#   all.y：逻辑值，默认为 FALSE。如果为 TRUE, 显示 y 中匹配的行，即便 x 中没有对
#   应匹配的行，x 中没有匹配的行用 NA 来表示。
#   sort：逻辑值，是否对列进行排序。
#   merge() 函数和 SQL 的 JOIN 功能很相似： 
   ++++++++++++++连表查询+++++++++++

# data frame 1
df1 = data.frame(SiteId = c(1:6), 
Site= c("Google","Runoob","Taobao","Facebook","Zhihu","Weibo"))
# data frame 2
df2 = data.frame(SiteId = c(2, 4, 6, 7, 8), 
Country = c("CN","USA","CN","USA","IN"))
# INNER JOIN
df1 = merge(x=df1,y=df2,by="SiteId")
print("----- INNER JOIN -----")
>print(df1)
  SiteId     Site Country
1      2   Runoob      CN  ||
2      4 Facebook     USA  ||
3      6    Weibo      CN  ||
# 注释                      ||
=========匹配id相同的数字===========

# FULL JOIN
df2 = merge(x=df1,y=df2,by="SiteId",all=TRUE)
print("----- FULL JOIN -----")
print(df2)
  SiteId     Site Country.x Country.y
1      2   Runoob        CN        CN
2      4 Facebook       USA       USA
3      6    Weibo        CN        CN
4      7     <NA>      <NA>       USA
5      8     <NA>      <NA>        IN

# LEFT JOIN
df3 = merge(x=df1,y=df2,by="SiteId",all.x=TRUE)
print("----- LEFT JOIN -----")
print(df3)
  SiteId   Site.x Country   Site.y Country.x Country.y
1      2   Runoob      CN   Runoob        CN        CN
2      4 Facebook     USA Facebook       USA       USA
3      6    Weibo      CN    Weibo        CN        CN


# RIGHT JOIN
df4 = merge(x=df1,y=df2,by="SiteId",all.y=TRUE)
print("----- RIGHT JOIN -----")
print(df4)
 SiteId Site.x Country Site.y Country.x Country.y
1 2 Runoob CN Runoob CN CN
2 4 Facebook USA Facebook USA USA
3 6 Weibo CN Weibo CN CN
4 7 <NA> <NA> <NA> <NA> USA
5 8 <NA> <NA> <NA> <NA> IN

数据整合、拆分

melt() 和 cast() 函数来对数据进行整合和拆分。

• melt() ：宽格式数据转化成长格式。
• cast() ：长格式数据转化成宽格式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FMo0Gvzr-1617272465335)(D:\typora\working\R语言.assets\image-20210401140913664.png)]

1. melt（）函数：melt() 将数据集的每个列堆叠到一个列中

   melt(data, ..., na.rm = FALSE, value.name = "value")
   #  data：数据集。
   #  ...：传递给其他方法或来自其他方法的其他参数。
   #  na.rm：是否删除数据集中的 NA 值。
   #  value.name 变量名称，用于存储值。
   # 安装库，MASS 包含很多统计相关的函数，工具和数据集
   ===========================================================
   install.packages("MASS", repos = "https://mirrors.ustc.edu.cn/CRAN/") 
   # melt() 和 cast() 函数需要对库
   install.packages("reshape2", repos = "https://mirrors.ustc.edu.cn/CRAN/")
   install.packages("reshape", repos = "https://mirrors.ustc.edu.cn/CRAN/")
   
   # 载入库
   library(MASS)
   library(reshape2)
   library(reshape)
   # 创建数据框
    id = c(1,2,3,5)
   > time = c(1,2,1,2)
   > x1 <- c(5, 3, 6, 2)
   > x2 <- c(6, 5, 1, 4)
   > mydata <- data.frame(id, time, x1, x2)
   > cat("原始数据框:\n")
   原始数据框:
   > print(mydata)
     id time x1 x2
   1  1    1  5  6
   2  2    2  3  5
   3  3    1  6  1
   4  5    2  2  4
   > md <- melt(mydata, id = c("id","time"))
   > print(md)
     id time variable value
   1  1    1       x1     5
   2  2    2       x1     3
   3  3    1       x1     6
   4  5    2       x1     2
   5  1    1       x2     6
   6  2    2       x2     5
   7  3    1       x2     1
   8  5    2       x2     4
   > md <- melt(mydata, id = c("id","x2"))
   > print(md)
     id x2 variable value
   1  1  6     time     1
   2  2  5     time     2
   3  3  1     time     1
   4  5  4     time     2
   5  1  6       x1     5
   6  2  5       x1     3
   7  3  1       x1     6
   8  5  4       x1     2
   

2. cast（）函数 :cast 函数用于对合并对数据框进行还原，dcast() 返回数据框，acast() 返回一个向 量/矩阵/数组

dcast(
 data,  #合并的数据框。
 formula, #重塑的数据的格式，类似 x ~ y 格式，x 为行标签，y 为列标签 
 fun.aggregate = NULL, #：聚合函数，用于对 value 值进行处理。
 ...,
 margins = NULL, # 变量名称的向量（可以包含"grand\_col" 和 "grand\_row"），用于计算边距， 设置 TURE 计算所有边距。
 subset = NULL,  #对结果进行条件筛选，格式类似 subset =.(variable=="length")。
 fill = NULL,
 drop = TRUE,  #是否保留默认值
 value.var = guess_value(data) #后面跟要处理的字段
)
acast(
 data,
 formula,
 fun.aggregate = NULL,
 ...,
 margins = NULL,6
 subset = NULL,
 fill = NULL,
 drop = TRUE,
 value.var = guess_value(data)
)

==================================================================
 # 载入库
 library(MASS)
 library(reshape2)
 library(reshape)
 
 # 创建数据框
 id<- c(1, 1, 2, 2)
 time <- c(1, 2, 1, 2)
 x1 <- c(5, 3, 6, 2)
 x2 <- c(6, 5, 1, 4)
 mydata <- data.frame(id, time, x1, x2)
 # 整合
 md <- melt(mydata, id = c("id","time"))
 # Print recasted dataset using cast() function
 cast.data <- cast(md, id~variable, mean)
 print(cast.data)
  id x1  x2
1  1  4 5.5
2  2  4 2.5
cat("\n")

time.cast <- cast(md, time~variable, mean)
print(time.cast)
  time  x1  x2
1    1 5.5 3.5
2    2 2.5 4.5
cat("\n")

id.time <- cast(md, id~time, mean)
print(id.time)
  id   1 2
1  1 5.5 4
2  2 3.5 3
cat("\n")

id.time.cast <- cast(md, id+time~variable)
print(id.time.cast)
  id time x1 x2
1  1    1  5  6
2  1    2  3  5
3  2    1  6  1
4  2    2  2  4
cat("\n")

id.variable.time <- cast(md, id+variable~time)
print(id.variable.time)
  id variable 1 2
1  1       x1 5 3
2  1       x2 6 5
3  2       x1 6 2
4  2       x2 1 4
cat("\n")

id.variable.time2 <- cast(md, id~variable+time)
print(id.variable.time2)
  id x1_1 x1_2 x2_1 x2_2
1  1    5    3    6    5
2  2    6    2    1    4

十二.导包

• R 语言相关的包一般存储安装目录下对 “library” 目录

• R 语言完整的相关包可以查阅： https://cran.r-project.org/web/packages/available_packages_by_name.html

1. 查看 R 包的安装目录 ：.libPaths()

2. 使用 library() 查看安装的包

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4gGIJbI4-1617272465335)(D:\typora\working\R语言.assets\image-20210401143239004.png)]

3. 查看已载入的包 ：search()

4. 安装新包 :install.packages(“要安装的包名”)

# 可以直接设置包名，从 CRAN 网站上获取包，如下实例载入 XML 包：
# 安装 XML 包
install.packages("XML")
# 或者可以直接在 CRAN 上下载相关包，直接在本地安装：
install.packages("./XML_3.98-1.3.zip")
国内一般建议大家使用国内镜像，以下实例使用清华源进行安装：
# 安装 XML 包
install.packages("XML", repos = "https://mirrors.ustc.edu.cn/CRAN/")
CRAN (The Comprehensive R Archive Network) 镜像源配置文件之一是 .Rprofile
# 在文末添加如下语句:
options("repos" = c(CRAN="https://mirrors.tuna.tsinghua.edu.cn/CRAN/"))
打开R即可使用

• 使用

  # 新安装的包需要先载入 R 编译环境中才可以使用，格式如下：
  library("包名")
  # 以下实例载入 XML 包：
  library("XML")
  

十三.csv

• 什么是csv?

  • 逗号分隔值（Comma-Separated Values，CSV，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）

  • 最广泛的应用是在程序之间转移表格数据

  • 由于大多数软件支持这个文件格式，所以常用于数据的储存与交互。 CSV 本质是文本，它的文件格式极度简单：数据一行一行的用文本保存起来而已

  • warning: CSV 文件最后一行需要保留一个空行，不然执行程序会有警告信息。

• 读取 CSV 文件

• read.csv() 函数来读取 CSV 文件的数据

data <- read.csv("sites.csv", encoding="UTF-8") 
#encoding 属性，read.csv 函数将默认以操作系统默认的文字编码进行读取

• // # likes 最大的数据 like <- max(data$likes)

• 指定查找条件

  • subset()

     subset(data, likes == 1234) # likes 为 1234 的数据
    # 条件语句等于使用 ==。
    # 多个条件使用 & 分隔符，以下实例查找 likes 大于 1 name 为 how 的数据：
    subset(data, likes > 1 & name=="how")
    

• 保存为 CSV 文件

  • write.csv() 函数将数据保存为 CSV 文件

  data <- read.csv("test.csv", encoding="UTF-8")
  # likes 为 1234 的数据
  test1 <- subset(data, likes == 1234)
  # 写入新的文件
  write.csv(test1,"test.csv")
  newdata <- read.csv("test.csv")
  
  #  生成的数据中 X 来自数据集 newper，可以通过参数 row.names = FALSE 来删除它：
  

十四.excel

• Excel 格式的文件主要是 xls 或 xlsx , 导入 xlsx 库来 实现直接的读取。R 语言读写 Excel 文件需要安装扩展包

install.packages("xlsx", repos = "https://mirrors.ustc.edu.cn/CRAN/")
# 验证包是否安装
any(grepl("xlsx",installed.packages()))
# 载入包
library("xlsx")
data <- read.xlsx("sites.xlsx", sheetIndex = 1)

十五.画图

1.饼图 ： pie() 函数来实现饼图

pie(x, labels = names(x), edges = 200, radius = 0.8,
 clockwise = FALSE, init.angle = if(clockwise) 90 else 0,
 density = NULL, angle = 45, col = NULL, border = NULL,
 lty = NULL, main = NULL, …)
#  x: 数值向量，表示每个扇形的面积。
#  labels: 字符型向量，表示各扇形面积标签。
#  edges: 这个参数用处不大，指的是多边形的边数（圆的轮廓类似很多边的多边形）。
#  radius: 饼图的半径。
#  main: 饼图的标题。
#  clockwise: 是一个逻辑值,用来指示饼图各个切片是否按顺时针做出分割。
#  angle: 设置底纹的斜率。
#  density: 底纹的密度。默认值为 NULL。
#  col: 是表示每个扇形的颜色，相当于调色板。
#  绘制饼状图要做这些准备：反映数量的向量、各部分的标签、各部分的颜色（可选）。


# 数据准备
info = c(1, 2, 4, 8)
# 命名
names = c("Google", "Runoob", "Taobao", "Weibo")
# 涂色（可选）
cols = c("#ED1C24","#22B14C","#FFC90E","#3f48CC")
# 计算百分比
piepercent = paste(round(100*info/sum(info)), "%")
# 绘图
pie(info, labels=piepercent, main = "网站分析", col=cols, family='GB1')
# 添加颜色样本标注
legend("topright", names, cex=0.8, fill=cols)

======================3D=========================
install.packages("plotrix", repos = "https://mirrors.ustc.edu.cn/CRAN/")

# 载入 plotrix
library(plotrix)
# 数据准备
info = c(1, 2, 4, 8)
# 命名
names = c("Google", "Runoob", "Taobao", "Weibo")
# 涂色（可选）
cols = c("#ED1C24","#22B14C","#FFC90E","#3f48CC")
# 设置文件名，输出为 png
png(file = "3d_pie_chart.png")
# 绘制 3D 图，family 要设置你系统支持的中文字体库
pie3D(info,labels = names,explode = 0.1, main = "3D图",family = "STHeitiTC-Light")

2.条形图：barplot() 函数来创建条形图

barplot(H,xlab,ylab,main, names.arg,col,beside)
#  H 向量或矩阵，包含图表用的数字值，每个数值表示矩形条的高度。
#  xlab x 轴标签。
#  ylab y 轴标签。
#  main 图表标题。
#  names.arg 每个矩形条的名称。
#  col 每个矩形条的颜色。

cvd19 = c(83534,2640626,585493)
barplot(cvd19,
main="新冠疫情条形图",
col=c("#ED1C24","#22B14C","#FFC90E"),
names.arg=c("中国","美国","印度"),
family='GB1'
)

3.函数曲线

curve(expr, from = NULL, to = NULL, n = 101, add = FALSE,
 type = "l", xname = "x", xlab = xname, ylab = NULL,
 log = NULL, xlim = NULL, …)
# S3 函数的方法
plot(x, y = 0, to = 1, from = y, xlim = NULL, ylab = NULL, …)
# R 语言的类有 S3 类和 S4 类，S3 类用的比较广，创建简单粗糙但是灵活，而 S4 
# 类比较精细。
# expr：函数表达式
# from 和 to：绘图的起止范围
# n：一个整数值，表示 x 取值的数量
# add：是一个逻辑值，当为 TRUE 时，表示将绘图添加到已存在的绘图中。
# type：绘图的类型，p 为点、l 为直线， o 同时绘制点和线，且线穿过点。
# xname：用于 x 轴变量的名称。
# xlim 和 ylim 表示 x 轴和 y 轴的范围。
# xlab，ylab：x 轴和 y 轴的标签名称。
# plot 函数中，x 和 y 分别表示所绘图形的横坐标和纵坐标。

# 注意：任何计算机绘图工具绘制的都是模式图，它并不能保证与真的函数图像一模一
# 样，它只是每隔一段距离取一个点，然后计算这个点的"高度"并绘制出来，为了保证曲线连
# 续性，相邻两个点之间会有直线连接，所以在某些情况下例如 tan(x) 可能会出现错误
=================================================
# 向量数据
v <- c(7,12,28,3,41)
# 生成图片
png(file = "line_chart_label_colored.jpg")
# 绘图、线图颜色为红色，main 参数用于设置标题
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall", main = "Rain fall chart"：

4.散点图: 可以使用 plot() 函数来绘制

plot(x, y, type="p", main, xlab, ylab, xlim, ylim, axes)

#  x 横坐标 x 轴的数据集合
#  y 纵坐标 y 轴的数据集合
#  type：绘图的类型，p 为点、l 为直线， o 同时绘制点和线，且线穿过点。
#  main 图表标题。
#  xlab、ylab x 轴和 y 轴的标签名称。
#  xlim、ylim x 轴和 y 轴的范围。
#  axes 布尔值，是否绘制两个 x 轴。
#  type 参数可选择值：
#  p：点图 l：线图
#  b：同时绘制点和线 c：仅绘制参数 b 所示的线
#  o：同时绘制点和线，且线穿过点 h：绘制出点到横坐标轴的垂直线
#  s：阶梯图，先横后纵 S：阶梯图，先纵后竖
#  n： 空图
===================================================================
x<-c(10,40)
y<-c(20,60)
# 生成 png 图片
png(file = "runnob-test-plot.png")
plot(x, y, "o")
# 接下来使用 R 语言的内置数据集 mtcars 来进行测试。
# 使用 mtcars 数据集的 wt 和 mpg 列：
# 实例
input <- mtcars[,c('wt','mpg')]
print(head(input))
# 输出结果为：
wt mpg
Mazda RX4 2.620 21.0
Mazda RX4 Wag 2.875 21.0
Datsun 710 2.320 22.8
Hornet 4 Drive 3.215 21.4
Hornet Sportabout 3.440 18.7
Valiant 3.460 18.1
接着使用以上数据生存一个散点图：
实例
# 数据
input <- mtcars[,c('wt','mpg')]3
# 生成 png 图片
png(file = "scatterplot.png")
# 设置坐标 x 轴范围 2.5 到 5, y 轴范围 15 到 30.
plot(x = input$wt,y = input$mpg,
xlab = "Weight",
ylab = "Milage",
xlim = c(2.5,5),
ylim = c(15,30), 
main = "Weight vs Milage"
)
# 散点图矩阵
# 散点图矩阵是借助两变量散点图的作图方法，它可以看作是一个大的图形方阵，其每
# 一个非主对角元素的位置上是对应行的变量与对应列的变量的散点图。而主对角元素位置
# 上是各变量名，这样，借助散点图矩阵可以清晰地看到所研究多个变量两两之间的相关关
# 系。散点图矩阵就是把数据集中的每个数值变量两两绘制散点图。
# R 语言使用以下函数创建散点图矩阵：
pairs(formula, data)
# 参数：
formula 变量系列
data 变量的数据集
实例
# 输出图片
```r

#  type：绘图的类型，p 为点、l 为直线， o 同时绘制点和线，且线穿过点。
#  main 图表标题。
#  xlab、ylab x 轴和 y 轴的标签名称。
#  xlim、ylim x 轴和 y 轴的范围。
#  axes 布尔值，是否绘制两个 x 轴。
#  type 参数可选择值：
#  p：点图 l：线图
#  b：同时绘制点和线 c：仅绘制参数 b 所示的线
#  o：同时绘制点和线，且线穿过点 h：绘制出点到横坐标轴的垂直线
#  s：阶梯图，先横后纵 S：阶梯图，先纵后竖
#  n： 空图
===================================================================
x<-c(10,40)
y<-c(20,60)
# 生成 png 图片
png(file = "runnob-test-plot.png")
plot(x, y, "o")
# 接下来使用 R 语言的内置数据集 mtcars 来进行测试。
# 使用 mtcars 数据集的 wt 和 mpg 列：
# 实例
input <- mtcars[,c('wt','mpg')]
print(head(input))
# 输出结果为：
wt mpg
Mazda RX4 2.620 21.0
Mazda RX4 Wag 2.875 21.0
Datsun 710 2.320 22.8
Hornet 4 Drive 3.215 21.4
Hornet Sportabout 3.440 18.7
Valiant 3.460 18.1
接着使用以上数据生存一个散点图：
实例
# 数据
input <- mtcars[,c('wt','mpg')]3
# 生成 png 图片
png(file = "scatterplot.png")
# 设置坐标 x 轴范围 2.5 到 5, y 轴范围 15 到 30.
plot(x = input$wt,y = input$mpg,
xlab = "Weight",
ylab = "Milage",
xlim = c(2.5,5),
ylim = c(15,30), 
main = "Weight vs Milage"
)
# 散点图矩阵
# 散点图矩阵是借助两变量散点图的作图方法，它可以看作是一个大的图形方阵，其每
# 一个非主对角元素的位置上是对应行的变量与对应列的变量的散点图。而主对角元素位置
# 上是各变量名，这样，借助散点图矩阵可以清晰地看到所研究多个变量两两之间的相关关
# 系。散点图矩阵就是把数据集中的每个数值变量两两绘制散点图。
# R 语言使用以下函数创建散点图矩阵：
pairs(formula, data)
# 参数：
formula 变量系列
data 变量的数据集
实例
# 输出图片

大概走马观花看了一下R,自我感觉和matlab 和python 的数据处理有很多相似之处，多有建议学好一门，其它两个就比较容易上手了。有什么错误之处还请批评指正。