R学习笔记:《R语言入门与数据分析》

R语言 专栏收录该内容
2 篇文章 2 订阅

前言:这是根据B站《R语言入门与数据分析》自学整理的学习笔记。非科班出身,之前也没接触过代码,自己理解能力也比较差,所以会显得外行又笨拙,但还是希望多交流学习,才有动力持续进步。
目前这个课程笔记还没完结,会边学边更新。

文章目录

P1 课程介绍

R语言用途:

  • 统计
  • 绘图

课程设置:

  • 数据分析内容,R的目的
  • R的基本操作
  • 的数据结构和操作(重点)
  • R对于文件的操作,读取
  • R语言的实战分析

课程包含案例脚本和实战练习题


P2 数据分析

数据:指对客观事件进行记录并可以鉴别的符号,性质、状态及相互关系的记录

目的:指导决策

数据分析过程:

数据采集 --> 数据储存 --> 数据统计 --> 数据挖掘 --> 数据可视化 --> 进行决策

数据挖掘:非线性数据,一般指从大量的数据中通过算法搜索隐藏于其中信息的过程(探索的过程)

而数据统计则更注重于统计,可以通过不同的方法,但结果一样,数据挖掘则不同的人可能有不同的结果


P3 数据挖掘

  • 分析与某事物相关的所有数据,而不是少部分数据,注重关联
  • 接受数据的复杂性,而不过于追求精确性
  • 不过分探求因果关系,转而关注事物的相关

P4 数据可视化

将数字结果用图形化展示出来


P5 R语言介绍

源自于S语言,但开源、免费,最初由做生物统计的科学家Robert开发

R语言的特点

  • 有效的数据处理和保存机制
  • 拥有完整数组和矩阵的操作运算符
  • 一系列连贯而又完整的数据分析中间工具
  • 数据可视化
  • 程序设计语言:语句
  • 彻底面向对象的统计编程语言
  • 和其他编程语言、数据库之间有很好的接口
  • 自由、开源、免费
  • 具有丰富的网上资源

用于计算、统计、绘图、编程、分析(扩展包)

R语言的缺点

  • R软件不够规范,不容易上手,学习成本高
  • R扩展包数量太大,难以查找和上手,且这些包不如商业软件稳定

P6 案例演示

0.5mg1mg2mg
橙汁
维生素C

豚鼠摄入上述两种物质对牙齿长度的影响


P7 R软件的安装

R语言官方网站(在CRAN-Mirrors里选择国内的镜像站点下载)

Rstudio官网下载(与R语言的区别在多了几个面板,操控跟容易,实质是IDE集成环境)

本人直接选择下载课程方打包放在百度云的版本(同时包含R语言和Rstudio)


P8 R软件的运行与设置

此节略过


P9 Rstudio

窗口布局如下表

左上窗口:R代码界面即脚本窗口右上窗口:环境和历史记录
左下窗口:R的控制台右下窗口:功能模块包括文档、绘图、帮助等

左上脚本窗口

  • 编写代码,可直接保存,编写好的代码也是在这一模块直接导入
  • 右上角的“Run”按钮直接点击是运行当前行,选中代码点击“Run”则是运行选中行
  • 右上角的“Source”点击后运行所有代码,并会在左上窗口显示运行信息
  • 左上角的荧光棒符号是检查语法的功能
  • 左上角的放大镜是查找与替换的功能
  • 左上角最左边的保存按钮可将代码保存在不同文件中

左下控制台窗口

  • 练习代码用
  • 包扩内置数据集、函数和扩展包的联想功能(设置中可关闭联想功能)
    • 输入首字母后按“Tab”键,会出现联想功能(补齐)注意不能连续敲Tab,如果连敲两下代表默认补齐第一个函数,多加练习熟练之后可迅速反应敲几个字母排在首位的函数可直接敲Tab补齐
    • 内置数据集 粉色
    • 数据框 表格图案
    • 函数 蓝色

右上环境和历史记录窗口

  • Environment:列出当前工作空间中包含的对象,对象的值

如在左下角的控制台窗口直接输入

> mtcars

可直接显示查看对象

  • History:敲过的代码

右下功能模块窗口

  • Files:当前工作空间所在文件
  • Plots:图形展示窗口,在左下控制台中调用绘图函数时,图形会展示在此处的Plots窗口(所见即所得)
  • Package:展示出系统已有的软件包,也可安装新的或者升级已有的软件包;勾选的包的名字则直接载入到左下控制台界面

上述每个窗口界面的占比都可通过鼠标移动缩放,更多的设置可点击

Tools --> Global Options --> Appearance(字体、主题)

快捷键

Ctrl + ↑

  • 直接按列出历史输入记录(上下方向键进行选择)
  • 再输入几个字母后按,如输入“> lib"后按Ctrl + ↑,则列出的是所有用过的包含”lib“的函数

Esc

  • 在任何情况下按Esc键则中断操作

    • 比如一个函数没敲完换行,出现连续几行的“+”的情况,此时可以直接按Esc中断操作
    > sum(X
    + 
    + 
    + 
    + 
    
    > 
    
  • 若语句太长,需要一个个删除太麻烦也可以直接按Esc中断操作

Alt + shift + K

可现实Rstudio中所有的快捷操作


P10 Rstudio 基本操作

  1. 设定工作目录:输入和输出文件的默认位置,包括读取和写入数据文件、打开和保存脚本文件以及保存工作空间映像等
  2. 可使用getwd命令查看当前默认的工作目录
> getwd()
[1] "C:/Users/Lin/Documents"
  1. R中的函数必须加小括号,因为在R中常量、变量、函数甚至图形都被称为对象,而对象都可以用自定义字母表示

可通过setwd函数命令更改工作目录,一般设置成文件所在的目录,结果输出也为此目录

> setwd(dir = "D:/RData/Data Practice")
> getwd()
[1] "D:/RData/Data Practice"
> 

注意:调出setwd函数后,dir语句得跟双引号,且Windows默认路径中为反斜线\,R语言中路径里得改成正斜线/,且需要再输一次getwd函数

上述同样适用于修改rprofile.set文件

  1. 可使用list.files函数查看当前目录下包含文件
> setwd(dir = "D:/Rdata")
> getwd()
[1] "D:/Rdata"
> list.files()
 [1] "2015年度中国城市GDP排名.xlsx"
 [2] "Ch01.R"                      
 [3] "Ch02.R"                      
 [4] "Ch03.R"                      
 [5] "Ch04.R"                      
 [6] "Ch05.R"                      
 [7] "Data Practice"               
 [8] "data.xlsx"                   
 [9] "file.xlsx"                       

list.files的功能等同于

> dir()

5. 赋值操作

局部赋值

> x <- 3
> x
[1] 3
  • 与其他语言一样,变量名不能是数字开头
  • R语言赋值符号为一个小于号加一个连字符,中间没有空格

当然,也可以用等号进行赋值:

> x=3
> x
[1] 3

但一般不这么做,一是不专业,二是容易与计算结果符弄混

赋值符 <- 的快捷键:Alt + -

全局变量赋值

> X <<- 5
> X
[1] 5

当使用“ <<- "时表示强制赋值给一个全局变量,而不是局部变量

清屏快捷键:Ctrl + L

  1. 查看工作空间中已经定义的变量和函数:
> ls()
[1] "x" "X" "y" "z" "Z"
> ls.str()
x :  num 6
X :  num 5
y :  num 30
z :  num 7
Z :  num 1
> str(x)
 num 6
> str(y)
 num 30
> str(z)
 num 7

ls函数查看变量列表,str函数查看具体的变量值

如果需要查看名字中包含“.”的变量名,可使用:

> ls(all.names = TRUE)
[1] ".Random.seed" "x"            "X"           
[4] "y"            "z"            "Z"    
  1. 删除变量(对象)
> rm (x)
> x
Error: object 'x' not found

使用rm(即remove的缩写)函数可删除一个或者多个对象:

> rm(x,y)
Warning message:
In rm(x, y) : object 'x' not found
> rm(y,z)
Warning message:
In rm(y, z) : object 'y' not found
#出现not found是因为我在上一步已经删除了这个对象

如果想一次性删除整个工作簿中的所有对象:

> rm (list=ls())
#列表和删除的组合函数

但注意,删除之后是不可撤销且没有回收站功能的

  1. 列出历史命令
> history(25)
#适用于清屏后,最大只支持最近25条记录,会在右上角环境窗口显示
  1. 保存

    图片另存

    ​ 为防止一次处理太多数据而导致的崩溃,可随时使用函数> save.image(),类似word里的Ctrl + S的定期保存功能,并会在工作目录中生成一个R.Data文件,但只会保留数据和绘图函数等,绘制出来的图形不会单独保存,是另外的图片格式。保存图片可使用:

    > q()
    Save workspace image to D:/RData/Data Practice/.RData? [y/n]: 
    #键入y即可保存
    

P11 R包的安装

​ 官网包的位置:进入任意一个R的镜像下载页面(这里以中科大的镜像为例),点击左侧的“Packages”,再点击正文的“CRAN Task Views

R这个模式有点像手机操作系统,而包就是一个个的APP,通过安装不同APP来扩展手机系统的功能

R包的安装方式有两种

  • R包的在线安装(推荐)

    首次安装包应打开R而不是Rstudio,并输入:

> install.packages() #会跳出一个CRAN镜像选择框(网或者电脑卡则需要稍等一会儿才会弹出),根据地址就近选择就行,比如我选的是GuangZhou
接着会跳出一个数量巨大的 包选择对话框,从中选择需要下载安装的包即可
#接着程序会自动下载到默认目录并安装
#比如我的被安装到了C:\Users\Lin\AppData\Local\Temp\Rtmpwrn7kB\downloaded_packages

​ 因为默认安装包下载在C盘,并不想存在此处,那么如何修改R包的默认下载储存位置呢?经过网上一番搜索找到如下答案:

1. 改变默认的安装路径:
.libPaths("new path")
#但这只是安装位置,下载保存位置依然没变,那么↓

2. 改变某一个包的保存及安装路径:
install.packages("Packagename",destdir="destdir",lib="libdir")
其中destdir为包所在位置,lib为指定的包安装路径

>  install.packages("ggplot2",destdir="D:/RData/R-win-4.0.2/R-4.0.2/R-packages",lib="D:/RData/R-win-4.0.2/R-4.0.2/R-packages")#缺点是每次下载新的包都得设置一次

#我这么做的过程中出现了两次问题,一次是R版本不够新导致的安装时出现
安装程序包‘ggplot2’时退出狀態的值不是0
#解决办法是更新版本后重装即可

#第二次是安装到一半时网断了,出现
InternetOpenUrl失败:’无法与服务器建立连接'
#解决办法是重新联网……

#于是在下方学习到了一个用代码更新R的方法

R版本更新用代码命令行更新

#更新R版本-共三个命令行
> install.packages("installr")
还安装相依关系‘stringi’, ‘stringr’

下载的程序包在
        ‘C:\Users\Lin\AppData\Local\Temp\Rtmpwrn7kB\downloaded_packages’里
> library(installr)
 To suppress this message use:
                        suppressPackageStartupMessages(library(installr))

> updateR()
The file was downloaded successfully into:
 C:\Users\Lin\AppData\Local\Temp\Rtmpwrn7kB/R-4.0.2-win.exe 

查看包的安装位置

> .libPaths()
[1] "D:/RData/R-win-4.0.2/R-4.0.2/R-packages"
[2] "D:/RData/R-win-4.0.2/R-4.0.2/library"   

直接用联网安装的好处是对新手来说操作简单,自动安装,且会联动下载相关的关联包(相依关系)

查看已安装的包

​ 在RStudio中的左下角的控制台输入> library(),则会在左上角的脚本窗口弹出一个选项卡界面显示当前已安装的包

  • 源代码安装

​ 需要手动在官网下载和设置包的源代码,并选择安装路径等一系列设置,同时还需要手动查看并处理依赖包的一系列安装,暂时不会用到,需要时再研究

可使用> update.packages()这一命令对包进行更新


P12 R包的使用

R包:实际上是函数、数据,预编译代码等以一种定义完善的方式组成的集合

  • 存储包的目录称为库,函数> .libPaths()显示包的存放位置
  • > library()可以在左上角弹出页面显示目前有哪些包
  • 可以使用> library()或者> require()载入包,此时括号里的字符串(也就是包的名字)不需要使用引号了
  • R本身内置了几个基础包,包括base datasets utils grDevices graphics stats methods splines stats4 tcltk等,提供了种类繁多的默认函数和数据集
  • 函数> search()回车可以显示出哪些包已加载并可以使用了
  • 敲出的每个函数都会有提示框后面的灰色字显示来自哪个包
  • 输入> help(package="ggplot2")会在右下角的功能模块出现帮助文档:包含代码展示。实例展示等;
  • 也可以通过> library(help="ggplot2")查看包的基本信息,内容会列在左上角的控制台模块里;
    • 在左上角内容界面的索引条目下,会出一系列的数据集,一般是为了给包中的函数作为案例使用的
  • 可使用> ls("package:vcd")命令列出当前包中所有函数
    • 具体函数如何使用可用命令> data(package="vcd"),可列出R包中包含的所有数据集
  • 移除已经加载的包可使用>detach("package:vcd")函数
  • 克隆R包(用于换设备时转移):
    • 使用> installed.packages()列出当前环境中已安装的包(install后面有ed,注意区分);
    • 接着输入> installed.packages()[,1],即使用下标访问数据的第一列;
    • 将所有R包的名字保存到一个文件中Rpack <- installed.packages()[,1]save(Rpack,file="Rpack.Rdata")
    • 将上面这个文件移到另一台设备中,可使用>load()函数来打开这个文件。存到另外一个变量> Rpack
    • 在新设备中批量安装这些包可使用for循环:`> for (i in pack) install.packages(i)
    • 即使新设备中已存在部分包也没关系,安装时会自动跳过已安装的包

P13 获取帮助

  • 直接点击可视化窗口菜单栏中的“Help”可查看,也可调用>help.start()查看帮助文档
  • 如果想直接查看某个函数的用途,可直接输入> help(),会在右下角窗口出现帮助信息,也可直接输入一个问号紧接函数名,如> ?plot,效果相同
  • 如果不想看那么多的函数具体信息,只想知道该函数的参数,可输入如>args(plot)查看
  • 如果想看一个函数的使用示例,可使用如> example(mean)查看,绘图案例同理可用如> example(“hist”)查看
  • 此外,R的内置函数> demo(graphics)会列出一些==案例图==
  • 除了help函数查看R包的帮助外,还可以通过更详细的> vignette函数查看,包含简介、教程、开发文档等(但不是所有包都包含这个文档)
  • 在未加载包的情况下查看包的帮助文档,可使用如> ??ggplot2这个格式查找
  • 在不知道具体包名,只知道一些关键词信息的情况下想查看具体的包的帮助,可使用本地搜索函数如> help.search("heatmap")
  • 列出所有包含关键词的包可使用如> apropos("sum")进行搜索
  • 若函数搜索不到,或者文档太老了,可使用如> RSiteSearch("matlab")联网搜索,结果会在默认浏览器里访问R官网并打开搜索结果
  • 使用搜索引擎搜索:R搜索引擎,这是基于谷歌搜索引擎中得到的结果并提取出于R相关的结果部分(前提是能访问Google才能顺利使用该网站进行搜索

P14 Excel案例

本节为以《2015年度中国城市GDP排名》的表格为案例演示Excel数据分析的基本操作

R与Excel的比较:R与Excel最大的一个不同就是R软件不能使用鼠标。因此,在Excel中可以非常轻松完成的选择,框选,复制,粘贴,填充,排序,筛选等等操作,在R中必须使用代码来完成。(R往往用来处理大数据,使用鼠标反而更不方便)

行是观测值,列是变量值

快捷键:Alt + +

设置单元格格式:Ctrl + 1

对于需要可视化分析的数据,熟练掌握数据透视表的使用有助于提高工作效率


P15 内置数据集

  • 使用函数> help(package="datasets")可以在右下角窗口调出内置数据集文档,可点击查看详细信息,主要包含的是美国或者欧洲的数据信息
  • 使用> data()括号了里什么也不加可以在左上角窗口调出所有包含的内置数据集的列表(左列是名字,右列是介绍),包含矩阵、列表、因子、数据框以及时间序列等类型
  • 直接输入数据集的名字,就会显示相关数据,如> rivers会显示美国133条河流的长度(注意:自己的数据命名时尽量不要与内置数据集重复,避免覆盖内置数据集,但即使被覆盖也可以通过函数> data("rivers")重新加载即可)
  • 查看内置向量数据的属性信息
> names(euro)
 [1] "ATS" "BEF" "DEM" "ESP" "FIM" "FRF" "IEP" "ITL" "LUF"
[10] "NLG" "PTE"
  • 使用内置数据集构建矩阵(以美国各洲参数为例)
> state <- data.frame(state.name,state.abb,state.area,state.division,state.region)
> state
       state.name state.abb state.area     state.division
1         Alabama        AL      51609 East South Central
2          Alaska        AK     589757            Pacific
3         Arizona        AZ     113909           Mountain
4        Arkansas        AR      53104 West South Central
5      California        CA     158693            Pacific
6        Colorado        CO     104247           Mountain
7     Connecticut        CT       5009        New England
8        Delaware        DE       2057     South Atlantic
9         Florida        FL      58560     South Atlantic
10        Georgia        GA      58876     South Atlantic
11         Hawaii        HI       6450            Pacific
12          Idaho        ID      83557           Mountain
13       Illinois        IL      56400 East North Central
14        Indiana        IN      36291 East North Central
  • 对内置数据集生成热图
> heatmap(volcano)
生成示例
  • 使用> data(package=.packages(all.available = TRUE))可加载R包中所有可用的数据集
  • 如果只想加载数据集而不是整个R包,可使用> data(chile,package="car")(第一个参数是包的名字,第二个参数是需要加载的数据集的名字),再输入> Chile该数据集就会被加载进来

P16 数据结构

数据结构:是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

  1. R中的数据类型
  • 数值型:数值可以用于直接结算,加减乘除;
  • 字符串型:可以进行连接、转换,提取等
  • 逻辑型:真或者假
  • 日期型等

不同的数据类型相当于基本的单词,数据结构相当于自然语言中的词汇、短语、句子甚至是文章

  1. 一般变成数据结构
  • 普通数据结构:向量、标量、列表、数组、多维数组
  • 特殊数据结构:
    • perl中的哈希
    • Python中的字典
    • C语言中的指针等
  1. R对象

对象:object,是指可以赋值给变量的任何事物,包括常量、数据结构、函数,甚至图形。对象都拥有某种模式,描述了此对象是如何储存的,以及某个类。

  1. R中数据结构
  • 向量,标量
  • 矩阵
  • 数组
  • 列表
  • 数据框
  • 因子
  • 时间序列
  • ……

P17 向量

向量:vector,是R中最重要的一个概念,它是构成其他数据结构的基础。R中的向量概念与数学中的向量(矢量)是不同的,类似于数学上集合的概念,由一个或者多个元素构成。

向量其实是用于储存数值型、字符型或逻辑型数据的一堆数组。

用函数c来创建向量。c代表concatenate连接,也可以理解为收集collect,或者合并combine。

> x <- c(1,2,3,4,5)
> x #相当于省略print函数
[1] 1 2 3 4 5
> print(x)
[1] 1 2 3 4 5
> y <- c("one","two","three") #字符串一定要加引号
> y
[1] "one"   "two"   "three"
> z <- c(TRUE,T,F) #不加引号,但是字母都要大写
> z
[1]  TRUE  TRUE FALSE
> c(1:100) #冒号隔开表示依次列出1到100的所有整数值(向量)
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100
> seq(from=1,to=100) #从1到100
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100
> seq(from=1,to=100,by=2) #从1到100,间隔为2的所有向量(等差数列)
 [1]  1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37
[20] 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75
[39] 77 79 81 83 85 87 89 91 93 95 97 99
> seq(from=1,to=100,length.out = 10) #控制间隔长度,调整等差跨度
 [1]   1  12  23  34  45  56  67  78  89 100
> rep(2,5) #重复某个向量,第一个参数是要被重复的向量,第二个参数是重复次数
[1] 2 2 2 2 2
> rep(x,5) #这里是重复刚刚上面定义的向量x
 [1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
> rep(x,each=5) #设置重复方式,是整个数组重复,还是里头每一个元素集中重复
 [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5
> rep(x,each=5,times=2) #当each和times同时存在时,出来的结果就是它们的乘积
 [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 1 1 1 1
[30] 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5
> a <- c(1,2,"one") 
> a
[1] "1"   "2"   "one"  #输入的向量必须为同一类型,如不是则会被像如此转换
> mode(a)
[1] "character" #开头给a赋值的数字型在这里就被转换成了语句
> mode(z)
[1] "logical"

向量化编程的优势

> x <- c(1,2,3,4,5)
> y <- c(6,7,8,9,10)
> 1*2+6 #想让x向量中每一个元素都乘以2加上y向量中的每一个对应位置的元素该如何实现?
[1] 8
> x*2+y #这个语句就比其他编程语言中的for循环简单的多
[1]  8 11 14 17 20
> x[x>3] #从x中取出x>3的值
[1] 4 5
> rep(x,c(2,4,3,1,5)) #控制x中每一个元素的循环次数
 [1] 1 1 2 2 2 2 3 3 3 4 5 5 5 5 5

P18 向量索引

向量索引:访问向量中的元素

  • 正(负)整数索引

> x <- c(1:100)
> x
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100
> length(x) #向量x中元素个数
[1] 100
> x[1] #向量x中第一个元素 也可以是 直接写出的这个元素 只是这里两个1刚好重复了
[1] 1
> x[0] #与其它编程语言不同,R是从1开始而不是从0开始,所以输入0则输出无效
integer(0)
> x(c(1:6)) #注意x后面第一层一定要跟中括号
Error in x(c(1:6)) : could not find function "x"
> x[c(1:6)] #输出x向量中第一到第六个元素
[1] 1 2 3 4 5 6
> x[-3] #负索引,输出x向量中除开第三个元素之外的所有元素
 [1]   1   2   4   5   6   7   8   9  10  11  12  13  14  15
[15]  16  17  18  19  20  21  22  23  24  25  26  27  28  29
[29]  30  31  32  33  34  35  36  37  38  39  40  41  42  43
[43]  44  45  46  47  48  49  50  51  52  53  54  55  56  57
[57]  58  59  60  61  62  63  64  65  66  67  68  69  70  71
[71]  72  73  74  75  76  77  78  79  80  81  82  83  84  85
[85]  86  87  88  89  90  91  92  93  94  95  96  97  98  99
[99] 100
> x[c(1,3,7,44,67,89)] #输出指定元素
[1]  1  3  7 44 67 89
> x[c(1,5,5,34,34,53,53,53)] #输出重复元素
[1]  1  5  5 34 34 53 53 53
> x[c(-3,45,67)] #除去第三位后后面的元素顺序就变了,所以不能正确定义而报错,无法同时存在输出
Error in x[c(-3, 45, 67)] : 
  only 0's may be mixed with negative subscripts
  • 逻辑向量索引

> y <- c(1:10)
> y
 [1]  1  2  3  4  5  6  7  8  9 10
> y[c(T,T,F,F,T,F,T,T,F,T)] #用逻辑值作为索引,可以将TURE和FALSE缩写成T和F,这里的逻辑值对应y向量中的十个元素
[1]  1  2  5  7  8 10 #只输出了逻辑值为真的元素
> y[c(T)] #不需要与元素个数相等的逻辑值,也可以用循环
 [1]  1  2  3  4  5  6  7  8  9 10 #表示向量y中所有元素都为真即全部输出
> y[c(f)] #注意逻辑值一定要大写
Error: object 'f' not found
> y[c(F)] #如果只有一个F则都不输出
integer(0)
> y[c(T,F)] #这里相当于使用“T,F”这个顺序循环
[1] 1 3 5 7 9
> y[c(T,T,F)]
[1]  1  2  4  5  7  8 10
> y[c(T,T,F,F,T,F,T,T,F,T,T)] #如果逻辑值的数量大于元素个数,则会产生缺失值
[1]  1  2  5  7  8 10 NA
> y[c(T,T,F,F,T,F,T,T,F,T,F)] #如果多的那个逻辑值为F则不输出
[1]  1  2  5  7  8 10
> y[y>4 & y<8] #条件判断表达式
[1] 5 6 7


> z <- c("one","two","three","four","five")
> z
[1] "one"   "two"   "three" "four"  "five" 
> "one" %in% z #%in%判断前面一个向量内的元素是否在后面一个向量中,返回布尔值
[1] TRUE
> z["one" %in% z]
[1] "one"   "two"   "three" "four"  "five" 
> z[z %in% C("one","two")]
Error in C("one", "two") : object not interpretable as a factor #c要小写
> z[z %in% c("one","two")]
[1] "one" "two"
> z %in% c("one","two")
[1]  TRUE  TRUE FALSE FALSE FALSE
> k <- z %in% c("one","two")
> z[k]
[1] "one" "two"
  • 名称索引

> names(y) <- c("one","two","three","four","five","six","seven","eight","nine","ten")
> y
  one   two three  four  five   six seven eight  nine   ten  #元素名称,name的属性
    1     2     3     4     5     6     7     8     9    10  #向量的元素值,即value
> names(y)
 [1] "one"   "two"   "three" "four"  "five"  "six"   "seven"
 [8] "eight" "nine"  "ten"  
> euro #euro数据集,通过names函数访问向量的名称属性
        ATS         BEF         DEM         ESP         FIM 
  13.760300   40.339900    1.955830  166.386000    5.945730 
        FRF         IEP         ITL         LUF         NLG 
   6.559570    0.787564 1936.270000   40.339900    2.203710 
        PTE 
 200.482000 

如何修改向量(包括添加、删除和修改数据)

> x <- c(1:100)
> x
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100
> x[101] <- 101 #多一个元素
> x
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100 101
> v <- 1:3
> v[c(4,5,6)] <- c(4,5,6) #索引添加,批量赋值到具体位置
> v
[1] 1 2 3 4 5 6
> v[20] <- 4 #元素4被添加到20个元素,中间扩展没用被赋值的元素均为NA即缺失值
> v
 [1]  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA NA
[20]  4


将数据添加到指定位置
> append(x = v,values = 99,after = 5) #将元素99添加到第五位之后
 [1]  1  2  3  4  5 99  6 NA NA NA NA NA NA NA NA NA NA NA NA
[20] NA  4
> append(x=v,values = 99,after = 0) #after=0则是添加到第一位
 [1] 99  1  2  3  4  5  6 NA NA NA NA NA NA NA NA NA NA NA NA
[20] NA  4


删除数据
> rm(v) #删除整个向量
> v
Error: object 'v' not found

> y[-c(1:3] #删除向量中的某个元素,可使用负整数索引的方式
 four  five   six seven eight  nine   ten 
    4     5     6     7     8     9    10 
> y <- y[-c(1:3)] #将替换掉的y重新赋值,作用相当于删除其中的元素了
> y
 four  five   six seven eight  nine   ten 
    4     5     6     7     8     9    10

修改数据       
> y["four"] <- 100 #将元素four的值改为100
> y
 four  five   six seven eight  nine   ten 
  100     5     6     7     8     9    10 
> x[2]
[1] 2
> x[2] <- 148 #将元素2改成148
> x[2]
[1] 148
> x[2] <- "one" #数值向量不能赋值给一个字符串
> x
  [1] "1"   "one" "3"   "4"   "5"   "6"   "7"   "8"   "9"  
 [10] "10"  "11"  "12"  "13"  "14"  "15"  "16"  "17"  "18" 
 [19] "19"  "20"  "21"  "22"  "23"  "24"  "25"  "26"  "27" 
 [28] "28"  "29"  "30"  "31"  "32"  "33"  "34"  "35"  "36" 
 [37] "37"  "38"  "39"  "40"  "41"  "42"  "43"  "44"  "45" 
 [46] "46"  "47"  "48"  "49"  "50"  "51"  "52"  "53"  "54" 
 [55] "55"  "56"  "57"  "58"  "59"  "60"  "61"  "62"  "63" 
 [64] "64"  "65"  "66"  "67"  "68"  "69"  "70"  "71"  "72" 
 [73] "73"  "74"  "75"  "76"  "77"  "78"  "79"  "80"  "81" 
 [82] "82"  "83"  "84"  "85"  "86"  "87"  "88"  "89"  "90" 
 [91] "91"  "92"  "93"  "94"  "95"  "96"  "97"  "98"  "99" 
[100] "100" "101"
      
  • 赋值的时候用( ),查东西的时候用[ ]

P19 向量运算

数值运算

> x <- 1:10
> x
 [1]  1  2  3  4  5  6  7  8  9 10
> x+1 #每一个元素都加1
 [1]  2  3  4  5  6  7  8  9 10 11
> x-3 #每一个元素都减3
 [1] -2 -1  0  1  2  3  4  5  6  7
> x <- x+1 #将结果赋值更新
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> y <- seq(1,100,length.out = 10) #1-100差十个间隔的等差数列
> y
 [1]   1  12  23  34  45  56  67  78  89 100
> x+y #每个对应位置的元素相加
 [1]   3  15  27  39  51  63  75  87  99 111
> x*y #每个对应位置的元素相乘
 [1]    2   36   92  170  270  392  536  702  890 1100
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> y
 [1]   1  12  23  34  45  56  67  78  89 100
> x**y #x的y次幂
 [1]  2.000000e+00  5.314410e+05  7.036874e+13  5.820766e+23
 [5]  1.039456e+35  2.115876e+47  3.213876e+60  2.697216e+74
 [9]  1.000000e+89 1.378061e+104
> y%%x # y除以x的余数
 [1] 1 0 3 4 3 0 3 6 9 1
> y%/%x #y除以x的值
 [1] 0 4 5 6 7 8 8 8 8 9
> z <- c(1,2) #元素个数不一致的计算情况,定义一个只有两个元素的z
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> x+z #z会被循环使用,第一次加1,第二次加2,第三次加1.第四次加2……以此类推
 [1]  3  5  5  7  7  9  9 11 11 13
> x*z #乘同加
 [1]  2  6  4 10  6 14  8 18 10 22
> z <- 1:3 #如果将向量z的元素定义为3个呢?
> x
 [1]  2  3  4  5  6  7  8  9 10 11
> z
[1] 1 2 3
> x+z
 [1]  3  5  7  6  8 10  9 11 13 12
Warning message:
In x + z : longer object length is not a multiple of shorter object length
#出现报错,提示x和z的长度不匹配,在向量运算中,元素个数必须为整数倍

逻辑运算

> x
 [1]  2  3  4  5  6  7  8  9 10 11
> x>5
 [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE
[10]  TRUE
> y
 [1]   1  12  23  34  45  56  67  78  89 100
> x>y
 [1]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10] FALSE
> c(1,2,3) %in% c(1,2,2,4,5,6) #包含运算符%in%表示左边的值是否存在于右边,如果在则输出为TRUE
[1]  TRUE  TRUE FALSE

> x
 [1]  2  3  4  5  6  7  8  9 10 11
> y
 [1]   1  12  23  34  45  56  67  78  89 100
> x==y #两个等于号==是逻辑运算
 [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10] FALSE
> x=y #一个等号=是赋值,一定要注意区分以免影响后面的运算
> x
 [1]   1  12  23  34  45  56  67  78  89 100
> y
 [1]   1  12  23  34  45  56  67  78  89 100

向量运算的函数

  • 数学函数
> x <- -5:5
> abs(x) #求向量x的绝对值
 [1] 5 4 3 2 1 0 1 2 3 4 5
> sqrt(x) #求x的平方根
 [1]      NaN      NaN      NaN      NaN      NaN 0.000000
 [7] 1.000000 1.414214 1.732051 2.000000 2.236068
Warning message:
In sqrt(x) : NaNs produced
> sqrt(25)
[1] 5
> log(16,base = 2) #计算一2为底,16的对数
[1] 4
> log(16) #不加base默认是自然对数
[1] 2.772589
> log10(10) #以10为底10的对数
[1] 1
> exp(x) #向量x中以e为底的指数函数
 [1] 6.737947e-03 1.831564e-02 4.978707e-02 1.353353e-01
 [5] 3.678794e-01 1.000000e+00 2.718282e+00 7.389056e+00
 [9] 2.008554e+01 5.459815e+01 1.484132e+02
> ceiling(c(-2.45,3.1415)) #天花板,向上取整
[1] -2  4
> floor(c(-2.45,3.1415)) #地板,向下取整
[1] -3  3
> trunc(c(-2.45,3.1415)) #取整,源自truncate(缩短删减、掐头去尾的意思)
[1] -2  3
> round(c(-2.45,3.1415)) #取整
[1] -2  3
> round(c(-2.45,3.1415),digits = 2) #保留小数点后两位
[1] -2.45  3.14
> signif(c(-2.45,3.1415),digits = 2) #作用类似于round,保留两位有效数字
[1] -2.4  3.1
> sin(x) #三角函数
 [1]  0.9589243  0.7568025 -0.1411200 -0.9092974 -0.8414710
 [6]  0.0000000  0.8414710  0.9092974  0.1411200 -0.7568025
[11] -0.9589243
> cos(x)
 [1]  0.2836622 -0.6536436 -0.9899925 -0.4161468  0.5403023
 [6]  1.0000000  0.5403023 -0.4161468 -0.9899925 -0.6536436
[11]  0.2836622
  • 统计函数
> vec <- c(1:100) #创建一个1到100的向量
> vec
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14
 [15]  15  16  17  18  19  20  21  22  23  24  25  26  27  28
 [29]  29  30  31  32  33  34  35  36  37  38  39  40  41  42
 [43]  43  44  45  46  47  48  49  50  51  52  53  54  55  56
 [57]  57  58  59  60  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80  81  82  83  84
 [85]  85  86  87  88  89  90  91  92  93  94  95  96  97  98
 [99]  99 100
> sum(vec) #对vec求和
[1] 5050
> max(vec) #vec中的最大值
[1] 100
> min(vec) #最小值
[1] 1
> range(vec) #范围
[1]   1 100
> mean(vec) #均值
[1] 50.5
> var(vec) #方差
[1] 841.6667
> round(var(vec),digits = 2) #对方差保留两位小数
[1] 841.67
> round(sd(vec),digits = 2) #sd表示标准差
[1] 29.01
> prod(vec) #连乘的积
[1] 9.332622e+157
> median(vec) #中位数
[1] 50.5
> quantile(vec) #分位数
    0%    25%    50%    75%   100% 
  1.00  25.75  50.50  75.25 100.00 
> quantile(vec,c(0.4,0.5,0.8)) #分别计算vec的四分位数,分位数和八分位数
 40%  50%  80% 
40.6 50.5 80.2 
> t <- c(1,4,3,5,9,7)
> t
[1] 1 4 3 5 9 7
> which.max(t) #返回的是索引值,返回的是最大值的位置
[1] 5
> which.min(t) #此处一定是索引值,这里的1同样是位置
[1] 1
> which(t==7) #索引元素7的位置
[1] 6
> which(t>3) #索引向量t中所有大于3的元素的位置
[1] 2 4 5 6

P20 矩阵与数组

矩阵(Matrix):是一个按照长方阵列排列的复数或实数集合。向量是一维的,而矩阵是二维的,需要有行和列。

在R软件中,矩阵是有维数的向量,这里的矩阵元素可以是数值型,字符型或者逻辑型,但是每个元素必须都拥有相同的模式,这个和向量一致。

常见的内置数据集> iris3> state.77都是常见矩阵,可直接用>heatmap()绘制热图

创建一个矩阵
> x <- 1:20
> x
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20
> m <- matrix(x,nrow = 4,ncol = 5) #nrow表示行(Row),ncol表示列(Column)
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> m <- matrix(1:20,4,5) #也可以省略参数名直接创建
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> m <- matrix(x,nrow = 4,ncol = 6)
Warning message: #行和列一定要满足分配
In matrix(x, nrow = 4, ncol = 6) :
  data length [20] is not a sub-multiple or multiple of the number of columns [6]
> m <- matrix(x,nrow = 4,ncol = 4) #会满足行列要求自动分配
> m
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16
> m <- matrix(x,nrow = 3,ncol = 3) #不能满足分配所以报错
Warning message:
In matrix(x, nrow = 3, ncol = 3) :
  data length [20] is not a sub-multiple or multiple of the number of rows [3]
> m <- matrix(1:20,4) #省略参数也会自动分配,但默认按列分配
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> m <- matrix(1:20,4,byrow = T) #可修改为按行排列,共排四行
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    3    4    5
[2,]    6    7    8    9   10
[3,]   11   12   13   14   15
[4,]   16   17   18   19   20
> m <- matrix(1:20,4,byrow = F) #改为FALSE则按列分布
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> rnames <- c("R1","R2","R3","R4") #创建一个行并给行命名
> rnames
[1] "R1" "R2" "R3" "R4"
> cnames <- c("C1","C2","C3","C4","C5") #创建一个列并给列命名
> cnames
[1] "C1" "C2" "C3" "C4" "C5"
> dimnames(m) <- list(rnames,cnames) #给矩阵的行和列命名
> m
   C1 C2 C3 C4 C5
R1  1  5  9 13 17
R2  2  6 10 14 18
R3  3  7 11 15 19
R4  4  8 12 16 20
> ?dim #dimension的简称,可以显示向量的维数
> dim(x)
NULL
> dim(x) <- c(4,5) #通过添加维数构建向量,4行5列
> x #由向量变成了矩阵
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
数组
R的向量像其他语言中的数组,R的数组其实就是多维的矩阵
> dim(x) <- c(4,5) #将向量写成一个4行5列的数组
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> x <- 1:20
> dim(x) <- c(2,2,5) #定义一个关于向量x的三维数组:一维相当于一行字,二维相当于一页纸,三维相当于一本书,但三维没法直观的在页面表示出来,于是表示成下面的样子
> x
, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

, , 3

     [,1] [,2]
[1,]    9   11
[2,]   10   12

, , 4

     [,1] [,2]
[1,]   13   15
[2,]   14   16

, , 5

     [,1] [,2]
[1,]   17   19
[2,]   18   20


> ?array
> dim1 <- c("A1","A2")
> dim2 <- c("B1","B2","B3")
> dim3 <- C("C1","C2","C3","C4")
Error in C("C1", "C2", "C3", "C4") : 不能把对象解释成因子 #这里上面dim3的c不小心大写了,注意
> 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

#还可以创建字符型和逻辑型的矩阵或数组,也可以创建更多维的数组(复杂,用的不多)
#R内置数据集的经典矩阵 > Titanic
矩阵的索引(如何访问矩阵的数据)
> m <- matrix(1:20,4,5,byrow = T)
> m
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    3    4    5
[2,]    6    7    8    9   10
[3,]   11   12   13   14   15
[4,]   16   17   18   19   20
> m[1,2] #访问第1行第2列的元素  相当于行是i,列是j
[1] 2
> m[1,c(2,3,4)] #访问第1行,第2、3、4位的元素
[1] 2 3 4
> m[c(2:4),c(2,3)] #访问m中第2到4行以及第2到3列的元素,出来一个子集
     [,1] [,2]
[1,]    7    8
[2,]   12   13
[3,]   17   18
> m[2,] #访问第2行的所有元素
[1]  6  7  8  9 10
> m[,2] #访问第2列的所有元素
[1]  2  7 12 17
> m[2] #逗号的重要性,如果没有则是第2行第1个元素
[1] 6
> m[-1,2] #第2列除第一个以外的所有元素
[1]  7 12 17
> dimnames(m)=list(rnames,cnames)
> m
   C1 C2 C3 C4 C5
R1  1  2  3  4  5
R2  6  7  8  9 10
R3 11 12 13 14 15
R4 16 17 18 19 20
> m["R1","C2"] #直接通过坐标访问也可,但注意字符串要加引号
[1] 2

> head(state.x77)
           Population Income Illiteracy Life Exp Murder
Alabama          3615   3624        2.1    69.05   15.1
Alaska            365   6315        1.5    69.31   11.3
Arizona          2212   4530        1.8    70.55    7.8
Arkansas         2110   3378        1.9    70.66   10.1
California      21198   5114        1.1    71.71   10.3
Colorado         2541   4884        0.7    72.06    6.8
           HS Grad Frost   Area
Alabama       41.3    20  50708
Alaska        66.7   152 566432
Arizona       58.1    15 113417
Arkansas      39.9    65  51945
California    62.6    20 156361
Colorado      63.9   166 103766
> state.x77[Income] #名称语句一定要加引号,同时注意大小写
Error: object 'Income' not found
> state.x77["Income"] #矩阵的查找i和j要同时索引
[1] NA
> state.x77[,"Income"] #查找Income这一列的所有值
       Alabama         Alaska        Arizona       Arkansas 
          3624           6315           4530           3378 
    California       Colorado    Connecticut       Delaware 
          5114           4884           5348           4809 
       Florida        Georgia         Hawaii          Idaho 
          4815           4091           4963           4119 
      Illinois        Indiana           Iowa         Kansas 
          5107           4458           4628           4669 
      Kentucky      Louisiana          Maine       Maryland 
          3712           3545           3694           5299 
 Massachusetts       Michigan      Minnesota    Mississippi 
          4755           4751           4675           3098 
      Missouri        Montana       Nebraska         Nevada 
          4254           4347           4508           5149 
 New Hampshire     New Jersey     New Mexico       New York 
          4281           5237           3601           4903 
North Carolina   North Dakota           Ohio       Oklahoma 
          3875           5087           4561           3983 
        Oregon   Pennsylvania   Rhode Island South Carolina 
          4660           4449           4558           3635 
  South Dakota      Tennessee          Texas           Utah 
          4167           3821           4188           4022 
       Vermont       Virginia     Washington  West Virginia 
          3907           4701           4864           3617 
     Wisconsin        Wyoming 
          4468           4566 
> state.x77["Alabama"]
[1] NA
> state.x77["Alabama",] #查找整行
Population     Income Illiteracy   Life Exp     Murder 
   3615.00    3624.00       2.10      69.05      15.10 
   HS Grad      Frost       Area 
     41.30      20.00   50708.00 
矩阵运算
> m
   C1 C2 C3 C4 C5
R1  1  2  3  4  5
R2  6  7  8  9 10
R3 11 12 13 14 15
R4 16 17 18 19 20
> m+1 #m矩阵中每个元素都加1
   C1 C2 C3 C4 C5
R1  2  3  4  5  6
R2  7  8  9 10 11
R3 12 13 14 15 16
R4 17 18 19 20 21
> m*2 #m矩阵中每个元素都乘以2
   C1 C2 C3 C4 C5
R1  2  4  6  8 10
R2 12 14 16 18 20
R3 22 24 26 28 30
R4 32 34 36 38 40
> m+m #每个对应位置的元素相加
   C1 C2 C3 C4 C5
R1  2  4  6  8 10
R2 12 14 16 18 20
R3 22 24 26 28 30
R4 32 34 36 38 40
> n <- matrix(1:20,5,4)
> n
     [,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
> m+n #元素位置不匹配对应无法进行计算,m是4行5列,n是5行4列
Error in m + n : non-conformable arrays

> m[1,]
C1 C2 C3 C4 C5 
 1  2  3  4  5 
> t <- m[1,]
> sum(t) #可以利用赋值的方式对矩阵中某些具体元素进行运算,但这样显然太复杂了,利用公式更简便
[1] 15

> colSums(m) #计算m中每一列的和
C1 C2 C3 C4 C5 
34 38 42 46 50 
> rowSums(m) #计算m中每一行的和
R1 R2 R3 R4 
15 40 65 90 

> n <- matrix(1:9,3,3)
> t <- matrix(2:10,3,3)
> n
     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9
> t
     [,1] [,2] [,3]
[1,]    2    5    8
[2,]    3    6    9
[3,]    4    7   10
> n*t #矩阵的内积
     [,1] [,2] [,3]
[1,]    2   20   56
[2,]    6   30   72
[3,]   12   42   90
> n %*% t #矩阵的外积
     [,1] [,2] [,3]
[1,]   42   78  114
[2,]   51   96  141
[3,]   60  114  168
> diag(n) #计算对角线
[1] 1 5 9
> diag(m)
[1]  1  7 13 19
> t(m) #对m进行转制,将行和列进行互换
   R1 R2 R3 R4
C1  1  6 11 16
C2  2  7 12 17
C3  3  8 13 18
C4  4  9 14 19
C5  5 10 15 20
  C1 C2 C3 C4 C5
R1  1  2  3  4  5
R2  6  7  8  9 10
R3 11 12 13 14 15
R4 16 17 18 19 20

P21 列表

列表顾名思义就是用来存储很多内容的一个集合,在其他编程语言中,列表一般和数组是等同的,但是在R语言中,列表却是R中最复杂的一种数据结构,也是非常重要的一种数据结构。

列表就是一些对象的有序集合。列表中可以存储若干向量、矩阵、数据框,甚至其他列表的组合。

向量与列表

1、在模式上和向量类似,都是一维数据集合。
2、向量只能存储一种数据类型,列表中的对象可以是R中的任何数据结构,甚至列表本身。

> state.center #内置列表
$x
 [1]  -86.7509 -127.2500 -111.6250  -92.2992 -119.7730
 [6] -105.5130  -72.3573  -74.9841  -81.6850  -83.3736
[11] -126.2500 -113.9300  -89.3776  -86.0808  -93.3714
[16]  -98.1156  -84.7674  -92.2724  -68.9801  -76.6459
[21]  -71.5800  -84.6870  -94.6043  -89.8065  -92.5137
[26] -109.3200  -99.5898 -116.8510  -71.3924  -74.2336
[31] -105.9420  -75.1449  -78.4686 -100.0990  -82.5963
[36]  -97.1239 -120.0680  -77.4500  -71.1244  -80.5056
[41]  -99.7238  -86.4560  -98.7857 -111.3300  -72.5450
[46]  -78.2005 -119.7460  -80.6665  -89.9941 -107.2560

$y
 [1] 32.5901 49.2500 34.2192 34.7336 36.5341 38.6777 41.5928
 [8] 38.6777 27.8744 32.3329 31.7500 43.5648 40.0495 40.0495
[15] 41.9358 38.4204 37.3915 30.6181 45.6226 39.2778 42.3645
[22] 43.1361 46.3943 32.6758 38.3347 46.8230 41.3356 39.1063
[29] 43.3934 39.9637 34.4764 43.1361 35.4195 47.2517 40.2210
[36] 35.5053 43.9078 40.9069 41.5928 33.6190 44.3365 35.6767
[43] 31.3897 39.1063 44.2508 37.5630 47.4231 38.4204 44.5937
[50] 43.0504

> a <- 1:20 #向量
> b <- matrix(1:20,4) #矩阵
> c <- mtcars #内置矩阵数据集
> d <- "This is a test list" #字符串
> a;b;c;d
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0

[1] "This is a test list"
> mlist <- list(a,b,c,d)
> mlist
[[1]]
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

[[2]]
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

[[3]]
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0


[[4]]
[1] "This is a test list"

> mlist <- list(first=a,second=b,third=c,forth=d) #创建列表
> mlist
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

$second
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

$third
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0

$forth
[1] "This is a test list"

> mlist[1] #索引列表中某项
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

> mlist[1,4] #加c
Error in mlist[1, 4] : incorrect number of dimensions
> mlist[c(1,4)] #索引第几到第几项
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

$forth
[1] "This is a test list"

> state.center[c("x","y")] #按字符串索引
$x
 [1]  -86.7509 -127.2500 -111.6250  -92.2992 -119.7730
 [6] -105.5130  -72.3573  -74.9841  -81.6850  -83.3736
[11] -126.2500 -113.9300  -89.3776  -86.0808  -93.3714
[16]  -98.1156  -84.7674  -92.2724  -68.9801  -76.6459
[21]  -71.5800  -84.6870  -94.6043  -89.8065  -92.5137
[26] -109.3200  -99.5898 -116.8510  -71.3924  -74.2336
[31] -105.9420  -75.1449  -78.4686 -100.0990  -82.5963
[36]  -97.1239 -120.0680  -77.4500  -71.1244  -80.5056
[41]  -99.7238  -86.4560  -98.7857 -111.3300  -72.5450
[46]  -78.2005 -119.7460  -80.6665  -89.9941 -107.2560

$y
 [1] 32.5901 49.2500 34.2192 34.7336 36.5341 38.6777 41.5928
 [8] 38.6777 27.8744 32.3329 31.7500 43.5648 40.0495 40.0495
[15] 41.9358 38.4204 37.3915 30.6181 45.6226 39.2778 42.3645
[22] 43.1361 46.3943 32.6758 38.3347 46.8230 41.3356 39.1063
[29] 43.3934 39.9637 34.4764 43.1361 35.4195 47.2517 40.2210
[36] 35.5053 43.9078 40.9069 41.5928 33.6190 44.3365 35.6767
[43] 31.3897 39.1063 44.2508 37.5630 47.4231 38.4204 44.5937
[50] 43.0504

> mlist$first #也可直接用美元符$接名字索引
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20
> state.center$x
 [1]  -86.7509 -127.2500 -111.6250  -92.2992 -119.7730
 [6] -105.5130  -72.3573  -74.9841  -81.6850  -83.3736
[11] -126.2500 -113.9300  -89.3776  -86.0808  -93.3714
[16]  -98.1156  -84.7674  -92.2724  -68.9801  -76.6459
[21]  -71.5800  -84.6870  -94.6043  -89.8065  -92.5137
[26] -109.3200  -99.5898 -116.8510  -71.3924  -74.2336
[31] -105.9420  -75.1449  -78.4686 -100.0990  -82.5963
[36]  -97.1239 -120.0680  -77.4500  -71.1244  -80.5056
[41]  -99.7238  -86.4560  -98.7857 -111.3300  -72.5450
[46]  -78.2005 -119.7460  -80.6665  -89.9941 -107.2560
> mlist[1] #一个中括号[ ]索引出的是列表
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

> mlist[[1]] #两个中括号[[ ]]索引出来的是列表中的数据(类型)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20
> class(mlist[1])
[1] "list"
> class(mlist[[1]])
[1] "integer"
> mlist[5] <- iris 
Warning message:
In mlist[5] <- iris :
  number of items to replace is not a multiple of replacement length
> mlist[[5]] <- iris #添加列表项要用双中括号[[ ]]
> mlist
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

$second
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

$third
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0

$forth
[1] "This is a test list"

[[5]]
    Sepal.Length Sepal.Width Petal.Length Petal.Width
1            5.1         3.5          1.4         0.2
2            4.9         3.0          1.4         0.2
3            4.7         3.2          1.3         0.2
4            4.6         3.1          1.5         0.2
5            5.0         3.6          1.4         0.2
6            5.4         3.9          1.7         0.4

       Species
1       setosa
2       setosa
3       setosa
4       setosa
5       setosa
6       setosa


> mlist[-5] #删除列表项用一个中括号
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

$second
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

$third
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0

$forth
[1] "This is a test list"

> mlist[[5]] <- NULL #也可直接NULL置空
> mlist
$first
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
[20] 20

$second
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

$third
                     mpg cyl  disp  hp drat    wt  qsec vs am
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1
Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0
Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0
Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0

$forth
[1] "This is a test list"

P22 数据框

数据框是一种表格式的数据结构。数据框旨在模拟数据集,与其他统计软件例如SAS或者SPSS中的数据集的概念一致。
数据集通常是由数据构成的一个矩形数组,行表示观测,列表示变量。
不同的行业对于数据集的行和列叫法不同。

数据框特点

数据框实际上是一个列表。列表中的元素是向量,这些向量构成数据框的列,每一列必须具有相同的长度,所以数据框是矩形结构,而且数据框的列必须命名。

矩阵与数据框

1、数据框形状上很像矩阵;
2、数据框是比较规则的列表;
3、矩阵必须为同一数据类型;
4、数据框每一列必须同一类型,每一行可以不同。

矩阵所有的数据是同一类型,dataframe只是每一列同一个类型

> state <- data.frame(state.name,state.abb,state.region,state.x77) #将列表和成数据框
> state
                   state.name state.abb  state.region
Alabama               Alabama        AL         South
Alaska                 Alaska        AK          West
Arizona               Arizona        AZ          West
Arkansas             Arkansas        AR         South
California         California        CA          West
Colorado             Colorado        CO          West
> state[c(2,4)] #输出2/3/4列
               state.abb Population
Alabama               AL       3615
Alaska                AK        365
Arizona               AZ       2212
Arkansas              AR       2110
California            CA      21198
> state[,"state.abb"] #输出state.abb这一列的具体元素
 [1] "AL" "AK" "AZ" "AR" "CA" "CO" "CT" "DE" "FL" "GA" "HI"
[12] "ID" "IL" "IN" "IA" "KS" "KY" "LA" "ME" "MD" "MA" "MI"
[23] "MN" "MS" "MO" "MT" "NE" "NV" "NH" "NJ" "NM" "NY" "NC"
[34] "ND" "OH" "OK" "OR" "PA" "RI" "SC" "SD" "TN" "TX" "UT"
[45] "VT" "VA" "WA" "WV" "WI" "WY"
> state[,2] #效果等同于上一句
 [1] "AL" "AK" "AZ" "AR" "CA" "CO" "CT" "DE" "FL" "GA" "HI"
[12] "ID" "IL" "IN" "IA" "KS" "KY" "LA" "ME" "MD" "MA" "MI"
[23] "MN" "MS" "MO" "MT" "NE" "NV" "NH" "NJ" "NM" "NY" "NC"
[34] "ND" "OH" "OK" "OR" "PA" "RI" "SC" "SD" "TN" "TX" "UT"
[45] "VT" "VA" "WA" "WV" "WI" "WY"
> state["Alabama",] #输出Alabama这一行的元素
        state.name state.abb state.region Population Income
Alabama    Alabama        AL        South       3615   3624
        Illiteracy Life.Exp Murder HS.Grad Frost  Area
Alabama        2.1    69.05   15.1    41.3    20 50708
> state$Murder #直接用$索引是更为快捷常用的方式
 [1] 15.1 11.3  7.8 10.1 10.3  6.8  3.1  6.2 10.7 13.9  6.2
[12]  5.3 10.3  7.1  2.3  4.5 10.6 13.2  2.7  8.5  3.3 11.1
[23]  2.3 12.5  9.3  5.0  2.9 11.5  3.3  5.2  9.7 10.9 11.1
[34]  1.4  7.4  6.4  4.2  6.1  2.4 11.6  1.7 11.0 12.2  4.5
[45]  5.5  9.5  4.3  6.7  3.0  6.9

> women
   height weight
1      58    115
2      59    117
3      60    120
4      61    123
5      62    126
6      63    129
7      64    132
8      65    135
9      66    139
10     67    142
11     68    146
12     69    150
13     70    154
14     71    159
15     72    164
> plot(women$height,women$weight) #这种简写对绘图非常有效
> lm(weight ~height,data = women) #使用lm函数求线性回归

Call:
lm(formula = weight ~ height, data = women)

Coefficients:
(Intercept)       height  
     -87.52         3.45  
women散点图

一次使用数据框的多列数据

如果一次要访问数据框的多列数据,每次使用美元符$比较麻烦,还有如下两种方法可供选择
> attach(mtcars) #加载数据框到R搜索目录中
> mpg #直接敲数据框列的名字而不需要使用$
 [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4
 [9] 22.8 19.2 17.8 16.4 17.3 15.2 10.4 10.4
[17] 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3
[25] 19.2 27.3 26.0 30.4 15.8 19.7 15.0 21.4
> hp
 [1] 110 110  93 110 175 105 245  62  95 123
[11] 123 180 180 180 205 215 230  66  52  65
[21]  97 150 150 245 175  66  91 113 264 175
[31] 335 109
> detach(mtcars) #使用完成后可调用detach函数取消加载
> hp
Error: object 'hp' not found

> with(mtcars,(mpg)) #with函数作用与attach相似
 [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4
 [9] 22.8 19.2 17.8 16.4 17.3 15.2 10.4 10.4
[17] 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3
[25] 19.2 27.3 26.0 30.4 15.8 19.7 15.0 21.4

#也可以使用双中括号的方式访问,但返回的是向量

但一般用$查找列数据更加方便清晰

P23 因子

变量分类

  • 名义型变量:城市,所属省份等 孟德尔实验中的豌豆性状
  • 有序型变量:等级,定性(good/better/best)孟德尔实验中的豌豆数量(少中多)
  • 连续型变量:身高,年龄等

因子:在R中名义型变量和有序型变量称为因子,factor。这些分类变量的可能值为一个水平,例如good,better,best,都称为一个level。

由这些水平构成的向量就称为因子。

因子的应用:计算频数/独立性检验/相关性检验/方差分析/主成分分析/因子分析

> mtcars$cyl #取出mtcars中气缸数cyl这一列,cyl这一列可作为因子类型,而因子的level就是4/6/8
 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4
[21] 4 8 8 8 8 4 4 4 8 6 8 4
> table(mtcars$cyl) #table函数计算频数统计

 4  6  8 
11  7 14 
> table(mtcars$am) #am表示手档还是自动档
 0  1 
19 13 

#名义型变量的因子示例
> f <- factor(c("red","red","blue","green","blue","green"))
> f
[1] red   red   blue  green blue  green
Levels: blue green red

#有序型变量的因子示例
> week <-factor(c("Mon","Tue","Wed","Thr","Fri","Sat","Sun")) #定义一个有序行变量week
> week #会出现level,但排序不是我们想要的
[1] Mon Tue Wed Thr Fri Sat Sun
Levels: Fri Mon Sat Sun Thr Tue Wed
> week <- factor(c("Mon","Tue","Wed","Thr","Fri","Sat","Sun"),ordered = T,levels = c( "Mon","Tue","Wed","Thr","Fri","Sat","Sun")) #手动定义level顺序
> week #按照定义排序输出
[1] Mon Tue Wed Thr Fri Sat Sun
7 Levels: Mon < Tue < Wed < Thr < ... < Sun

> fcly <- factor(mtcars$cyl) #从数据集中取出一个因子
> fcly
 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4
[21] 4 8 8 8 8 4 4 4 8 6 8 4
Levels: 4 6 8
> fcly <- mtcars$cyl
> fcly
 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4
[21] 4 8 8 8 8 4 4 4 8 6 8 4
> plot(mtcars$cyl) #散点图
> plot(factor(mtcars$cyl)) #柱状图

image-20201013101738306 image-20201013101820776

plot(mtcars c y l ) ∗ ∗ ∗ ∗ p l o t ( f a c t o r ( m t c a r s cyl)** **plot(factor(mtcars cyl)plot(factor(mtcarscyl))

另一种定义level的方式

> num <- c(1:100)
> num
  [1]   1   2   3   4   5   6   7   8   9  10
 [11]  11  12  13  14  15  16  17  18  19  20
 [21]  21  22  23  24  25  26  27  28  29  30
 [31]  31  32  33  34  35  36  37  38  39  40
 [41]  41  42  43  44  45  46  47  48  49  50
 [51]  51  52  53  54  55  56  57  58  59  60
 [61]  61  62  63  64  65  66  67  68  69  70
 [71]  71  72  73  74  75  76  77  78  79  80
 [81]  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100
> cut(num,c(seq(0,100,10))) #将num向量用cut函数分成(0,10] (10,20] ... (90,100]区间
  [1] (0,10]   (0,10]   (0,10]   (0,10]  
  [5] (0,10]   (0,10]   (0,10]   (0,10]  
  [9] (0,10]   (0,10]   (10,20]  (10,20] 
 [13] (10,20]  (10,20]  (10,20]  (10,20] 
 [17] (10,20]  (10,20]  (10,20]  (10,20] 
 [21] (20,30]  (20,30]  (20,30]  (20,30] 
 [25] (20,30]  (20,30]  (20,30]  (20,30] 
 [29] (20,30]  (20,30]  (30,40]  (30,40] 
 [33] (30,40]  (30,40]  (30,40]  (30,40] 
 [37] (30,40]  (30,40]  (30,40]  (30,40] 
 [41] (40,50]  (40,50]  (40,50]  (40,50] 
 [45] (40,50]  (40,50]  (40,50]  (40,50] 
 [49] (40,50]  (40,50]  (50,60]  (50,60] 
 [53] (50,60]  (50,60]  (50,60]  (50,60] 
 [57] (50,60]  (50,60]  (50,60]  (50,60] 
 [61] (60,70]  (60,70]  (60,70]  (60,70] 
 [65] (60,70]  (60,70]  (60,70]  (60,70] 
 [69] (60,70]  (60,70]  (70,80]  (70,80] 
 [73] (70,80]  (70,80]  (70,80]  (70,80] 
 [77] (70,80]  (70,80]  (70,80]  (70,80] 
 [81] (80,90]  (80,90]  (80,90]  (80,90] 
 [85] (80,90]  (80,90]  (80,90]  (80,90] 
 [89] (80,90]  (80,90]  (90,100] (90,100]
 [93] (90,100] (90,100] (90,100] (90,100]
 [97] (90,100] (90,100] (90,100] (90,100]
10 Levels: (0,10] (10,20] ... (90,100]

P24 缺失数据

  • 完全随机缺失
  • 随机缺失
  • 非随机缺失

为何会出现缺失数据?

1. 机器断电,设备故障导致某个测量值发生丢失。

2. 测量根本没有发生:例如在做问卷调查时,有些问题没有回答,或者有些问题是无效的回答等。

缺失值NA

R 中,NA代表缺失值,是不可用,not available的简称,用来存储缺失信息

这里的缺失值NA表示没有,但注意没有并不一定是0,NA是不知道是多少,也可能是0,也可能是任何值,缺失值和值为0是完全不同的

> 1+NA
[1] NA
> NA==0 #不知道T还是F,所以返回NA
[1] NA
> a <- c(NA,1:49)
> a
 [1] NA  1  2  3  4  5  6  7  8  9 10 11 12
[14] 13 14 15 16 17 18 19 20 21 22 23 24 25
[27] 26 27 28 29 30 31 32 33 34 35 36 37 38
[40] 39 40 41 42 43 44 45 46 47 48 49
> sum(a) #缺失值存在时,在计算中会产生问题
[1] NA
> mean(a)
[1] NA
> ?sum
sum(..., na.rm = FALSE) #na.rm函数计算时跳过缺失值
> sum(a,na.rm=T)
[1] 1225
> mean(a,na.rm = T) #计算平均值时分母是否包含了NA在内的元素个数?
[1] 25
> mean(1:49) #验证得到NA是没被包含的
[1] 25
> is.na(a) #测试数据中是否包含NA,包含位置返回为TURE
 [1]  TRUE FALSE FALSE FALSE FALSE FALSE
 [7] FALSE FALSE FALSE FALSE FALSE FALSE
[13] FALSE FALSE FALSE FALSE FALSE FALSE
[19] FALSE FALSE FALSE FALSE FALSE FALSE
[25] FALSE FALSE FALSE FALSE FALSE FALSE
[31] FALSE FALSE FALSE FALSE FALSE FALSE
[37] FALSE FALSE FALSE FALSE FALSE FALSE
[43] FALSE FALSE FALSE FALSE FALSE FALSE
[49] FALSE FALSE

> sleep
    BodyWgt BrainWgt NonD Dream Sleep  Span
1  6654.000  5712.00   NA    NA   3.3  38.6
2     1.000     6.60  6.3   2.0   8.3   4.5
3     3.385    44.50   NA    NA  12.5  14.0
4     0.920     5.70   NA    NA  16.5    NA

    Gest Pred Exp Danger
1  645.0    3   5      3
2   42.0    3   1      3
3   60.0    1   1      1
4   25.0    5   2      3

> is.na(sleep)
      BodyWgt BrainWgt  NonD Dream Sleep
 [1,]   FALSE    FALSE  TRUE  TRUE FALSE
 [2,]   FALSE    FALSE FALSE FALSE FALSE
 [3,]   FALSE    FALSE  TRUE  TRUE FALSE
 [4,]   FALSE    FALSE  TRUE  TRUE FALSE

       Span  Gest  Pred   Exp Danger
 [1,] FALSE FALSE FALSE FALSE  FALSE
 [2,] FALSE FALSE FALSE FALSE  FALSE
 [3,] FALSE FALSE FALSE FALSE  FALSE
 [4,]  TRUE FALSE FALSE FALSE  FALSE

> rowSums(sleep) #计算行加和
 [1]       NA   77.700       NA       NA

> colSums(sleep) #计算列加和
 BodyWgt BrainWgt     NonD    Dream    Sleep 
12324.98 17554.32       NA       NA       NA 
    Span     Gest     Pred      Exp   Danger 
      NA       NA   178.00   150.00   162.00 

去除缺失值NA

> ?na.omit #删除缺失值
> c <- c(NA,1:20,NA,NA)  #定义一个包含缺失值的向量
> c
 [1] NA  1  2  3  4  5  6  7  8  9 10 11 12
[14] 13 14 15 16 17 18 19 20 NA NA
> d <- na.omit(c) #删除NA后赋值
> d
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13
[14] 14 15 16 17 18 19 20
attr(,"na.action")
[1]  1 22 23
attr(,"class")
[1] "omit"
> is.na(d) #缺失值的部分被删除
 [1] FALSE FALSE FALSE FALSE FALSE FALSE
 [7] FALSE FALSE FALSE FALSE FALSE FALSE
[13] FALSE FALSE FALSE FALSE FALSE FALSE
[19] FALSE FALSE
> sum(d) #能够重新被计算
[1] 210
> mean(d)
[1] 10.5


> na.omit(sleep) #删除sleep数据集中包含NA的行
    BodyWgt BrainWgt NonD Dream Sleep  Span
2     1.000     6.60  6.3   2.0   8.3   4.5
5  2547.000  4603.00  2.1   1.8   3.9  69.0
6    10.550   179.50  9.1   0.7   9.8  27.0
7     0.023     0.30 15.8   3.9  19.7  19.0
8   160.000   169.00  5.2   1.0   6.2  30.4
9     3.300    25.60 10.9   3.6  14.5  28.0
10   52.160   440.00  8.3   1.4   9.7  50.0
11    0.425     6.40 11.0   1.5  12.5   7.0
12  465.000   423.00  3.2   0.7   3.9  30.0
15    0.075     1.20  6.3   2.1   8.4   3.5
16    3.000    25.00  8.6   0.0   8.6  50.0
17    0.785     3.50  6.6   4.1  10.7   6.0
18    0.200     5.00  9.5   1.2  10.7  10.4
22   27.660   115.00  3.3   0.5   3.8  20.0
23    0.120     1.00 11.0   3.4  14.4   3.9
25   85.000   325.00  4.7   1.5   6.2  41.0
27    0.101     4.00 10.4   3.4  13.8   9.0
28    1.040     5.50  7.4   0.8   8.2   7.6
29  521.000   655.00  2.1   0.8   2.9  46.0
32    0.005     0.14  7.7   1.4   9.1   2.6
33    0.010     0.25 17.9   2.0  19.9  24.0
34   62.000  1320.00  6.1   1.9   8.0 100.0
37    0.023     0.40 11.9   1.3  13.2   3.2
38    0.048     0.33 10.8   2.0  12.8   2.0
39    1.700     6.30 13.8   5.6  19.4   5.0
40    3.500    10.80 14.3   3.1  17.4   6.5
42    0.480    15.50 15.2   1.8  17.0  12.0
43   10.000   115.00 10.0   0.9  10.9  20.2
44    1.620    11.40 11.9   1.8  13.7  13.0
45  192.000   180.00  6.5   1.9   8.4  27.0
46    2.500    12.10  7.5   0.9   8.4  18.0
48    0.280     1.90 10.6   2.6  13.2   4.7
49    4.235    50.40  7.4   2.4   9.8   9.8
50    6.800   179.00  8.4   1.2   9.6  29.0
51    0.750    12.30  5.7   0.9   6.6   7.0
52    3.600    21.00  4.9   0.5   5.4   6.0
54   55.500   175.00  3.2   0.6   3.8  20.0
57    0.900     2.60 11.0   2.3  13.3   4.5
58    2.000    12.30  4.9   0.5   5.4   7.5
59    0.104     2.50 13.2   2.6  15.8   2.3
60    4.190    58.00  9.7   0.6  10.3  24.0
61    3.500     3.90 12.8   6.6  19.4   3.0

> length(rowSums(sleep)) #被删除NA行之前的行数
[1] 62
> length(rowSums(na.omit(sleep))) #含有NA的行全被删除,数据缺失严重
[1] 42
image-20201002120232878

其他缺失值

  1. 缺失数据NaN,代表不可能的值;
  2. Inf表示无穷,分为正无穷Inf和负无穷Inf,代表无穷大或无穷小

不同缺失值之间的差别

  1. NA是存在的值,但是不知道是多少;
  2. NaN是不存在的;
  3. Inf存在,是无穷大或无穷小,但是表示不可能的值。
> 1/0
[1] Inf
> -1/0
[1] -Inf
> 0/0
[1] NaN
> is.nan(0/0)
[1] TRUE
> is.infinite(1/0)
[1] TRUE

P25 字符串

正则表达式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WaZUBC5y-1604480800330)(C:%5CUsers%5CZixin%20Liu%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20201002151646472.png)]

统计字符串
> nchar("hello world") #用于统计字符串的字符数
[1] 11
> month.name
 [1] "January"   "February"  "March"    
 [4] "April"     "May"       "June"     
 [7] "July"      "August"    "September"
[10] "October"   "November"  "December" 
> nchar(month.name) #返回的是字符串数
 [1] 7 8 5 5 3 4 4 6 9 7 8 8
> length(month.name) #返回的是元素个数
[1] 12
> nchar(c(2,13,123)) #对数值型向量进行字符串处理
[1] 1 2 3
> paste("Everbody","loves","stata") #合并字符串向量
[1] "Everbody loves stata"
> paste("Everbody","loves","stata",sep="-") #默认空格连接,也可用sep设置
[1] "Everbody-loves-stata"

> names <- c("Moe","Mary","David")
> paste(names,"love stars") #连接方式是元素和元素分别连接
[1] "Moe love stars"   "Mary love stars" 
[3] "David love stars"
> sentence <- c("loves stars","hate sun")
> paste(names,sentence) #如果元素个数不匹配,则按循环原则
[1] "Moe loves stars"   "Mary hate sun"    
[3] "David loves stars"
提取字符串
> month.name
 [1] "January"   "February"  "March"    
 [4] "April"     "May"       "June"     
 [7] "July"      "August"    "September"
[10] "October"   "November"  "December" 
> substr(x=month.name,start = 1,stop = 3) #参数(被提取字符串,起始字符位点,终止字符位点),从1开始
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun"
 [7] "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
> temp <- substr(x=month.name,start = 1,stop = 3)
> toupper(temp) #字符全部大写
 [1] "JAN" "FEB" "MAR" "APR" "MAY" "JUN"
 [7] "JUL" "AUG" "SEP" "OCT" "NOV" "DEC"
> tolower(temp) #字符全部小写
 [1] "jan" "feb" "mar" "apr" "may" "jun"
 [7] "jul" "aug" "sep" "oct" "nov" "dec"
> ?sub #一次替换
> ?gsub #全局替换
> gsub("^(\\w)","\\U\\1",tolower(temp),perl = T) #perl中的正则表达式,首字母大写
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun"
 [7] "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
> gsub("^(\\w)","\\L\\1",tolower(temp),perl = T) #全小写
 [1] "jan" "feb" "mar" "apr" "may" "jun"
 [7] "jul" "aug" "sep" "oct" "nov" "dec"
> gsub("^(\\w)","\\L\\1",toupper(temp),perl = T) #首字母小写
 [1] "jAN" "fEB" "mAR" "aPR" "mAY" "jUN"
 [7] "jUL" "aUG" "sEP" "oCT" "nOV" "dEC"
字符串匹配
> ?grep #在字符串中搜索某种模式,如果fixed=F则支持正则表达式,fixed=T则搜索模式为文本字符串,返回值为匹配的下标
> x <- c("b","A+","AC")
> x
[1] "b"  "A+" "AC"
> grep("A+",x) #在向量x中寻找A+
[1] 2 3
> grep("A+",x,fixed = T) 
[1] 2 #表示与向量中第二个元素匹配上了
> grep("A+",x,fixed = F) #+表示可以匹配1到正无穷个字符A,所以AC也满足条件
[1] 2 3

> ?match #同样用于查找匹配字符串
> match("AC",x)
[1] 3
分割字符串
> ?strsplit
> path <- "/user/local/bin/R"
> strsplit(path,"/") #返回的是列表而不是字符串,因为字符串中可以包含多个子串
[[1]]
[1] ""      "user"  "local" "bin"   "R"  
> strsplit(c(path,path),"/") #当分割多个向量时,以字符串的形式返回会更美观逻辑
[[1]]
[1] ""      "user"  "local" "bin"   "R"    

[[2]]
[1] ""      "user"  "local" "bin"   "R"    

字符串成对组合技巧——笛卡尔积
##有两个字符串向量,我们需要生成他俩组成的所有组合,这里可以用到笛卡尔积

> ?outer
> face <- 1:13
> suit <- c("spades","clubs","hearts","diamonds")
> face
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13
> suit
[1] "spades"   "clubs"    "hearts"  
[4] "diamonds"
> outer(suit,face,FUN = paste) #FUN后接一个函数,我们这里需要连接字符串所以用paste函数
     [,1]         [,2]         [,3]        
[1,] "spades 1"   "spades 2"   "spades 3"  
[2,] "clubs 1"    "clubs 2"    "clubs 3"   
[3,] "hearts 1"   "hearts 2"   "hearts 3"  
[4,] "diamonds 1" "diamonds 2" "diamonds 3"
     [,4]         [,5]         [,6]        
[1,] "spades 4"   "spades 5"   "spades 6"  
[2,] "clubs 4"    "clubs 5"    "clubs 6"   
[3,] "hearts 4"   "hearts 5"   "hearts 6"  
[4,] "diamonds 4" "diamonds 5" "diamonds 6"
     [,7]         [,8]         [,9]        
[1,] "spades 7"   "spades 8"   "spades 9"  
[2,] "clubs 7"    "clubs 8"    "clubs 9"   
[3,] "hearts 7"   "hearts 8"   "hearts 9"  
[4,] "diamonds 7" "diamonds 8" "diamonds 9"
     [,10]         [,11]        
[1,] "spades 10"   "spades 11"  
[2,] "clubs 10"    "clubs 11"   
[3,] "hearts 10"   "hearts 11"  
[4,] "diamonds 10" "diamonds 11"
     [,12]         [,13]        
[1,] "spades 12"   "spades 13"  
[2,] "clubs 12"    "clubs 13"   
[3,] "hearts 12"   "hearts 13"  
[4,] "diamonds 12" "diamonds 13"

P26 日期和时间

时间序列分析

  1. 对时间序列的描述
  2. 利用前面的结果进行预测
> presidents
     Qtr1 Qtr2 Qtr3 Qtr4
1945   NA   87   82   75
1946   63   50   43   32
1947   35   60   54   55
1948   36   39   NA   NA
1949   69   57   57   51
1950   45   37   46   39
1951   36   24   32   23
1952   25   32   NA   32
1953   59   74   75   60
1954   71   61   71   57
1955   71   68   79   73
1956   76   71   67   75
1957   79   62   63   57
1958   60   49   48   52
1959   57   62   61   66
1960   71   62   61   57
1961   72   83   71   78
1962   79   71   62   74
1963   76   64   62   57
1964   80   73   69   69
1965   71   64   69   62
1966   63   46   56   44
1967   44   52   38   46
1968   36   49   35   44
1969   59   65   65   56
1970   66   53   61   52
1971   51   48   54   49
1972   49   61   NA   NA
1973   68   44   40   27
1974   28   25   24   24
> class(presidents)
[1] "ts" #时间序列,time series(seq?)
> presidents$Qtr1 #无法提取,因为不是数据框格式
Error in presidents$Qtr1 : $ operator is invalid for atomic vectors

> airmiles #专门的时间序列格式示例,一般一个时间点对应一个数据
Time Series:
Start = 1937 
End = 1960 
Frequency = 1 
 [1]   412   480   683  1052  1385  1418
 [7]  1634  2178  3362  5948  6109  5981
[13]  6753  8003 10566 12528 14760 16769
[19] 19819 22362 25340 25343 29269 30514

#时间序列中的时间点既可以时日期/年月日/小时/分钟秒

> Sys.Date() #查看当前系统时间
[1] "2020-10-03"
> class(Sys.Date())
[1] "Date"

> a <- "2020-10-03"
> as.Date(a)
[1] "2020-10-03"
> class(a)
[1] "character"
> as.Date(a,format = "%Y-%m-%d") # %Y为四位数年份;%y为年份;%m为两位数月份;%d为两位数日期
[1] "2020-10-03"
> class(as.Date(a,format = "%Y-%m-%d"))
[1] "Date"
> ?strftime #更多时间序列设置可参考这个函数

> seq(as.Date("2020-10-03"),as.Date("2020-10-08"),by=1) #设置时间间隔
[1] "2020-10-03" "2020-10-04"
[3] "2020-10-05" "2020-10-06"
[5] "2020-10-07" "2020-10-08"

> ?ts #设置成时间序列函数
> sales <- round(runif(48,min = 50,max = 100)) #随机生成50-100内的48个随机数,runif生成随机数,round取整数
> sales
 [1]  77  76  84  81  65  53  77  93  96
[10]  60  75  99  83  70  72  90  76  90
[19]  86  98  60  92  87  53  75  59  63
[28]  88 100  64  61  86  98  94  57  99
[37]  61  64  59  59  72  54  99  86  92
[46]  71  86  90
> ts(sales,start = c(2010,5),end = c(2014,4),frequency = 1) #frequency设置成1为以年为单位,12以月份为单位,4以季度为单位,不存在以天为单位,一般时间序列中都不用“天”这个单位
Time Series:
Start = 2014 
End = 2017 
Frequency = 1 
[1] 77 76 84 81
> ts(sales,start = c(2010,5),end = c(2014,4),frequency = 4)
     Qtr1 Qtr2 Qtr3 Qtr4
2011   77   76   84   81
2012   65   53   77   93
2013   96   60   75   99
2014   83   70   72   90
> ts(sales,start = c(2010,5),end = c(2014,4),frequency = 12)
     Jan Feb Mar Apr May Jun Jul Aug Sep
2010                  77  76  84  81  65
2011  96  60  75  99  83  70  72  90  76
2012  60  92  87  53  75  59  63  88 100
2013  98  94  57  99  61  64  59  59  72
2014  92  71  86  90                    
     Oct Nov Dec
2010  53  77  93
2011  90  86  98
2012  64  61  86
2013  54  99  86
2014 

P26 常见错误

1. 定义向量时忘了加c

> x <- (1,2,3)
Error: unexpected ',' in "x <- (1,"

2. 连字符问题

> x <- c(1,2,3)
> x < -5 #尽量使用Alt + -直接生成,避免因为空格的加入而变成逻辑比较符
[1] FALSE FALSE FALSE

3. 括号问题

R中所有函数都要加括号与普通对象进行区分,对函数的所有操作都应在括号里面,尽量使用自动补齐功能避免括号漏掉

> x <- matrix(c(1:20,seq(1,12,3),4,4)
+ )
> x #缺少括号会出现加号
      [,1]
 [1,]    1
 [2,]    2
 [3,]    3
 [4,]    4
 [5,]    5
 [6,]    6
 [7,]    7
 [8,]    8
 [9,]    9
[10,]   10
[11,]   11
[12,]   12
[13,]   13
[14,]   14
[15,]   15
[16,]   16
[17,]   17
[18,]   18
[19,]   19
[20,]   20
[21,]    1
[22,]    4
[23,]    7
[24,]   10
[25,]    4
[26,]    4
> x <- matrix(c(1:20,seq(1,12,3),4),4) #补加括号时要注意位置
Warning message:
In matrix(c(1:20, seq(1, 12, 3), 4), 4) :
  data length [25] is not a sub-multiple or multiple of the number of rows [4]
> x <- matrix(c(1:20,seq(1,12,3)),4,4)
> x
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

3. 字符串的引号问题

  • 字符串一定要加引号,且对数要正确
> x <- c(one,two,three,4,5)
Error: object 'one' not found
> x <- c("one","two","three",4,5)
> x
[1] "one"   "two"   "three" "4"    
[5] "5"  
  • 加载R包的时候一定要加引号
> install.packages(gclus)
Error in install.packages : object 'gclus' not found
> install.packages("gclus")
trying URL 'https://cran.rstudio.com/bin/windows/contrib/4.0/gclus_1.3.2.zip'
Content type 'application/zip' length 416404 bytes (406 KB)
downloaded 406 KB

package ‘gclus’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
	C:\Users\Zixin Liu\AppData\Local\Temp\RtmpEF3l31\downloaded_packages

4. 逗号问题

  • 逗号和元素的对应关系
> x <- c(1,2,3,)
Error in c(1, 2, 3, ) : argument 4 is empty
> x <- c(1,2,3)
  • 逗号在矩阵中的作用
> state.x77[1]
[1] 3615
> state.x77[1,]
Population     Income Illiteracy 
   3615.00    3624.00       2.10 
  Life Exp     Murder    HS Grad 
     69.05      15.10      41.30 
     Frost       Area 
     20.00   50708.00 
> state.x77[,1]
       Alabama         Alaska 
          3615            365 
       Arizona       Arkansas 
          2212           2110 
    California       Colorado 
         21198           2541 
   Connecticut       Delaware 
          3100            579 
       Florida        Georgia 
          8277           4931 
        Hawaii          Idaho 
           868            813 

5. 等号问题

赋值是一个=,等于是两个==

> a=5
> b=8
> a==b
[1] FALSE
> a=b
> a
[1] 8
> b
[1] 8
> a==b
[1] TRUE

6. 路径问题

R中将反斜线/当作转义

> getwd()
[1] "D:/RData/Data Practice"
> setwd("D:\\RData\\Data Practice/") #用两个反斜线或一个正斜线

7. R扩展包问题

跟随老师视频演示时可能出现不一致状况,是因为未使用install.packages(“”)函数加载R包,包名一定记得加引号

8. 优先级问题

> x <- 1+2*3^4>5 || 15%%3>2
> x
[1] TRUE

#如果不确定优先级顺序,则多使用括号

9. 严格区分大小写

> help()
> HELP()
Error in HELP() : could not find function "HELP"

10. 学会看报错信息,擅用搜索引擎解决问题


P28 获取数据

R获取数据的三种途径:

  1. 利用键盘输入数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4svCUl9W-1604480800333)(https://i.loli.net/2020/10/09/ZtnVg19oTGmS5sO.png)]

  • 直接手动输入
> patientID <- c(1,2,3,4)
> admdate <- c("10/15/2009","11/01/2009","10/21/2009","10/28/2009")
> age <- c(25,34,28,52)
> status <- c("Poor","Improved","Excellent","Poor")
> data <- data.frame(patientID,admdate,age,diabetes,status)
> data
  patientID    admdate age diabetes    status
1         1 10/15/2009  25    Type1      Poor
2         2 11/01/2009  34    Type2  Improved
3         3 10/21/2009  28    Type1 Excellent
4         4 10/28/2009  52    Type1      Poor
  • 调用数据编辑器
> ?edit
> data2 <- data.frame(patientID=character(0),admdate=character(0),age=numeric(),diabetes=character(),status=character())
> data2 <- edit(data2) #会弹出一个编辑框,直接在表格里输入
> data2
  patientID    admdate age diabetes status
1         1 10/15/2009  25    Type1   Poor
2         2       <NA>  NA     <NA>   <NA>
3         3       <NA>  NA     <NA>   <NA>
4         4       <NA>  NA     <NA>   <NA>
> fix(data2) #可使用fix函数直接修改保存

  1. 通过读取存储在外部文件上的数据

    R几乎可以读取所有主流的数据文件格式,包括Excel,SPSS,SAS等软件的文件格式,可利用R扩展包读取

    但为了有效的使用R进行统计,数据之前一般要经过python或者perl进行预处理

  2. 通过访问数据库系统来获取数据

  • R提供了多种面向数据库管理系统的接口,如SQL等

  • 通过ODBC(Open Database Connectivity 开放数据库连接)访问数据库

  • 加载RODBC包可以使R与通过RODBC连接的SQL数据库进行双向通信,不仅可以用R读取数据库的内容,也可以将R处理的结果写入数据库内

> install.packages("RODBC")
trying URL 'https://cran.rstudio.com/bin/windows/contrib/4.0/RODBC_1.3-17.zip'
Content type 'application/zip' length 878540 bytes (857 KB)
downloaded 857 KB

package ‘RODBC’ successfully unpacked and MD5 sums checked

The downloaded binary packages are in
	C:\Users\Zixin Liu\AppData\Local\Temp\RtmpEF3l31\downloaded_packages
  • 安装DPI包可以实现通过驱动程序连接至数据库 ,该包为不同的数据库提供了一种通用的语法,要使用某个数据库,需要下载其与DPI相连的包才能使用,这些包为数据库原始的驱动程序提供了API接口

P29 读取文件(一)

  • 在工作目录下直接读取
> read.table("input.txt") #读取的文件一定要在工作目录下且需要加引号
    Ozone Solar.R Wind Temp Month Day
1      41     190  7.4   67     5   1
2      36     118  8.0   72     5   2
3      12     149 12.6   74     5   3
4      18     313 11.5   62     5   4
5      NA      NA 14.3   56     5   5
6      28      NA 14.9   66     5   6
7      23     299  8.6   65     5   7
8      19      99 13.8   59     5   8
9       8      19 20.1   61     5   9
10     NA     194  8.6   69     5  10
119    NA     153  5.7   88     8  27
120    76     203  9.7   97     8  28
121   118     225  2.3   94     8  29
145    23      14  9.2   71     9  22
146    36     139 10.3   81     9  23
147     7      49 10.3   69     9  24
148    14      20 16.6   63     9  25
149    30     193  6.9   70     9  26
150    NA     145 13.2   77     9  27
151    14     191 14.3   75     9  28
152    18     131  8.0   76     9  29
153    20     223 11.5   68     9  30
> x <- read.table("input.txt")
> head(x) #当文件表格太长时只显示头部,默认是6行
  Ozone Solar.R Wind Temp Month Day
1    41     190  7.4   67     5   1
2    36     118  8.0   72     5   2
3    12     149 12.6   74     5   3
4    18     313 11.5   62     5   4
5    NA      NA 14.3   56     5   5
6    28      NA 14.9   66     5   6
> tail(x) #只显示尾部
    Ozone Solar.R Wind Temp Month Day
148    14      20 16.6   63     9  25
149    30     193  6.9   70     9  26
150    NA     145 13.2   77     9  27
151    14     191 14.3   75     9  28
152    18     131  8.0   76     9  29
153    20     223 11.5   68     9  30
> head(x,n=10) #可以手动修改显示行数
   Ozone Solar.R Wind Temp Month Day
1     41     190  7.4   67     5   1
2     36     118  8.0   72     5   2
3     12     149 12.6   74     5   3
4     18     313 11.5   62     5   4
5     NA      NA 14.3   56     5   5
6     28      NA 14.9   66     5   6
7     23     299  8.6   65     5   7
8     19      99 13.8   59     5   8
9      8      19 20.1   61     5   9
10    NA     194  8.6   69     5  10

  • 读取需要分列的文件(分列符一般有“,” “空格” “-”等)
> x <- read.table("D:/RData/input.csv")
> x
                                                                    V2
1  ,"mpg","cyl","disp","hp","drat","wt","qsec","vs","am","gear","carb"
2                                 ,21,6,160,110,3.9,2.62,16.46,0,1,4,4
3                                ,21,6,160,110,3.9,2.875,17.02,0,1,4,4
4                               ,22.8,4,108,93,3.85,2.32,18.61,1,1,4,1
5                             ,21.4,6,258,110,3.08,3.215,19.44,1,0,3,1
6                              ,18.7,8,360,175,3.15,3.44,17.02,0,0,3,2
7                              ,18.1,6,225,105,2.76,3.46,20.22,1,0,3,1
8                              ,14.3,8,360,245,3.21,3.57,15.84,0,0,3,4
9                                ,24.4,4,146.7,62,3.69,3.19,20,1,0,4,2
10                             ,22.8,4,140.8,95,3.92,3.15,22.9,1,0,4,2
11                            ,19.2,6,167.6,123,3.92,3.44,18.3,1,0,4,4
12                            ,17.8,6,167.6,123,3.92,3.44,18.9,1,0,4,4
13                            ,16.4,8,275.8,180,3.07,4.07,17.4,0,0,3,3
14                            ,17.3,8,275.8,180,3.07,3.73,17.6,0,0,3,3

##若直接读取则会因为逗号间隔未被分开而显得很乱,不好阅读

> x <- read.table("D:/RData/input.csv",sep=",") #可使用sep识别间隔符进行分列
> x
                    V1   V2  V3    V4  V5   V6    V7    V8 V9 V10  V11  V12
1                       mpg cyl  disp  hp drat    wt  qsec vs  am gear carb
2            Mazda RX4   21   6   160 110  3.9  2.62 16.46  0   1    4    4
3        Mazda RX4 Wag   21   6   160 110  3.9 2.875 17.02  0   1    4    4
4           Datsun 710 22.8   4   108  93 3.85  2.32 18.61  1   1    4    1
5       Hornet 4 Drive 21.4   6   258 110 3.08 3.215 19.44  1   0    3    1
6    Hornet Sportabout 18.7   8   360 175 3.15  3.44 17.02  0   0    3    2
7              Valiant 18.1   6   225 105 2.76  3.46 20.22  1   0    3    1
8           Duster 360 14.3   8   360 245 3.21  3.57 15.84  0   0    3    4

# Windows系统下直接用记事本打开要导入的数据文件可找到间隔符
#`header`函数的作用是是否将数据表格第一行的字符设置为变量名称,而不是当成具体的值来处理
> x <- read.table("D:/RData/input.csv",sep=",",header = TRUE)
> head(x)
                  X  mpg cyl disp  hp drat    wt  qsec vs am gear carb
1         Mazda RX4 21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
2     Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
3        Datsun 710 22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
4    Hornet 4 Drive 21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
5 Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
6           Valiant 18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

##跳过不想读取的数据使用`skip`函数
> x <- read.table("D:/RData/input 1.txt",sep=" ",header = TRUE,skip = 5) #从第6行开始读取
> x
    Ozone Solar.R Wind Temp Month Day
1      41     190  7.4   67     5   1
2      36     118  8.0   72     5   2
3      12     149 12.6   74     5   3
4      18     313 11.5   62     5   4
5      NA      NA 14.3   56     5   5
6      28      NA 14.9   66     5   6
7      23     299  8.6   65     5   7
8      19      99 13.8   59     5   8

## skip控制从哪开始读,nrow控制读多少行,组合使用可以读取数据中任何部分
> x <- read.table("D:/RData/input 1.txt",sep=" ",header = TRUE,skip = 50,nrows = 5)
> x
  X45 NA. X332 X13.8 X80 X6 X14
1  46  NA  322  11.5  79  6  15
2  47  21  191  14.9  77  6  16
3  48  37  284  20.7  72  6  17
4  49  20   37   9.2  65  6  18
5  50  12  120  11.5  73  6  19

  • 使用na.string函数将原始数据中用于表示缺失值的其他符号为NA
  • stringAsFactors控制读入字符串是否转化为因子:在R中会将数字识别成数值型格式,将字符串转换成因子类型,如果不需要时可以用该函数设置成FALSE
  • >?read.table的帮助说明还有其他可以读取的格式供查阅(如csv【默认用逗号,分割】/delim【默认用制表符分隔】等)

P30 读取文件(二)

  • 读取在线的文件
> x <- read.table("www.网址.com",sep=" ",header = TRUE)
##这里必须是可供下载的网址,如果是嵌入网页中的表格,那么应该是读取html文件
  • 如何读取非文本文件

网页中一般包含大量内容,可以使用grepgsub等函数进行筛选

#如果只读取网页中的表格数据,可使用`which`函数

>readHTMLTable("https://en.wikipedia.org/wiki/World_population",which=3) #读取该网页的第三个表格
Error in (function (classes, fdef, mtable)  : 
  unable to find an inherited method for function ‘readHTMLTable’ for signature ‘"NULL"’
In addition: Warning message:
XML content does not seem to be XML: '' 
          
# 网页的表格格式不一定能被正确读取出来
  • 读取统计软件格式的文件
> help(package="foreign")

#包含如下多种格式,read是读取,write是写入
data.restore	Read an S3 Binary or data.dump File
lookup.xport	Lookup Information on a SAS XPORT Format Library
read.arff	    Read Data from ARFF Files
read.dbf	    Read a DBF File
read.dta		Read Stata Binary Files
read.epiinfo	Read Epi Info Data Files
read.mtp		Read a Minitab Portable Worksheet
read.octave		Read Octave Text Data Files
read.S			Read an S3 Binary or data.dump File
read.spss		Read an SPSS Data File
read.ssd		Obtain a Data Frame from a SAS Permanent Dataset, via read.xport
read.systat		Obtain a Data Frame from a Systat File
read.xport		Read a SAS XPORT Format Library
write.arff		Write Data into ARFF Files
write.dbf		Write a DBF File
write.dta		Write Files in Stata Binary Format
write.foreign	Write Text Files and Code to Read Them

##若上述格式中仍然没有匹配的,可以另存为文本文档进行读取,或搜索相匹配的R包
> RSiteSearch("Matlab")
檢索查詢疑問已被提交给http://search.r-project.org
计算结果应很快就在瀏覽器里打开
  • 直接从粘贴板复制读取
> readClipboard() #可直接复制后输入该函数
[1] "排名\t城市别\t所属省\t金额(亿元)\t增长率\t人口(万)"
[2] "1\t上海\t直辖市\t25300\t6.80%\t2425.00 "               
[3] "2\t北京\t直辖市\t23000\t6.70%\t2168.00 "               
[4] "3\t广州\t广东省\t18100\t8.30%\t1667.00 "               
[5] "4\t深圳\t广东省\t17500\t8.90%\t1077.00 "               
[6] "5\t天津\t直辖市\t17200\t9.40%\t1516.00 "               
[7] "6\t重庆\t直辖市\t16100\t11.00%\t3001.00 "   

> x <- read.table("clipboard",header = T,sep = "\t")
> x
  排名 城市别 所属省 金额.亿元. 增长率 人口.万.
1    1   上海 直辖市      25300  6.80%     2425
2    2   北京 直辖市      23000  6.70%     2168
3    3   广州 广东省      18100  8.30%     1667
4    4   深圳 广东省      17500  8.90%     1077
5    5   天津 直辖市      17200  9.40%     1516
6    6   重庆 直辖市      16100 11.00%     3001

  • 直接读取压缩文件
> read.table(gzfile("input.txt.gz")) #gzfile不用解压缩可直接读取
                     X  mpg cyl  disp  hp drat    wt  qsec vs am gear carb
1            Mazda RX4 21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
2        Mazda RX4 Wag 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
3           Datsun 710 22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1

##注意读取的文件得在工作目录下
  • 读取不规则的文件
> ?readline  #可以基于每一行甚至每一单元读取文件
> readLines("input.csv",n=5) #n限制读入的最大行数
[1] "\"\",\"mpg\",\"cyl\",\"disp\",\"hp\",\"drat\",\"wt\",\"qsec\",\"vs\",\"am\",\"gear\",\"carb\""
[2] "\"Mazda RX4\",21,6,160,110,3.9,2.62,16.46,0,1,4,4"                                            
[3] "\"Mazda RX4 Wag\",21,6,160,110,3.9,2.875,17.02,0,1,4,4"                                       
[4] "\"Datsun 710\",22.8,4,108,93,3.85,2.32,18.61,1,1,4,1"                                         
[5] "\"Hornet 4 Drive\",21.4,6,258,110,3.08,3.215,19.44,1,0,3,1"   

> ?scan #每次读取一个单元,并根据指令处理;第一个参数为文件地址,第二个参数“what”用来描述scan所希望描述的文件单元;scan可重复执行制定模式,直到读取所有需要数据

> scan("scan.txt",what = list(character(3),numeric(0),numeric(0))) #表示读取每一行头3个字符串元素,然后再读取一个数值,然后再读取另外一个数值,两个numeric交替处理,0表示直到行尾
Read 20 records
[[1]]
 [1] "one"  "four" "one"  "four" "one"  "four"
 [7] "one"  "four" "one"  "four" "one"  "four"
[13] "one"  "four" "one"  "four" "one"  "four"
[19] "one"  "four"

[[2]]
 [1] 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5

[[3]]
 [1] 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6

> scan("scan.txt",what = list(X1=character(3),X2=numeric(2),X3=numeric(2))) #给变量命名
Read 20 records
$X1
 [1] "one"  "four" "one"  "four" "one"  "four"
 [7] "one"  "four" "one"  "four" "one"  "four"
[13] "one"  "four" "one"  "four" "one"  "four"
[19] "one"  "four"

$X2
 [1] 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5 2 5

$X3
 [1] 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6 3 6

scan读取的示例文件如下图

image-20201009165654290

P31 写入文件

  • 文件写入与格式转换
> ?write #与read系列函数相对应,存储为纯文本文件

> x <- rivers
> cat(x) #Concatenate and Print,连接和打印
735 320 325 392 524 450 1459 135 465 600 330 336 280 315 870 906 202 329 290 1000 600 505 1450 840 1243 890 350 407 286 280 525 720 390 250 327 230 265 850 210 630 260 230 360 730 600 306 390 420 291 710 340 217 281 352 259 250 470 680 570 350 300 560 900 625 332 2348 1171 3710 2315 2533 780 280 410 460 260 255 431 350 760 618 338 981 1306 500 696 605 250 411 1054 735 233 435 490 310 460 383 375 1270 545 445 1885 380 300 380 377 425 276 210 800 420 350 360 538 1100 1205 314 237 610 360 540 1038 424 310 300 444 301 268 620 215 652 900 525 246 360 529 500 720 270 430 671 1770
> write(x,file="x.txt") #会在工作目录下生成对应文件
> getwd() #当前工作目录
[1] "D:/RData"
## 可以在写入文件时添加完整的路径目录名,但必须是已存在的目录,R不会创建新目录

> ?write.table #数据框使用该函数
> ?write.csv #存为csv格式文件

#文件格式的转换
> read.table("input.txt",header = TRUE)
    Ozone Solar.R Wind Temp Month Day
1      41     190  7.4   67     5   1
2      36     118  8.0   72     5   2
3      12     149 12.6   74     5   3
4      18     313 11.5   62     5   4
5      NA      NA 14.3   56     5   5
……
151    14     191 14.3   75     9  28
152    18     131  8.0   76     9  29
153    20     223 11.5   68     9  30
> write.table(x,file = "D:/RData/Data Practice/newfile.txt")

> write.table (x,file=newfile.csv,sep="\t") #设置分隔符
  • R写入文件首列序号(行号)的删除

    用R进行数据写入时,会在头一列自动生成顺序编号(行号),再读写一次则又会多一行行号,反复读写则会多次添加带来不便,可使用如下方法解决

##使用row.names函数
> write.table(x,file = "D:/RData/Data Practice/newfile.txt",row.names = FALSE)

##使用负索引
  • R写入文件双引号的删除

    R写入文件时字符串向量会默认添加双引号,如果不想要可使用quote = FALSE函数删除

  • 缺失值NA代替

    缺失值默认用NA代替,可使用na="NA"调整缺失值的显示

  • 同名文件的覆盖与添加

    如果目录下存在同名文件,R写入时会直接覆盖(没有提示),如果不想覆盖而是继续添加可使用append=TURE添加到原文件结尾,append=FALSE则是清空原文件

  • 写入压缩文件

> write.table(mtcars,gzfile("newfile.txt.gz"))
##文件名记得加上对应的压缩格式
  • 写入或读取其他格式文件

    R更多支持的文件格式查看> help(package="foreign")


P32 读写Excel文件

  • 使用read函数读取csv格式文件(方便,无需配置环境,但一次只能处理一个sheet)
  • 在Excel中复制后,使用剪切板readClipboard()读取,或者使用> read.table("clipboard",header = T,sep = "\t")读取
  • 加载openxlsx`R包直接读取
> install.packages("openxlsx")
also installing the dependencies ‘zip’, ‘stringi’
……
The downloaded binary packages are in
	C:\Users\Lin\AppData\Local\Temp\RtmpgFVKJE\downloaded_packages
> library(openxlsx)
> cars32 <- read.xlsx("mtcars.xlsx")
> cars32
                    X1  mpg cyl  disp  hp drat    wt  qsec vs am gear carb
1            Mazda RX4 21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
2        Mazda RX4 Wag 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
3           Datsun 710 22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
  • 配置java环境后,可使用XLConnect这个R包或者xlsx这个R包进行读写
install.packages("XLConnect")
library(XLConnect)
?loadWorkbook
#Two step Read Excel File
ex <- loadWorkbook ("data.xlsx")
edata <- readWorksheet(ex,1)
head(edata)
edata <- readWorksheet(ex,1,startRow=0,starCol=0,endRow=50,endCol=3)

#One step Read Excel File
readWorksheetFromFile ("data.xlsx",1,startRow=0,starCol=0,
                       endRow=50,endCol=3,header=TRUE)
#Four step Wtire Excel File
wb <- loadWorkbook("file.xlsx",create=TRUE)
createSheet(wb,"Sheet 1")
writeWorksheet(wb,data=mtcars,sheet = "Sheet 1")
saveWorkbook()

#One step Wtire Excel File
writeWorksheetToFile("file.xlsx",data = mtcars,sheet = "Sheet 1")
vignette("XLConnect")




#Packages xlsx
install.packages("xlsx")
library(xlsx)
rdata <- read.xlsx("data.xlsx",n=1,startRow = 1,endRow = 100)
write.xlsx(rdata,file = "rdata.xlsx",sheetName = "Sheet 1",append = F)
help(package="xlsx")

P33 读写R格式文件

  • .RDS(单个R对象)和.RDATA(多个R对象)
  • 优势:R会对存储为内部文件格式的数据进行自动压缩处理,并且会存储所有与待存储对象相关的R元数据。如果数据中包含了因子,日期和时间或者类的属性等信息
  • 劣势:只能在R中打开,共享者也许安装R软件
## 存储RDS格式文件
> head(iris)
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa
> saveRDS(iris,file = "iris.RDS")
> x <- readRDS("iris.RDS")
> x
    Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
1            5.1         3.5          1.4         0.2     setosa
2            4.9         3.0          1.4         0.2     setosa
3            4.7         3.2          1.3         0.2     setosa
4            4.6         3.1          1.5         0.2     setosa
5            5.0         3.6          1.4         0.2     setosa
6            5.4         3.9          1.7         0.4     setosa
  • .RDATA文件类似于PS里的.psd文件,保存着项目进度,能保存所有对象但无法保存绘制出来的图形 ,图形另存可参见 图片另存
  • 加载.RDATA文件的方法
    • 直接双击文件打开
    • 从RStudio的project处引入(使用RStudio的project可另存为包含形式更为丰富的文件)
    • 使用如load(file = "C:/Users/wangtong/Desktop/RData/Ch02.R")函数直接打开,但注意:如果在已有工作簿中打开,之前已有的对象如果和即将要加载进来的对象出现重复,load函数不会做区分,建议先查看右上角的环境窗口查找已有变量
  • 保存多个对象示例save(iris,iris3,file = "iris.Rdata"),默认存于当前工作目录
  • 保存当前工作空间中所有对象可使用save.image()

P34 数据转换(一)

利用R进行数据分析的核心部分,分析更多的交给已有的R包或者代码,最关键的就是原始数据的处理,主要包括数据结构的变化:添加/删除/修改/排序等操作。Excel分析靠鼠标,R靠代码指令。

矩阵转换为数据框
> install.packages("openxlsx")
……
> library(openxlsx)
> cars32 <- read.xlsx("mtcars.xlsx")
> cars32
                    X1  mpg cyl  disp  hp drat    wt  qsec vs am gear carb
1            Mazda RX4 21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
2        Mazda RX4 Wag 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
3           Datsun 710 22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
4       Hornet 4 Drive 21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
5    Hornet Sportabout 18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
6              Valiant 18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
> is.data.frame(cars32) #判断是否为数据框类型,同时is函数还可判断其他多种类型数据
[1] TRUE
> is.data.frame(state.x77)
[1] FALSE
> dstate.x77 <- as.data.frame(state.x77) #使用as函数进行矩阵到数据框的强制转换
> is.data.frame(dstate.x77)
[1] TRUE


数据框转换为矩阵

数据框转换成矩阵麻烦一些,因为矩阵只能是同为数值型或同为字符串型的数据,数据框没有该限制

> data.frame(state.region,state.x77) #创建一个包含数值和字符串类型的数据框
                state.region Population Income Illiteracy Life.Exp Murder HS.Grad Frost   Area
Alabama                South       3615   3624        2.1    69.05   15.1    41.3    20  50708
Alaska                  West        365   6315        1.5    69.31   11.3    66.7   152 566432
Arizona                 West       2212   4530        1.8    70.55    7.8    58.1    15 113417
Arkansas               South       2110   3378        1.9    70.66   10.1    39.9    65  51945
> as.matrix(data.frame(state.region,state.x77)) #强制转换为矩阵,则都被转换为字符串类型
               state.region    Population Income Illiteracy Life.Exp Murder HS.Grad Frost Area    
Alabama        "South"         " 3615"    "3624" "2.1"      "69.05"  "15.1" "41.3"  " 20" " 50708"
Alaska         "West"          "  365"    "6315" "1.5"      "69.31"  "11.3" "66.7"  "152" "566432"
Arizona        "West"          " 2212"    "4530" "1.8"      "70.55"  " 7.8" "58.1"  " 15" "113417"
Arkansas       "South"         " 2110"    "3378" "1.9"      "70.66"  "10.1" "39.9"  " 65" " 51945"
is判断类型和as转换类型
> methods(is)
 [1] is.array                is.atomic              
 [3] is.call                 is.character           
 [5] is.complex              is.data.frame          
 [7] is.double               is.element             
 [9] is.empty.model          is.environment         
[11] is.expression           is.factor              
[13] is.finite               is.function            
[15] is.infinite             is.integer             
[17] is.language             is.leaf                
[19] is.list                 is.loaded              
[21] is.logical              is.matrix              
[23] is.mts                  is.na                  
[25] is.na.data.frame        is.na.numeric_version  
[27] is.na.POSIXlt           is.na<-                
[29] is.na<-.default         is.na<-.factor         
[31] is.na<-.numeric_version is.name                
[33] is.nan                  is.null                
[35] is.numeric              is.numeric.Date        
[37] is.numeric.difftime     is.numeric.POSIXt      
[39] is.numeric_version      is.object              
[41] is.ordered              is.package_version     
[43] is.pairlist             is.primitive           
[45] is.qr                   is.R                   
[47] is.raster               is.raw                 
[49] is.recursive            is.relistable          
[51] is.single               is.stepfun             
[53] is.symbol               is.table               
[55] is.ts                   is.tskernel            
[57] is.unsorted             is.vector              
see '?methods' for accessing help and source code
> methods(as)
  [1] as.array                      as.array.default              as.call                       as.character                  as.character.condition       
  [6] as.character.Date             as.character.default          as.character.error            as.character.factor           as.character.hexmode         
 [11] as.character.numeric_version  as.character.octmode          as.character.POSIXt           as.character.srcref           as.complex                   
 [16] as.data.frame                 as.data.frame.array           as.data.frame.AsIs            as.data.frame.character       as.data.frame.complex        
 [21] as.data.frame.data.frame      as.data.frame.Date            as.data.frame.default         as.data.frame.difftime        as.data.frame.factor         
 [26] as.data.frame.integer         as.data.frame.list            as.data.frame.logical         as.data.frame.matrix          as.data.frame.model.matrix   
 [31] as.data.frame.noquote         as.data.frame.numeric         as.data.frame.numeric_version as.data.frame.ordered         as.data.frame.POSIXct        
 [36] as.data.frame.POSIXlt         as.data.frame.raw             as.data.frame.table           as.data.frame.ts              as.data.frame.vector         
 [41] as.Date                       as.Date.character             as.Date.default               as.Date.factor                as.Date.numeric              
 [46] as.Date.POSIXct               as.Date.POSIXlt               as.dendrogram                 as.difftime                   as.dist                      
 [51] as.double                     as.double.difftime            as.double.POSIXlt             as.environment                as.expression                
 [56] as.expression.default         as.factor                     as.formula                    as.function                   as.function.default          
 [61] as.graphicsAnnot              as.hclust                     as.hexmode                    as.integer                    as.list                      
 [66] as.list.data.frame            as.list.Date                  as.list.default               as.list.difftime              as.list.environment          
 [71] as.list.factor                as.list.function              as.list.numeric_version       as.list.POSIXct               as.list.POSIXlt              
 [76] as.logical                    as.logical.factor             as.matrix                     as.matrix.data.frame          as.matrix.default            
 [81] as.matrix.noquote             as.matrix.POSIXlt             as.name                       as.null                       as.null.default              
 [86] as.numeric                    as.numeric_version            as.octmode                    as.ordered                    as.package_version           
 [91] as.pairlist                   as.person                     as.personList                 as.POSIXct                    as.POSIXct.Date              
 [96] as.POSIXct.default            as.POSIXct.numeric            as.POSIXct.POSIXlt            as.POSIXlt                    as.POSIXlt.character         
[101] as.POSIXlt.Date               as.POSIXlt.default            as.POSIXlt.factor             as.POSIXlt.numeric            as.POSIXlt.POSIXct           
[106] as.qr                         as.raster                     as.raw                        as.relistable                 as.roman                     
[111] as.single                     as.single.default             as.stepfun                    as.symbol                     as.table                     
[116] as.table.default              as.ts                         as.vector                     as.vector.factor             
see '?methods' for accessing help and source code
向量转换为其他类型
> x <- state.abb #创建一个字符串类型的向量
> x
 [1] "AL" "AK" "AZ" "AR" "CA" "CO" "CT" "DE" "FL" "GA" "HI"
[12] "ID" "IL" "IN" "IA" "KS" "KY" "LA" "ME" "MD" "MA" "MI"
[23] "MN" "MS" "MO" "MT" "NE" "NV" "NH" "NJ" "NM" "NY" "NC"
[34] "ND" "OH" "OK" "OR" "PA" "RI" "SC" "SD" "TN" "TX" "UT"
[45] "VT" "VA" "WA" "WV" "WI" "WY"
> dim(x) <- c(5,10) #定义一个二维空间变成一个5行10列的矩阵
> x
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] "AL" "CO" "HI" "KS" "MA" "MT" "NM" "OK" "SD" "VA" 
[2,] "AK" "CT" "ID" "KY" "MI" "NE" "NY" "OR" "TN" "WA" 
[3,] "AZ" "DE" "IL" "LA" "MN" "NV" "NC" "PA" "TX" "WV" 
[4,] "AR" "FL" "IN" "ME" "MS" "NH" "ND" "RI" "UT" "WI" 
[5,] "CA" "GA" "IA" "MD" "MO" "NJ" "OH" "SC" "VT" "WY" 
> x <- state.abb
> as.factor(x) #变成因子类型
 [1] AL AK AZ AR CA CO CT DE FL GA HI ID IL IN IA KS KY LA ME
[20] MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA
[39] RI SC SD TN TX UT VT VA WA WV WI WY
50 Levels: AK AL AR AZ CA CO CT DE FL GA HI IA ID IL ... WY
> as.list(x) #转换成列表
[[1]]
[1] "AL"

[[2]]
[1] "AK"

[[3]]
[1] "AZ"

[[4]]
[1] "AR"

> class(state.region)
[1] "factor"
> class(state.x77)
[1] "matrix" "array" 
> class(x)
[1] "character"
> state <- data.frame(x,state.region,state.x77) #创建一个包含多种数据类型的数据框
> state$Income #提取出某一列的值
 [1] 3624 6315 4530 3378 5114 4884 5348 4809 4815 4091 4963
[12] 4119 5107 4458 4628 4669 3712 3545 3694 5299 4755 4751
[23] 4675 3098 4254 4347 4508 5149 4281 5237 3601 4903 3875
[34] 5087 4561 3983 4660 4449 4558 3635 4167 3821 4188 4022
[45] 3907 4701 4864 3617 4468 4566
> state["Nevada",] #提取出具体某一行,一定记得加逗号,!!!!
        x state.region Population Income Illiteracy Life.Exp Murder HS.Grad Frost   Area
Nevada NV         West        590   5149        0.5    69.03   11.5    65.2   188 109889
> is.data.frame(state["Nevada",]) #每一行提取出来也是单独的数据框,且包含列名
[1] TRUE
> y <- state["Nevada",]
> unname(y) #去除列名
                                                      
Nevada NV West 590 5149 0.5 69.03 11.5 65.2 188 109889
> unlist(y) #适用于将列表结构转换成向量
           x state.region   Population       Income   Illiteracy     Life.Exp       Murder      HS.Grad        Frost         Area 
        "NV"          "4"        "590"       "5149"        "0.5"      "69.03"       "11.5"       "65.2"        "188"     "109889" 
> class(unlist(y))
[1] "character"
> as.vector(y) #强制转换成向量,元素所有原本属性都被删除
        x state.region Population Income Illiteracy Life.Exp Murder HS.Grad Frost   Area
Nevada NV         West        590   5149        0.5    69.03   11.5    65.2   188 109889
> class(as.vector(y))
[1] "data.frame"

P35 数据转换(二)

取子集
##连续提取
> who <- read.csv("WHO.csv",header = T) #引入示例里一个世卫组织的表格
> head(who) #头六行,列数多省略,可在右上角环境窗口中查看
> who1 <- who[c(1:50),c(1:10)] #取出1到50行和1到10列
> who1 #当控制台内因数据框太大不便显示时,可查看右上角环境窗口,点击对应目标会在左上角新选项卡页面显示

##不连续提取
> who2 <- who[c(1,3,5,8),c(2,14,16,18)]
> View(who2) #右上角点击后会显示的命令

##逻辑值提取
> who$Continent #取出WHO表格中大洲这一行的数据
  [1] 1 2 3 2 3 4 5 2 6 2 2 4 1 7 4 2 2 5 3 4 7 5 2 3 5 6 2 3
 [29] 3 7 3 4 1 3 3 5 7 5 3 3 3 6 5 3 2 5 2 2 2 1 5 5 5 1 5 3
 [57] 3 2 3 6 2 2 6 3 3 2 2 3 2 5 5 3 3 5 5 5 6 2 2 7 6 1 1 2
 [85] 1 2 5 6 1 2 3 6 6 6 1 2 6 2 3 3 3 1 2 2 6 2 3 3 6 7 3 1
[113] 6 3 3 4 6 2 2 6 2 1 3 6 3 6 7 2 5 6 6 5 3 3 6 2 1 7 6 5
[141] 6 5 5 6 2 2 5 1 2 2 3 5 5 5 6 2 3 1 3 2 3 3 6 2 2 6 3 3
[169] 2 7 3 5 3 2 2 1 6 2 3 6 6 3 6 5 1 2 2 6 3 2 1 2 4 5 2 6
[197] 5 6 1 1 3 3
> who3 <- who[which(who$Continent==7),] #取出符合Continent值为7的所有行,右上角显示
> who3 #

> who4 <- who[which(who$CountryID>50 & who$CountryID<=100),] #取CountryID大于50小于100的行列值,此处注意布尔符与数字之间不要有空格,闭合端加等号=,记得加逗号区分行列!!!

> ?subset #更为方便的取子集函数
> who4 <- subset(who,who$CountryID>50 & who$CountryID<=100)
> who4

##随机抽样函数,有放回或无放回
> ?sample
> x <- 1:100
> sample(x,30) #无放回的随机抽30个数
 [1]  14  55  65  40  83  71  96  45  21  77  97  28  98  18
[15]  93  31  85  88  74  20 100   9  48   2  89  26  86  80
[29]  30  52
> sample(x,60,replace = T) #有放回的抽60个数
 [1] 50  3 98 54 45 69 49 30 42 74 79 82 90 42  9 90 53 36 76
[20] 84 73  2 29 43 24 83 91 47 22 68 47 31 30 83 26 45 15 42
[39] 37  8  7 76 34 78 37 13  8 94 57 46 94 86 89 89 19 51 23
[58] 93 79 74
> sort(sample(x,60,replace = T)) #从小到大进行排序,有重复数字,与上面结果不一样是因为这一次又进行了一次随机抽取
 [1]  5  6  8 10 13 13 14 18 18 21 23 25 25 26 28 29 30 34 34
[20] 34 35 37 37 38 39 39 39 44 49 51 51 51 56 56 58 62 62 63
[39] 64 68 70 72 73 74 74 75 76 77 78 78 80 81 83 86 89 90 94
[58] 94 97 97
##用sample对数据框进行抽样
> sample(who$CountryID,30,replace = F)
 [1] 146  74  12 161  11  30  55 177  21  44  70  50 138 156
[15]  88 149 142 145  28 173 102 175 162  59  34  99  31  29
[29]  92 126
> who[sample(who$CountryID,30,replace = F),] #随机取子集
删除固定行的数据
##使用负索引的方式
> mtcars[-1:-5,] #删除mtcars数据集中前5行,逗号在后删除行,逗号在前删除列,不加逗号默认为删除列
> mtcars$wt <- NULL #清空该行(列)的数据
> mtcars
                     mpg cyl  disp  hp drat  qsec vs am gear
Mazda RX4           21.0   6 160.0 110 3.90 16.46  0  1    4
Mazda RX4 Wag       21.0   6 160.0 110 3.90 17.02  0  1    4
数据框的添加与合并
> USArrests #美国50个州犯罪率的数据框
               Murder Assault UrbanPop Rape
Alabama          13.2     236       58 21.2
Alaska           10.0     263       48 44.5
Arizona           8.1     294       80 31.0
Arkansas          8.8     190       50 19.5
California        9.0     276       91 40.6
……
> state.division #美国50个州的分区数据框(相当于我国的东北/华北/华中/华南等)
 [1] East South Central Pacific            Mountain          
 [4] West South Central Pacific            Mountain          
 [7] New England        South Atlantic     South Atlantic
> data.frame(USArrests,state.division) #合并成一个数据框
               Murder Assault UrbanPop Rape     state.division
Alabama          13.2     236       58 21.2 East South Central
Alaska           10.0     263       48 44.5            Pacific
Arizona           8.1     294       80 31.0           Mountain
Arkansas          8.8     190       50 19.5 West South Central

##单独的行和列的添加
> ?cbind #Columns-bind完成行对行的连接,相当于增加列数
> cbind(USArrests,state.division) #效果同上
##合并行时要求新合并的数据与原有数据具有同一列名
> data1 <- head(USArrests,20) #取USArrests中前20行
> data2 <- tail(USArrests,20) #取后20行
> rbind(data1,data2) #Rows-bind合并列,列对列的连接,相当于增加行数
单独的行和列的添加
> ?cbind #Columns-bind完成行对行的连接,相当于增加列数
> cbind(USArrests,state.division) #效果同上

##合并行时要求新合并的数据与原有数据具有同一列名
> data1 <- head(USArrests,20) #取USArrests中前20行
> data2 <- tail(USArrests,20) #取后20行
> rbind(data1,data2) #Rows-bind合并列,列对列的连接,相当于增加行数

##如果行列数不匹配进行合并演示
> head(cbind(USArrests,state.division),20)
            Murder Assault UrbanPop Rape     state.division
Alabama       13.2     236       58 21.2 East South Central
Alaska        10.0     263       48 44.5            Pacific
Arizona        8.1     294       80 31.0           Mountain
Arkansas       8.8     190       50 19.5 West South Central
> data3 <- head(cbind(USArrests,state.division),20)
> data2
               Murder Assault UrbanPop Rape
New Mexico       11.4     285       70 32.1
New York         11.1     254       86 26.1
North Carolina   13.0     337       45 16.1
North Dakota      0.8      45       44  7.3
> rbind(data2,data3)
Error in rbind(deparse.level, ...) : 变量的列数不对
删除重复项行列
> data1 <- head(USArrests,30)
> data2 <- tail(USArrests,30)
> data4 <- rbind(data1,data2) #data1和data2有10行的重复项
> length(rownames(data4)) #合并时会完整合并而不删除重复项
[1] 60
> duplicated(data4) #查看重复部分
 [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[19] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[28] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
[37]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE
[46] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[55] FALSE FALSE FALSE FALSE FALSE FALSE
> data4[duplicated(data4),] #取出重复部分,R会对重复行名加个数字1
               Murder Assault UrbanPop Rape
Massachusetts1    4.4     149       85 16.3
Michigan1        12.1     255       74 35.1
Minnesota1        2.7      72       66 14.9
Mississippi1     16.1     259       44 17.1
……
> data4[!duplicated(data4),] #添加感叹号!是取反,即取出非重复部分
               Murder Assault UrbanPop Rape
Alabama          13.2     236       58 21.2
Alaska           10.0     263       48 44.5
Arizona           8.1     294       80 31.0
Arkansas          8.8     190       50 19.5
California        9.0     276       91 40.6
……
> length(rownames(data4[!duplicated(data4),])) #这时已经删除掉了重复的那10行
[1] 50

最简便快捷的去重复项指令是使用> unique(),可直接删除所有重复元素


P36 数据转换(三)

调换行和列的顺序

  • Excel中的转换:复制表格 --> 在新的sheet中Ctrl + Alt + V -->在弹出的对话框中选择右下角的“转置”,确定即可

  • 在R中的行列转换
> sracmt <- t(mtcars) #直接使用t函数
> sracmt 
   Mazda RX4 Mazda RX4 Wag Datsun 710 Hornet 4 Drive
mpg      21.00         21.00      22.80          21.40
cyl       6.00          6.00       4.00           6.00
  • 单独翻转某一行

    (比如基因序列的反向和互补)

> ?rev #reverse反转的简称
> letters
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n"
[15] "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"
> rev(letters)
 [1] "z" "y" "x" "w" "v" "u" "t" "s" "r" "q" "p" "o" "n" "m"
[15] "l" "k" "j" "i" "h" "g" "f" "e" "d" "c" "b" "a"

##翻转某一列
> women
   height weight
1      58    115
2      59    117
3      60    120
4      61    123
5      62    126
6      63    129
7      64    132
8      65    135
9      66    139
10     67    142
11     68    146
12     69    150
13     70    154
14     71    159
15     72    164
> rownames(women)
 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10" "11"
[12] "12" "13" "14" "15"
> rev(rownames(women))
 [1] "15" "14" "13" "12" "11" "10" "9"  "8"  "7"  "6"  "5" 
[12] "4"  "3"  "2"  "1" 
> women[rev(rownames(women)),] #另一列顺序也随之变化
   height weight
15     72    164
14     71    159
13     70    154
12     69    150
11     68    146
10     67    142
9      66    139
8      65    135
7      64    132
6      63    129
5      62    126
4      61    123
3      60    120
2      59    117
1      58    115
  • 单位的转换
##例如将women数据集中的英寸单位转化成厘米
> women$height
 [1] 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
> women$height*2.54 #英寸转厘米×2.54
 [1] 147.32 149.86 152.40 154.94 157.48 160.02 162.56 165.10
 [9] 167.64 170.18 172.72 175.26 177.80 180.34 182.88
> data.frame(women$height*2.54,women$weight) 
   women.height...2.54 women.weight
1               147.32          115
2               149.86          117
3               152.40          120
4               154.94          123
> ?transform #转换,修改任何列的值
> transform(women,height=height*2.54) #直接在原数据上修改
   height weight
1  147.32    115
2  149.86    117
3  152.40    120
4  154.94    123
……
> transform(women,height.cm=height*2.54) #将修改的值新存一列
   height weight height.cm
1      58    115    147.32
2      59    117    149.86
3      60    120    152.40
4      61    123    154.94
  • 排序
> ?sort
> sort(rivers) #数值按从小打到排
  [1]  135  202  210  210  215  217  230  230  233  237  246
 [12]  250  250  250  255  259  260  260  265  268  270  276
 [23]  280  280  280  281  286  290  291  300  300  300  301
……
> sort(state.name) #字符串按字母顺序排
 [1] "Alabama"        "Alaska"         "Arizona"       
 [4] "Arkansas"       "California"     "Colorado"      
 [7] "Connecticut"    "Delaware"       "Florida"       
[10] "Georgia"        "Hawaii"         "Idaho"         
[13] "Illinois"       "Indiana"        "Iowa"          
[16] "Kansas"         "Kentucky"       "Louisiana"   
##配合rev函数可实现升序和降序

> sort(mtcars) # sort函数无法直接对数据框进行排序
Error in `[.data.frame`(x, order(x, na.last = na.last, decreasing = decreasing)) : 
  选择了未定义的列
> mtcars[sort(rownames(mtcars)),] #但可通过索引行名或列名进行排序
                     mpg cyl  disp  hp drat  qsec vs am gear
AMC Javelin         15.2   8 304.0 150 3.15 17.30  0  0    3
Cadillac Fleetwood  10.4   8 472.0 205 2.93 17.98  0  0    3
Camaro Z28          13.3   8 350.0 245 3.73 15.41  0  0    3
Chrysler Imperial   14.7   8 440.0 230 3.23 17.42  0  0    3
Datsun 710          22.8   4 108.0  93 3.85 18.61  1  1    4
Dodge Challenger    15.5   8 318.0 150 2.76 16.87  0  0    3
Duster 360          14.3   8 360.0 245 3.21 15.84  0  0    3
Ferrari Dino        19.7   6 145.0 175 3.62 15.50  0  1    5
> mtcars[sort(mtcars$mpg),] #如这里是按mpg这列升序排

> ?order #返回的是向量的位置,而不是排序的结果
> sort(rivers)
  [1]  135  202  210  210  215  217  230  230  233  237  246
 [12]  250  250  250  255  259  260  260  265  268  270  276
 [23]  280  280  280  281  286  290  291  300  300  300  301
> order(rivers) #即排名,索引值
  [1]   8  17  39 108 129  52  36  42  91 117 133  34  56  87
 [15]  76  55  41  75  37 127 138 107  13  30  72  53  29  19
 [29]  49  61 103 124 126  46  94 123 116  14   2   3  35  18
> rivers[8] #因rivers返回的是索引值,可以利用这点间接的对数据框进行排序
[1] 135
> order(mtcars$mpg)
 [1] 15 16 24  7 17 31 14 23 22 29 12 13 11  6  5 10 25 30  1
[20]  2  4 32 21  3  9  8 27 26 19 28 18 20
> mtcars[order(mtcars$mpg),]
                     mpg cyl  disp  hp drat  qsec vs am gear carb
Cadillac Fleetwood  10.4   8 472.0 205 2.93 17.98  0  0    3    4
Lincoln Continental 10.4   8 460.0 215 3.00 17.82  0  0    3    4
Camaro Z28          13.3   8 350.0 245 3.73 15.41  0  0    3    4
Duster 360          14.3   8 360.0 245 3.21 15.84  0  0    3    4
Chrysler Imperial   14.7   8 440.0 230 3.23 17.42  0  0    3    4
> mtcars[order(-mtcars$mpg),] #在列名前直接加“-”则得到逆序
                     mpg cyl  disp  hp drat  qsec vs am gear carb
Toyota Corolla      33.9   4  71.1  65 4.22 19.90  1  1    4    1
Fiat 128            32.4   4  78.7  66 4.08 19.47  1  1    4    1
Honda Civic         30.4   4  75.7  52 4.93 18.52  1  1    4    2
##对多个条件进行排序
> mtcars[order(mtcars$mpg,mtcars$disp),] #在消耗的每加仑汽油行驶里程(mpg)一致的情况下,排量(disp)小的排在前面
                     mpg cyl  disp  hp drat  qsec vs am gear carb
Lincoln Continental 10.4   8 460.0 215 3.00 17.82  0  0    3    4
Cadillac Fleetwood  10.4   8 472.0 205 2.93 17.98  0  0    3    4
Camaro Z28          13.3   8 350.0 245 3.73 15.41  0  0    3    4
Duster 360          14.3   8 360.0 245 3.21 15.84  0  0    3    4
Chrysler Imperial   14.7   8 440.0 230 3.23 17.42  0  0    3    4
Maserati Bora       15.0   8 301.0 335 3.54 14.60  0  1    5    8

> ?rank #返回的是向量的排名,涉及到秩次概念

P37 数据转换(四)

> WorldPhones #全球八个区域七年中的电话数量
     N.Amer Europe Asia S.Amer Oceania Africa Mid.Amer
1951  45939  21574 2876   1815    1646     89      555
1956  60423  29990 4708   2568    2366   1411      733
1957  64721  32510 5230   2695    2526   1546      773
1958  68484  35218 6662   2845    2691   1663      836
1959  71799  37598 6856   3000    2868   1769      911
1960  76036  40341 8220   3145    3054   1905     1008
1961  79831  43173 9053   3338    3224   2005     1076
> worldphones <- as.data.frame(WorldPhones)
> rs <- rowSums(worldphones) #计算每一行的加和值
> rs
  1951   1956   1957   1958   1959   1960   1961 
 74494 102199 110001 118399 124801 133709 141700 
> cm <- colMeans(worldphones) #计算每一列的平均值
> cm
    N.Amer     Europe       Asia     S.Amer    Oceania 
66747.5714 34343.4286  6229.2857  2772.2857  2625.0000 
    Africa   Mid.Amer 
 1484.0000   841.7143 
> total <- cbind(worldphones,Total=rs) #增添加和值rs这一列
> total
     N.Amer Europe Asia S.Amer Oceania Africa Mid.Amer  Total
1951  45939  21574 2876   1815    1646     89      555  74494
1956  60423  29990 4708   2568    2366   1411      733 102199
1957  64721  32510 5230   2695    2526   1546      773 110001
1958  68484  35218 6662   2845    2691   1663      836 118399
1959  71799  37598 6856   3000    2868   1769      911 124801
1960  76036  40341 8220   3145    3054   1905     1008 133709
1961  79831  43173 9053   3338    3224   2005     1076 141700
> rbind(total,cm) #增添平均值cm这一列
       N.Amer   Europe     Asia   S.Amer Oceania Africa  Mid.Amer     Total
1951 45939.00 21574.00 2876.000 1815.000    1646     89  555.0000  74494.00
1956 60423.00 29990.00 4708.000 2568.000    2366   1411  733.0000 102199.00
1957 64721.00 32510.00 5230.000 2695.000    2526   1546  773.0000 110001.00
1958 68484.00 35218.00 6662.000 2845.000    2691   1663  836.0000 118399.00
1959 71799.00 37598.00 6856.000 3000.000    2868   1769  911.0000 124801.00
1960 76036.00 40341.00 8220.000 3145.000    3054   1905 1008.0000 133709.00
1961 79831.00 43173.00 9053.000 3338.000    3224   2005 1076.0000 141700.00
8    66747.57 34343.43 6229.286 2772.286    2625   1484  841.7143  66747.57#此处该数据错误,由于计算平均值时未计入加和值Total这列,导致行列不匹配,Total这列的平均值错误
##解决方法是先输出计算完行加和值的整个数据框,再计算列平均值,如下
> cm <- colMeans(total)
> cm
     N.Amer      Europe        Asia      S.Amer     Oceania      Africa    Mid.Amer       Total 
 66747.5714  34343.4286   6229.2857   2772.2857   2625.0000   1484.0000    841.7143 115043.2857 
> rbind(total,cm)
> rbind(total,mean=cm) #mean是重新命名新添加行
       N.Amer   Europe     Asia   S.Amer Oceania Africa  Mid.Amer    Total
1951 45939.00 21574.00 2876.000 1815.000    1646     89  555.0000  74494.0
1956 60423.00 29990.00 4708.000 2568.000    2366   1411  733.0000 102199.0
1957 64721.00 32510.00 5230.000 2695.000    2526   1546  773.0000 110001.0
1958 68484.00 35218.00 6662.000 2845.000    2691   1663  836.0000 118399.0
1959 71799.00 37598.00 6856.000 3000.000    2868   1769  911.0000 124801.0
1960 76036.00 40341.00 8220.000 3145.000    3054   1905 1008.0000 133709.0
1961 79831.00 43173.00 9053.000 3338.000    3224   2005 1076.0000 141700.0
mean 66747.57 34343.43 6229.286 2772.286    2625   1484  841.7143 115043.3
apply series函数
image-20201010215528394
> ?apply ##三个参数:X表示被处理的对象;MARGIN表示向量下标,1表示行,2表示列,c(1,2)表示行和列;FUN表示此处可调用函数。
> apply(WorldPhones,MARGIN = 1,FUN = sum) #对每行求和
  1951   1956   1957   1958   1959   1960   1961 
 74494 102199 110001 118399 124801 133709 141700 
> apply(WorldPhones,MARGIN = 2,FUN = mean) #对每列求平均值
    N.Amer     Europe       Asia     S.Amer    Oceania     Africa   Mid.Amer 
66747.5714 34343.4286  6229.2857  2772.2857  2625.0000  1484.0000   841.7143 
##与第一种方法相比,可以计算更多的类型值,如方差/log值等,但将结果合并时仍需注意上一种方法出现的行列匹配以及值的对应问题(先计算行加和合并表,再计算合并后的表的列平均值)
> apply(WorldPhones,MARGIN = 2,FUN = var)
     N.Amer      Europe        Asia      S.Amer     Oceania      Africa    Mid.Amer 
127181160.6  51776902.0   4512287.6    246698.6    273595.0    419524.3     31019.9 
> apply(WorldPhones,MARGIN = 2,FUN = log)
       N.Amer    Europe     Asia   S.Amer  Oceania   Africa Mid.Amer
1951 10.73507  9.979244 7.964156 7.503841 7.406103 4.488636 6.318968
1956 11.00913 10.308619 8.457018 7.850883 7.768956 7.252054 6.597146ong
1957 11.07784 10.389303 8.562167 7.899153 7.834392 7.343426 6.650279
1958 11.13436 10.469313 8.804175 7.953318 7.897668 7.416378 6.728629
1959 11.18163 10.534706 8.832879 8.006368 7.961370 7.478170 6.814543
1960 11.23896 10.605124 9.014325 8.053569 8.024207 7.552237 6.915723
1961 11.28767 10.672971 9.110851 8.113127 8.078378 7.603399 6.981006


#lapply and sapply
> ?lapply # list apply返回的是列表
> sapply # simplify apply 返回的是向量或矩阵
> state.center
$x
 [1]  -86.7509 -127.2500 -111.6250  -92.2992 -119.7730
 [6] -105.5130  -72.3573  -74.9841  -81.6850  -83.3736
[11] -126.2500 -113.9300  -89.3776  -86.0808  -93.3714
[16]  -98.1156  -84.7674  -92.2724  -68.9801  -76.6459
[21]  -71.5800  -84.6870  -94.6043  -89.8065  -92.5137
[26] -109.3200  -99.5898 -116.8510  -71.3924  -74.2336
[31] -105.9420  -75.1449  -78.4686 -100.0990  -82.5963
[36]  -97.1239 -120.0680  -77.4500  -71.1244  -80.5056
[41]  -99.7238  -86.4560  -98.7857 -111.3300  -72.5450
[46]  -78.2005 -119.7460  -80.6665  -89.9941 -107.2560

$y
 [1] 32.5901 49.2500 34.2192 34.7336 36.5341 38.6777 41.5928
 [8] 38.6777 27.8744 32.3329 31.7500 43.5648 40.0495 40.0495
[15] 41.9358 38.4204 37.3915 30.6181 45.6226 39.2778 42.3645
[22] 43.1361 46.3943 32.6758 38.3347 46.8230 41.3356 39.1063
[29] 43.3934 39.9637 34.4764 43.1361 35.4195 47.2517 40.2210
[36] 35.5053 43.9078 40.9069 41.5928 33.6190 44.3365 35.6767
[43] 31.3897 39.1063 44.2508 37.5630 47.4231 38.4204 44.5937
[50] 43.0504

> lapply(state.center,FUN = length) #计算上述列表的元素个数,返回值依然是列表形式
$x
[1] 50

$y
[1] 50
> sapply(state.center,FUN = length) #与上方类似,但返回值是向量
 x  y 
50 50 
> class(sapply(state.center,FUN = length))
[1] "integer"


#tapply
> ?tapply #tapply(X, INDEX, FUN = NULL, ..., default = NA, simplify = TRUE),注意第二个参数为因子
> state.name #美国50个洲的名字
 [1] "Alabama"        "Alaska"         "Arizona"        "Arkansas"       "California"     "Colorado"       "Connecticut"    "Delaware"       "Florida"       
[10] "Georgia"        "Hawaii"         "Idaho"          "Illinois"       "Indiana"        "Iowa"           "Kansas"         "Kentucky"       "Louisiana"     
……    
> state.division #每个州的分区
 [1] East South Central Pacific            Mountain           West South Central Pacific            Mountain           New England        South Atlantic    
 [9] South Atlantic     South Atlantic     Pacific            Mountain           East North Central East North Central West North Central West North Central
……        
Levels: New England Middle Atlantic South Atlantic East South Central West South Central East North Central West North Central Mountain Pacific
> tapply(state.name,state.division,FUN = length) #统计每个分区有多少个州
       New England    Middle Atlantic     South Atlantic East South Central West South Central East North Central West North Central           Mountain 
                 6                  3                  8                  4                  4                  5                  7                  8 
           Pacific 
                 5 
数据的中心化与标准化

数据中心化,是指数据集中的各项数据减去数据集的均值。
数据标准化,是指在中心化之后在除以数据集的标准差,即数据集中的各项数据减去数据集的均值再除以数据集的标准差。

避免量纲(单位)差异。

> state.x77
               Population Income Illiteracy Life Exp Murder HS Grad Frost   Area
Alabama              3615   3624        2.1    69.05   15.1    41.3    20  50708
Alaska                365   6315        1.5    69.31   11.3    66.7   152 566432
Arizona              2212   4530        1.8    70.55    7.8    58.1    15 113417
Arkansas             2110   3378        1.9    70.66   10.1    39.9    65  51945
California          21198   5114        1.1    71.71   10.3    62.6    20 156361
……
> heatmap(state.x77) #各列直接单位不同数值差异太大,绘制出来的热图没有意义
> x <- c(1,2,3,6,3)
> mean(x)
[1] 3
> x-mean(x) #中心化后数值差异依然有点大
[1] -2 -1  0  3  0
> sd(x)
[1] 1.870829
> (x-mean(x))/sd(x) #继续进行数据标准化
[1] -1.0690450 -0.5345225  0.0000000  1.6035675  0.0000000 #得到的值相对稳定都在0附近

scale(x, center = TRUE, scale = TRUE) #后两个参数分别为中心化处理和标准化处理
> x <- scale(state.x77,scale = T,center = T)
> head(x)
           Population     Income Illiteracy   Life Exp     Murder    HS Grad      Frost       Area
Alabama    -0.1414316 -1.3211387   1.525758 -1.3621937  2.0918101 -1.4619293 -1.6248292 -0.2347183
Alaska     -0.8693980  3.0582456   0.541398 -1.1685098  1.0624293  1.6828035  0.9145676  5.8093497
Arizona    -0.4556891  0.1533029   1.033578 -0.2447866  0.1143154  0.6180514 -1.7210185  0.5002047
Arkansas   -0.4785360 -1.7214837   1.197638 -0.1628435  0.7373617 -1.6352611 -0.7591257 -0.2202212
California  3.7969790  1.1037155  -0.114842  0.6193415  0.7915396  1.1751891 -1.6248292  1.0034903
Colorado   -0.3819965  0.7294092  -0.771082  0.8800698 -0.1565742  1.3361400  1.1838976  0.3870991
> head(state.x77)
           Population Income Illiteracy Life Exp Murder HS Grad Frost   Area
Alabama          3615   3624        2.1    69.05   15.1    41.3    20  50708
Alaska            365   6315        1.5    69.31   11.3    66.7   152 566432
Arizona          2212   4530        1.8    70.55    7.8    58.1    15 113417
Arkansas         2110   3378        1.9    70.66   10.1    39.9    65  51945
California      21198   5114        1.1    71.71   10.3    62.6    20 156361
Colorado         2541   4884        0.7    72.06    6.8    63.9   166 103766
> heatmap(x)#结果明显

heatmap(state.x77) #意义不大 heatmap(x)#结果清晰

image-20201011094405213 image-20201011094310498


P38 reshape2

> x <- data.frame(k1 = c(NA,NA,3,4,5), k2 = c(1,NA,NA,4,5),
+                 data = 1:5)
> y <- data.frame(k1 = c(NA,2,NA,4,5), k2 = c(NA,NA,3,4,5),
+                 data = 1:5)
> x
  k1 k2 data
1 NA  1    1
2 NA NA    2
3  3 NA    3
4  4  4    4
5  5  5    5
> y
  k1 k2 data
1 NA NA    1
2  2 NA    2
3 NA  3    3
4  4  4    4
5  5  5    5
> rbind(x,y) #直接连接合并分不出哪些数据来自哪个数据框
   k1 k2 data
1  NA  1    1
2  NA NA    2
3   3 NA    3
4   4  4    4
5   5  5    5
6  NA NA    1
7   2 NA    2
8  NA  3    3
9   4  4    4
10  5  5    5
> merge(x, y, by = "k1") #x,y中k1相同的有:(NA,4,5),所以保留二者中包含(NA,4,5)的所有行
  k1 k2.x data.x k2.y data.y
1  4    4      4    4      4
2  5    5      5    5      5
3 NA    1      1   NA      1
4 NA    1      1    3      3
5 NA   NA      2   NA      1
6 NA   NA      2    3      3
> merge(x, y, by = "k2",comparables=T) #以k2为准合并,不匹配的部分用NA表示,即comparables=NA
  k2 k1.x data.x k1.y data.y
1  4    4      4    4      4
2  5    5      5    5      5
3 NA   NA      2   NA      1
4 NA   NA      2    2      2
5 NA    3      3   NA      1
6 NA    3      3    2      2
> merge(x, y, by = c("k1","k2")) #按k1,k2共有的元素合并
  k1 k2 data.x data.y
1  4  4      4      4
2  5  5      5      5
3 NA NA      2      1
  • reshape2:类似于Excel中数据透视表的功能,利用melt函数将数据“揉开”并“重造”的过程 这节重学
> install.packages("reshape2")
> library(reshape2)
> airquality #reshape2的演示数据集
    Ozone Solar.R Wind Temp Month Day
1      41     190  7.4   67     5   1
2      36     118  8.0   72     5   2
3      12     149 12.6   74     5   3
4      18     313 11.5   62     5   4
5      NA      NA 14.3   56     5   5
6      28      NA 14.9   66     5   6
7      23     299  8.6   65     5   7
8      19      99 13.8   59     5   8
9       8      19 20.1   61     5   9
10     NA     194  8.6   69     5  10
11      7      NA  6.9   74     5  11
12     16     256  9.7   69     5  12
……
> head(airquality)
  Ozone Solar.R Wind Temp Month Day
1    41     190  7.4   67     5   1
2    36     118  8.0   72     5   2
3    12     149 12.6   74     5   3
4    18     313 11.5   62     5   4
5    NA      NA 14.3   56     5   5
6    28      NA 14.9   66     5   6
> names(airquality) <- tolower(names(airquality)) #改成小写方便输入
> head(airquality)
  ozone solar.r wind temp month day
1    41     190  7.4   67     5   1
2    36     118  8.0   72     5   2
3    12     149 12.6   74     5   3
4    18     313 11.5   62     5   4
5    NA      NA 14.3   56     5   5
6    28      NA 14.9   66     5   6
> melt(airquality) #将宽数据改成长数据,即“融合数据”
No id variables; using all as measure variables
    variable value 
1      ozone  41.0
2      ozone  36.0
3      ozone  12.0
4      ozone  18.0
5      ozone    NA
6      ozone  28.0 #数据变成三列
……
 [ reached 'max' / getOption("max.print") -- omitted 418 rows ]
> aql <- melt(airquality)
No id variables; using all as measure variables
> head(aql)
  variable value
1    ozone    41
2    ozone    36
3    ozone    12
4    ozone    18
5    ozone    NA
6    ozone    28
> aql <- melt(airquality, id.vars = c("month", "day")) #确定哪部分用作行的观测,哪部分作为列的观测值
#month和day作为ID(用来区分不同行数据的变量),其余四个(ozone solar.r wind temp)作为变量值
> head(aql)
  month day variable value
1     5   1    ozone    41
2     5   2    ozone    36
3     5   3    ozone    12
4     5   4    ozone    18
5     5   5    ozone    NA
6     5   6    ozone    28
> aqw <- dcast(aql, month + day ~ variable) #dcast函数用来处理数据框,“~”表示相关联(二者有关系,但不一定是相等)    #acast函数返回向量/矩阵/数组
> head(aqw) #与原始数据相比只是把month day两列提前
  month day ozone solar.r wind temp
1     5   1    41     190  7.4   67
2     5   2    36     118  8.0   72
3     5   3    12     149 12.6   74
4     5   4    18     313 11.5   62
5     5   5    NA      NA 14.3   56
6     5   6    28      NA 14.9   66
> head(airquality)
  ozone solar.r wind temp month day
1    41     190  7.4   67     5   1
2    36     118  8.0   72     5   2
3    12     149 12.6   74     5   3
4    18     313 11.5   62     5   4
5    NA      NA 14.3   56     5   5
6    28      NA 14.9   66     5   6
> dcast(aql, month ~ variable) #去掉day变量提示:当一个月的数据合并后,不知道对每一天的值如何处理,是计算总和/平均值/中位数等
Aggregation function missing: defaulting to length
  month ozone solar.r wind temp
1     5    31      31   31   31
2     6    30      30   30   30
3     7    31      31   31   31
4     8    31      31   31   31
5     9    30      30   30   30
> dcast(aql, month ~ variable, fun.aggregate = mean, na.rm = TRUE) #aggregate合并,na.rm去除NA值
  month    ozone  solar.r      wind     temp
1     5 23.61538 181.2963 11.622581 65.54839
2     6 29.44444 190.1667 10.266667 79.10000
3     7 59.11538 216.4839  8.941935 83.90323
4     8 59.96154 171.8571  8.793548 83.96774
5     9 31.44828 167.4333 10.180000 76.90000
> head(aqw)
  month day ozone solar.r wind temp
1     5   1    41     190  7.4   67
2     5   2    36     118  8.0   72
3     5   3    12     149 12.6   74
4     5   4    18     313 11.5   62
5     5   5    NA      NA 14.3   56
6     5   6    28      NA 14.9   66
> aqw <- dcast(aql, month ~ variable, fun.aggregate = sum, na.rm = TRUE)
> head(aqw)
  month ozone solar.r  wind temp
1     5   614    4895 360.3 2032
2     6   265    5705 308.0 2373
3     7  1537    6711 277.2 2601
4     8  1559    4812 272.6 2603
5     9   912    5023 305.4 2307

##dcast(data,formula,fun.aggregate = NULL,……)
##formula需要融合后的数据格式,描述重铸数据形状:左边表示id.variable,右边表示major.variable可观测的值


P39 tidyr包

Tidyr data 处理整洁的数据

  • 每一列代表一个变量
  • 每一行代表一个观测
  • 每一个观测的值在表中的一个单元格中

即一个变量和一个观测确定一个唯一的值

有相同的行名和列名则会引起识别混乱,不属于tidyr data

tidyr包主要包含四个常用重要函数:

  • gather:将宽数据转换为长数据,类似于reshape2中的melt函数,gather的好处是固定列不变,其他列进行转换
> mtcars #以这个标准规范的数据集为例
> tdata <- mtcars[1:10,1:3]
> tdata
                   mpg cyl  disp
Mazda RX4         21.0   6 160.0
Mazda RX4 Wag     21.0   6 160.0
Datsun 710        22.8   4 108.0
Hornet 4 Drive    21.4   6 258.0
Hornet Sportabout 18.7   8 360.0
Valiant           18.1   6 225.0
Duster 360        14.3   8 360.0
Merc 240D         24.4   4 146.7
Merc 230          22.8   4 140.8
Merc 280          19.2   6 167.6
> tdata <- data.frame(name=rownames(tdata),tdata)
> tdata
                               name  mpg cyl  disp
Mazda RX4                 Mazda RX4 21.0   6 160.0
Mazda RX4 Wag         Mazda RX4 Wag 21.0   6 160.0
Datsun 710               Datsun 710 22.8   4 108.0
Hornet 4 Drive       Hornet 4 Drive 21.4   6 258.0
Hornet Sportabout Hornet Sportabout 18.7   8 360.0
Valiant                     Valiant 18.1   6 225.0
Duster 360               Duster 360 14.3   8 360.0
Merc 240D                 Merc 240D 24.4   4 146.7
Merc 230                   Merc 230 22.8   4 140.8
Merc 280                   Merc 280 19.2   6 167.6

##gather(data,key = "key",value = "value",
##key是宽数据变为长数据时存放需要编码的变量的变量名称,需要自己定义新的名字
##value需要数据转换的变量的数值,也需要自己重新定义,后面接对哪些列进行处理

> gather(tdata,key = "Key",value = "Value",cyl,disp,mpg)
                name  Key Value
1          Mazda RX4  cyl   6.0
2      Mazda RX4 Wag  cyl   6.0
3         Datsun 710  cyl   4.0
4     Hornet 4 Drive  cyl   6.0
5  Hornet Sportabout  cyl   8.0
6            Valiant  cyl   6.0
7         Duster 360  cyl   8.0
8          Merc 240D  cyl   4.0
9           Merc 230  cyl   4.0
10          Merc 280  cyl   6.0
11         Mazda RX4 disp 160.0
12     Mazda RX4 Wag disp 160.0
13        Datsun 710 disp 108.0
14    Hornet 4 Drive disp 258.0
15 Hornet Sportabout disp 360.0
16           Valiant disp 225.0
17        Duster 360 disp 360.0
18         Merc 240D disp 146.7
19          Merc 230 disp 140.8
20          Merc 280 disp 167.6
21         Mazda RX4  mpg  21.0
22     Mazda RX4 Wag  mpg  21.0
23        Datsun 710  mpg  22.8
24    Hornet 4 Drive  mpg  21.4
25 Hornet Sportabout  mpg  18.7
26           Valiant  mpg  18.1
27        Duster 360  mpg  14.3
28         Merc 240D  mpg  24.4
29          Merc 230  mpg  22.8
30          Merc 280  mpg  19.2
> gather(tdata,key = "Key",value = "Value",cyl:disp) #“:”从XX到XX
                name  mpg  Key Value
1          Mazda RX4 21.0  cyl   6.0
2      Mazda RX4 Wag 21.0  cyl   6.0
3         Datsun 710 22.8  cyl   4.0
4     Hornet 4 Drive 21.4  cyl   6.0
5  Hornet Sportabout 18.7  cyl   8.0
6            Valiant 18.1  cyl   6.0
7         Duster 360 14.3  cyl   8.0
8          Merc 240D 24.4  cyl   4.0
9           Merc 230 22.8  cyl   4.0
10          Merc 280 19.2  cyl   6.0
11         Mazda RX4 21.0 disp 160.0
12     Mazda RX4 Wag 21.0 disp 160.0
13        Datsun 710 22.8 disp 108.0
14    Hornet 4 Drive 21.4 disp 258.0
15 Hornet Sportabout 18.7 disp 360.0
16           Valiant 18.1 disp 225.0
17        Duster 360 14.3 disp 360.0
18         Merc 240D 24.4 disp 146.7
19          Merc 230 22.8 disp 140.8
20          Merc 280 19.2 disp 167.6
> gather(tdata,key = "Key",value = "Value",mpg,-disp) #“-”表示删除某列
                name cyl  disp Key Value
1          Mazda RX4   6 160.0 mpg  21.0
2      Mazda RX4 Wag   6 160.0 mpg  21.0
3         Datsun 710   4 108.0 mpg  22.8
4     Hornet 4 Drive   6 258.0 mpg  21.4
5  Hornet Sportabout   8 360.0 mpg  18.7
6            Valiant   6 225.0 mpg  18.1
7         Duster 360   8 360.0 mpg  14.3
8          Merc 240D   4 146.7 mpg  24.4
9           Merc 230   4 140.8 mpg  22.8
10          Merc 280   6 167.6 mpg  19.2
> gather(tdata,key = "Key",value = "Value",2:4) #也可以直接输入列所在序号
                name  Key Value
1          Mazda RX4  mpg  21.0
2      Mazda RX4 Wag  mpg  21.0
3         Datsun 710  mpg  22.8
4     Hornet 4 Drive  mpg  21.4
5  Hornet Sportabout  mpg  18.7
6            Valiant  mpg  18.1
7         Duster 360  mpg  14.3
8          Merc 240D  mpg  24.4
9           Merc 230  mpg  22.8
10          Merc 280  mpg  19.2
11         Mazda RX4  cyl   6.0
12     Mazda RX4 Wag  cyl   6.0
13        Datsun 710  cyl   4.0
14    Hornet 4 Drive  cyl   6.0
15 Hornet Sportabout  cyl   8.0
16           Valiant  cyl   6.0
17        Duster 360  cyl   8.0
18         Merc 240D  cyl   4.0
19          Merc 230  cyl   4.0
20          Merc 280  cyl   6.0
21         Mazda RX4 disp 160.0
22     Mazda RX4 Wag disp 160.0
23        Datsun 710 disp 108.0
24    Hornet 4 Drive disp 258.0
25 Hornet Sportabout disp 360.0
26           Valiant disp 225.0
27        Duster 360 disp 360.0
28         Merc 240D disp 146.7
29          Merc 230 disp 140.8
30          Merc 280 disp 167.6
  • spread:将长数据转换为宽数据,类似于reshape2中的cast函数
> gdata <- gather(tdata,key = "Key",value = "Value",2:4)
> gdata
                name  Key Value
1          Mazda RX4  mpg  21.0
2      Mazda RX4 Wag  mpg  21.0
3         Datsun 710  mpg  22.8
4     Hornet 4 Drive  mpg  21.4
5  Hornet Sportabout  mpg  18.7
6            Valiant  mpg  18.1
7         Duster 360  mpg  14.3
8          Merc 240D  mpg  24.4
9           Merc 230  mpg  22.8
10          Merc 280  mpg  19.2
11         Mazda RX4  cyl   6.0
12     Mazda RX4 Wag  cyl   6.0
13        Datsun 710  cyl   4.0
14    Hornet 4 Drive  cyl   6.0
15 Hornet Sportabout  cyl   8.0
16           Valiant  cyl   6.0
17        Duster 360  cyl   8.0
18         Merc 240D  cyl   4.0
19          Merc 230  cyl   4.0
20          Merc 280  cyl   6.0
21         Mazda RX4 disp 160.0
22     Mazda RX4 Wag disp 160.0
23        Datsun 710 disp 108.0
24    Hornet 4 Drive disp 258.0
25 Hornet Sportabout disp 360.0
26           Valiant disp 225.0
27        Duster 360 disp 360.0
28         Merc 240D disp 146.7
29          Merc 230 disp 140.8
30          Merc 280 disp 167.6
> spread(gdata,key = "Key",value = "Value") #重新回到tidyr格式
                name cyl  disp  mpg
1         Datsun 710   4 108.0 22.8
2         Duster 360   8 360.0 14.3
3     Hornet 4 Drive   6 258.0 21.4
4  Hornet Sportabout   8 360.0 18.7
5          Mazda RX4   6 160.0 21.0
6      Mazda RX4 Wag   6 160.0 21.0
7           Merc 230   4 140.8 22.8
8          Merc 240D   4 146.7 24.4
9           Merc 280   6 167.6 19.2
10           Valiant   6 225.0 18.1
  • separate:将一列分成多列
> df <- data.frame(x = c(NA, "a.b", "a.d", "b.c"))
> df
     x
1 <NA>
2  a.b
3  a.d
4  b.c
> separate(df,col=x,into = c("A","B"))
     A    B
1 <NA> <NA>
2    a    b
3    a    d
4    b    c
> df <- data.frame(x = c(NA, "a.b-c", "a-d", "b-c")) #加上连字符-再试一次
> separate(df,col=x,into = c("A","B")) #分割出现错误,-c都未显示
     A    B
1 <NA> <NA>
2    a    b
3    a    d
4    b    c
Warning message:
Expected 2 pieces. Additional pieces discarded in 1 rows [2]. 
> separate(df,x,into = c("A","B"),sep = "-") #重新设置分隔符
     A    B
1 <NA> <NA>
2  a.b    c
3    a    d
4    b    c
  • unite:将多列合并为一列
> x <- separate(df,x,into = c("A","B"),sep = "-")
> x
     A    B
1 <NA> <NA>
2  a.b    c
3    a    d
4    b    c
> unite(x,col ="AB",A,B,sep="-")
     AB
1 NA-NA
2 a.b-c
3   a-d
4   b-c

P40 dplyr包

## 以鸢尾花数据集iris(总共150行数据)为例
> dplyr::filter (iris,Sepal.Length >7) ##filter过滤,过滤掉长度大于7的数据
   Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
1           7.1         3.0          5.9         2.1 virginica
2           7.6         3.0          6.6         2.1 virginica
3           7.3         2.9          6.3         1.8 virginica
4           7.2         3.6          6.1         2.5 virginica
5           7.7         3.8          6.7         2.2 virginica
6           7.7         2.6          6.9         2.3 virginica
7           7.7         2.8          6.7         2.0 virginica
8           7.2         3.2          6.0         1.8 virginica
9           7.2         3.0          5.8         1.6 virginica
10          7.4         2.8          6.1         1.9 virginica
11          7.9         3.8          6.4         2.0 virginica
12          7.7         3.0          6.1         2.3 virginica
> dplyr::distinct(rbind(iris[1:10,],iris[1:15,])) #distinct去除重复数据
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1           5.1         3.5          1.4         0.2  setosa
2           4.9         3.0          1.4         0.2  setosa
3           4.7         3.2          1.3         0.2  setosa
4           4.6         3.1          1.5         0.2  setosa
5           5.0         3.6          1.4         0.2  setosa
6           5.4         3.9          1.7         0.4  setosa
7           4.6         3.4          1.4         0.3  setosa
8           5.0         3.4          1.5         0.2  setosa
9           4.4         2.9          1.4         0.2  setosa
10          4.9         3.1          1.5         0.1  setosa
11          5.4         3.7          1.5         0.2  setosa
12          4.8         3.4          1.6         0.2  setosa
13          4.8         3.0          1.4         0.1  setosa
14          4.3         3.0          1.1         0.1  setosa
15          5.8         4.0          1.2         0.2  setosa
> dplyr::slice(iris,10:15) #取出函数任意行
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          4.9         3.1          1.5         0.1  setosa
2          5.4         3.7          1.5         0.2  setosa
3          4.8         3.4          1.6         0.2  setosa
4          4.8         3.0          1.4         0.1  setosa
5          4.3         3.0          1.1         0.1  setosa
6          5.8         4.0          1.2         0.2  setosa
> dplyr::sample_n(iris,10) #用于随机取样
   Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
1           6.7         3.1          4.4         1.4 versicolor
2           5.1         3.8          1.6         0.2     setosa
3           7.2         3.6          6.1         2.5  virginica
4           4.8         3.1          1.6         0.2     setosa
5           6.6         3.0          4.4         1.4 versicolor
6           6.9         3.1          4.9         1.5 versicolor
7           6.7         3.3          5.7         2.5  virginica
8           6.5         3.2          5.1         2.0  virginica
9           6.2         2.8          4.8         1.8  virginica
10          5.5         4.2          1.4         0.2     setosa
> dplyr::sample_frac(iris,0.1) #随机按比例选取,比如这里是取10%
  Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
1           7.1         3.0          5.9         2.1  virginica
2           6.1         2.8          4.0         1.3 versicolor
3           5.0         3.5          1.6         0.6     setosa
4           5.0         2.0          3.5         1.0 versicolor
5           4.9         2.5          4.5         1.7  virginica
6           5.8         2.8          5.1         2.4  virginica
7           7.7         3.8          6.7         2.2  virginica
8           6.4         2.8          5.6         2.1  virginica
9           6.6         2.9          4.6         1.3 versicolor
10          4.8         3.0          1.4         0.1     setosa
11          7.2         3.2          6.0         1.8  virginica
12          6.3         2.5          4.9         1.5 versicolor
13          5.3         3.7          1.5         0.2     setosa
14          6.3         2.9          5.6         1.8  virginica
15          5.7         2.5          5.0         2.0  virginica
> dplyr::arrange(iris,Sepal.Length) #按照花萼长度进行排序
    Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
1            4.3         3.0          1.1         0.1     setosa
2            4.4         2.9          1.4         0.2     setosa
3            4.4         3.0          1.3         0.2     setosa
4            4.4         3.2          1.3         0.2     setosa
5            4.5         2.3          1.3         0.3     setosa
> dplyr::arrange(iris,desc(Sepal.Length)) #descend降序排列
    Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
1            7.9         3.8          6.4         2.0  virginica
2            7.7         3.8          6.7         2.2  virginica
3            7.7         2.6          6.9         2.3  virginica
4            7.7         2.8          6.7         2.0  virginica
5            7.7         3.0          6.1         2.3  virginica
6            7.6         3.0          6.6         2.1  virginica
7            7.4         2.8          6.1         1.9  virginica

##取子集
> ?select #比R自带的subset取子集功能更为强大
> example("select") #具体可查看帮助文档中的案例演示
  • 使用dplyr中的统计函数
##依然以iris数据集为例

> summarise(iris,avg=mean(Sepal.Length)) #计算花萼平均值
       avg
1 5.843333
> summarise(iris,sum=sum(Sepal.Length)) #计算花萼总长度
    sum
1 876.5
#还包含其他类似函数
summarise	    Summarise each group to fewer rows
summarise_all	Summarise multiple columns
summarise_at	Summarise multiple columns
summarise_if	Summarise multiple columns
summarize	    Summarise each group to fewer rows
summarize_all	Summarise multiple columns
summarize_at	Summarise multiple columns
summarize_if	Summarise multiple columns
  • 链式操作符%>%

两个百分号中间夹着一个大于号,称为链式操作符,它功能是用于实现将一个函数的输出传递给下一个函数,作为下一个函数的输入。
在Rstudio中可以使用ctrl+shift+M快捷键输出出来。

## %>%示例
> head(mtcars,20) %>% tail() #从mtcars的前20行中取出后6行
                     mpg cyl  disp  hp drat    wt  qsec vs am gear carb
Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1

## %>%的应用
> dplyr::group_by(iris,Species) #通过species对iris进行分组,共分成了三组
# A tibble: 150 x 5
# Groups:   Species [3]
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
          <dbl>       <dbl>        <dbl>       <dbl> <fct>  
 1          5.1         3.5          1.4         0.2 setosa 
 2          4.9         3            1.4         0.2 setosa 
 3          4.7         3.2          1.3         0.2 setosa 
 4          4.6         3.1          1.5         0.2 setosa 
 5          5           3.6          1.4         0.2 setosa 
 6          5.4         3.9          1.7         0.4 setosa 
 7          4.6         3.4          1.4         0.3 setosa 
 8          5           3.4          1.5         0.2 setosa 
 9          4.4         2.9          1.4         0.2 setosa 
10          4.9         3.1          1.5         0.1 setosa 
# ... with 140 more rows
> iris %>% group_by(Species) #同样实现上述分组效果
> iris %>% group_by(Species) %>% summarise(avg=mean(Sepal.Width)) #分组后计算花萼宽度的平均值
`summarise()` ungrouping output (override with `.groups` argument)
# A tibble: 3 x 2
  Species      avg
  <fct>      <dbl>
1 setosa      3.43
2 versicolor  2.77
3 virginica   2.97
> iris %>% group_by(Species) %>% summarise(avg=mean(Sepal.Width)) %>% arrange(avg) #依照花萼宽度的平均值对分出的三组进行排序
`summarise()` ungrouping output (override with `.groups` argument)
# A tibble: 3 x 2
  Species      avg
  <fct>      <dbl>
1 versicolor  2.77
2 virginica   2.97
3 setosa      3.43


> dplyr::mutate(iris,new=Sepal.Length+Petal.Length) #mutate添加新的变量,花萼与花瓣长度的总和
    Sepal.Length Sepal.Width Petal.Length Petal.Width    Species  new
1            5.1         3.5          1.4         0.2     setosa  6.5
2            4.9         3.0          1.4         0.2     setosa  6.3
3            4.7         3.2          1.3         0.2     setosa  6.0
4            4.6         3.1          1.5         0.2     setosa  6.1
……
  • 链接
> a=data.frame(x1=c("A","B","C"),x2=c(1,2,3))
> b=data.frame(x1=c("A","B","D"),x3=c(T,F,T))
> a
  x1 x2
1  A  1
2  B  2
3  C  3
> b
  x1    x3
1  A  TRUE
2  B FALSE
3  D  TRUE
> dplyr::left_join(a,b,by="x1") #左链接,以左边的表为基础,x1列输出的是a表的值;b表中没有C行所以是NA
  x1 x2    x3
1  A  1  TRUE
2  B  2 FALSE
3  C  3    NA
> dplyr::right_join(a,b,by="x1") #右链接
  x1 x2    x3
1  A  1  TRUE
2  B  2 FALSE
3  D NA  TRUE
##内链接是取x1的交集,全链接是取x1的并集
> dplyr::full_join(a,b,by="x1") #全链接
  x1 x2    x3
1  A  1  TRUE
2  B  2 FALSE
3  C  3    NA
4  D NA  TRUE
> dplyr::semi_join(a,b,by="x1") #半集,根据b表对a表进行过滤,取ab的交集,即a中含有b的项
  x1 x2
1  A  1
2  B  2
> dplyr::anti_join(a,b,by="x1") #反链接,根据右侧表b输出ab的补集,即a中b不含有的行
  x1 x2
1  C  3
## 交和补都是以a为基础
  • 几个数据集的合并
> first <- slice(mtcars,1:20) #取出mtcars头20行
> first #slice取出默认缺少行名(即第一列)
                     mpg cyl  disp  hp drat    wt  qsec vs am gear carb
Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
……
> mtcars <- mutate(mtcars,Model=rownames(mtcars))#利用mutate函数添加行名
> first <- slice(mtcars,1:20)
> second <- slice(mtcars,10:30)
> first
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4           Mazda RX4
2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4       Mazda RX4 Wag
3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1          Datsun 710
4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1      Hornet 4 Drive
……
> second
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4            Merc 280
2  17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4           Merc 280C
3  16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3          Merc 450SE
4  17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3          Merc 450SL
……
> intersect(first, second) #取交集
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4            Merc 280
2  17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4           Merc 280C
3  16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3          Merc 450SE
4  17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3          Merc 450SL
……
> union_all(first, second) #取并集
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4           Mazda RX4
2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4       Mazda RX4 Wag
3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1          Datsun 710
4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1      Hornet 4 Drive
……
> union(first, second) #取非冗余的并集,即去掉并集中的重复项
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4           Mazda RX4
2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4       Mazda RX4 Wag
3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1          Datsun 710
4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1      Hornet 4 Drive
……
> setdiff(first, second) #取frist的补集
   mpg cyl  disp  hp drat    wt  qsec vs am gear carb             Model
1 21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4         Mazda RX4
2 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4     Mazda RX4 Wag
3 22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1        Datsun 710
4 21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1    Hornet 4 Drive
5 18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2 Hornet Sportabout
6 18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1           Valiant
7 14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4        Duster 360
8 24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2         Merc 240D
9 22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2          Merc 230
> setdiff(second, first) #取second的补集

P41 R函数

类似于Linux操作系统的命令,每一条命令相当于一个软件,有其对应的功能,但R函数的纷繁众多,需要多加练习才能慢慢掌握部分。下面列出部分常用的函数。

image-20201012101032220
##以state.x77为例演示R进行回归分析的优势
> state <- as.data.frame(state.x77[,c("Murder","Population","Illiteracy","Income","Frost")])
> class(state)
[1] "data.frame"
> fit<- lm (Murder ~ Population+Illiteracy+Income+Frost,data=state)
> summary(fit)

Call:
lm(formula = Murder ~ Population + Illiteracy + Income + Frost, 
    data = state)

Residuals:
    Min      1Q  Median      3Q     Max 
-4.7960 -1.6495 -0.0811  1.4815  7.6210 

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) 1.235e+00  3.866e+00   0.319   0.7510    
Population  2.237e-04  9.052e-05   2.471   0.0173 *  
Illiteracy  4.143e+00  8.744e-01   4.738 2.19e-05 ***
Income      6.442e-05  6.837e-04   0.094   0.9253    
Frost       5.813e-04  1.005e-02   0.058   0.9541    
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 2.535 on 45 degrees of freedom
Multiple R-squared:  0.567,	Adjusted R-squared:  0.5285 
F-statistic: 14.73 on 4 and 45 DF,  p-value: 9.133e-08
##“Illiteracy  4.143e+00”文盲率的回归系数是4.14,表示在人口、收入、温度不变的情况下,文盲率上升1%,谋杀率上升4.14%,且它的系数在P < 0.001的情况下显著不为0

返回值

> ls() #当前环境中R的对象
 [1] "a"          "airquality" "aql"        "aqw"       
 [5] "b"          "df"         "first"      "fit"       
 [9] "gdata"      "mtcars"     "second"     "state"     
[13] "tdata"      "x"         
> Sys.Date() #返回当前系统时间
[1] "2020-10-12"
> rm(a) #删除对象,如果成功则不出现返回值,否则会出现错误提示
> rm(t)
Warning message:
In rm(t) : object 't' not found
##注意返回值的类型,选用不同的适用函数处理这些类型
> ?heatmap #只能处理矩阵而不能处理数据框类型
> plot() #向量和向量绘制成散点图;向量和因子绘制成条形图;
输入数据类型适用函数

向量:sum,mean,sd,range,median,sort,order
矩阵或数据框:cbind,rbind
数字矩阵:heatmap


P42 选项参数

将选项参数类比于买菜:去买菜/买啥/买多少

名字概念
软件相当于菜市场菜篮子
选项相当于菜,选还是不选
参数相当于量,选多少

一般选项参数分为:

1、输入控制部分

常用输入选项参数:

file:接一个文件
data:一般指要输入一个数据框;
x:表示单独的一个对象,一般都是向量,也可以是矩阵或者列表;
x和y:函数需要两个输入变量;
x,y,z:函数需要三个输入变量;
formula:公式;多用”~“连接,表示相关
na.rm:删除缺失值;

在R的帮助文档中,经常可以在选项参数部分看见”…“符号,它一般表示:

1、 如plot选项参数中的”…“表示参数可传递,也就是这部分参数与其他函数的参数是相重合的,可以通用,尤其是在R的绘图函数中,跨函数的参数几乎都适用于其他绘图函数;有”…“出现的地方表示这里省略,详细可查看后面的链接,会有详细信息。

2、 有一些函数中”…“表示没有数量限制,比如data.frame可支持多个向量合并,rbindcbind也是同理,一次可以给数据框或者矩阵等添加多行或者多列

2、输出控制部分

一般在R中结果直接出现在图形界面,可供调节的参数较少

3、调节部分
  • 根据名字判断选项的作用

    color 选项和明显用来控制颜色
    select 与选择有关
    font与字体有关
    font.axis 就是坐标轴的字体
    Ity 是line type的简写
    lwd 是line width
    method 软件算法
    ……

  • 选项接受哪些参数

    main:字符串,不能是向量
    na.rm: TRUE或者FALSE
    axis: 控制坐标轴的方向,side参数只能是1到4
    fig:控制图形区域的位置,包含四个元素的向量

    包含row或者col的选项:表示行和列

    method:如果一个统计多种算法,一般都是通过message选项设置

    ……


P43 数学统计函数

> x <- 1:100
> sum(x) #求和
[1] 5050
> mean(x) #求平均值
[1] 50.5
> var(x) #方差
[1] 841.6667
> sd(x) #标准差
[1] 29.01149
> log(x) #取对数
  [1] 0.0000000 0.6931472 1.0986123 1.3862944 1.6094379 1.7917595 1.9459101 2.0794415 2.1972246 2.3025851 2.3978953 2.4849066 2.5649494 2.6390573 2.7080502 2.7725887
 [17] 2.8332133 2.8903718 2.9444390 2.9957323 3.0445224 3.0910425 3.1354942 3.1780538 3.2188758 3.2580965 3.2958369 3.3322045 3.3672958 3.4011974 3.4339872 3.4657359
……
> abs(x) #取绝对值
  [1]   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
……
  • 概率论

概率论是统计学的基础,R有许多用于处理概率,概率分布以及随机变量的函数。R对每一个概率分布都有一个简称,这个名称用于识别与分布相联系的函数。这部分涉及到很多统计学基础的理论知识,比如随机试验,样本空间,对立与互斥,随机事件与必然事件,概率密度,概率分布等。

字母含义
ddensity 概率密度函数
pdistribution 分布函数,因为d被密度函数占用,所以此处用p
qquantile 分布函数的反函数,分位数
rrandom 产生相同分布的随机数

给正态分布函数Normal加上前缀d/p/q/r就构成了在R中的函数名

dnorm(x, mean = 0, sd = 1, log = FALSE) 正态概率密度函数
pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) 正态分布函数
qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) 正态分位数函数
rnorm(n, mean = 0, sd = 1) 正态分布的随机数函数

##生成满足正态分布的一组数字
> rnorm(n=100,mean=15,sd=2) #生成均值为5,方差为2的100个随机数
  [1] 16.20994 13.86703 13.57459 17.59804 13.42786 14.81579 13.90097 13.66559 12.89780 14.32336 11.90792 14.13920 14.29006 12.13283 15.33791 18.00150 17.38731
 [18] 13.21296 13.47545 16.59991 16.15427 16.39127 15.29226 11.78472 15.90156 15.04438 11.67756 14.90671 16.86426 17.37126 14.13865 13.65865 13.15860 13.50412
 [35] 13.38559 16.48209 15.02913 14.19975 14.30231 14.69572 14.14901 15.64589 17.51535 13.16878 18.07479 14.31368 16.74095 16.46288 16.24363 16.03831 16.18030
 [52] 11.86904 11.79376 13.80910 12.48360 14.28414 16.19988 14.82331 16.40078 12.90084 15.28390 17.53258 13.21655 13.10790 15.12662 16.44574 18.14601 18.08835
 [69] 16.61745 18.23243 15.40259 13.84561 17.17225 17.18257 15.60987 12.78682 14.58842 14.25293 19.35957 15.03703 12.65416 10.27531 15.65968 18.58215 16.49182
 [86] 16.19389 12.07531 14.94625 16.81830 14.42129 15.90670 17.67030 14.71304 17.89933 17.71255 15.39059 17.55040 12.38186 16.34006 19.95524
> round(rnorm(n=100,mean = 15,sd=2)) #取整
  [1] 12 15 15 16 14 15 18 18 18 12 11 14 16 17 11 13 15 13 16 14 18 15 16 15 15 15 15 15 13 14 15 15 13 16 13 14 18 14 13 15 14 19 16 16 14 18 15 15 17 13 16 17 15
 [54] 17 18 12 13 15 19 16 15 16 15 15 14 16 16 16 15 17 14 14 13 16 17 16 14 19 14 18 20 11 14 16 18 17 14 15 16 18 17 16 14 14 16 17 15 13 14 14
> ?Geometric #几何分布
> ?Hypergeometric #超几何分布
####等等许多数学概率模型,可以用于检验数据集是否符合上述这些分布

##随机数的生成
runif(1)
runif(50)
runif(10)*10
runif(50,min=1,max=100)
dgamma(c(1:9),shape = 2,rate = 1)
set.seed(666)
runif(50)
runif(50)
set.seed(666)
runif(50)

P44 描述性统计函数 补笔记

> myvars <- mtcars[c("mpg", "hp", "wt", "am")]
> summary(myvars) #能一次得到以下几种统计数据
      mpg              hp              wt              am        
 Min.   :10.40   Min.   : 52.0   Min.   :1.513   Min.   :0.0000  #最小值
 1st Qu.:15.43   1st Qu.: 96.5   1st Qu.:2.581   1st Qu.:0.0000  #第一个四分位数
 Median :19.20   Median :123.0   Median :3.325   Median :0.0000  #中位数(即第二四分位数)
 Mean   :20.09   Mean   :146.7   Mean   :3.217   Mean   :0.4062  #数值型变量的均值
 3rd Qu.:22.80   3rd Qu.:180.0   3rd Qu.:3.610   3rd Qu.:1.0000  #第三四分位数
 Max.   :33.90   Max.   :335.0   Max.   :5.424   Max.   :1.0000  #最大值
> fivenum(myvars$mpg) #和上面的summary类似,输出除平均值以外的五个值
[1] 10.40 15.35 19.20 22.80 33.90

P45 频数统计函数

一维频数统计

描述不同组之间的差异等要用到频数统计,有因子才能分组,针对因子类型直接分组:

> mtcars
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4           Mazda RX4
2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4       Mazda RX4 Wag
3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1          Datsun 710
4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1      Hornet 4 Drive
5  18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2   Hornet Sportabout
6  18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1             Valiant
7  14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4          Duster 360
8  24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2           Merc 240D
9  22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2            Merc 230
10 19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4            Merc 280
11 17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4           Merc 280C
12 16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3          Merc 450SE
13 17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3          Merc 450SL
14 15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3         Merc 450SLC
15 10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4  Cadillac Fleetwood
16 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4 Lincoln Continental
17 14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4   Chrysler Imperial
18 32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1            Fiat 128
19 30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2         Honda Civic
20 33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1      Toyota Corolla
21 21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1       Toyota Corona
22 15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2    Dodge Challenger
23 15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2         AMC Javelin
24 13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4          Camaro Z28
25 19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2    Pontiac Firebird
26 27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1           Fiat X1-9
27 26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2       Porsche 914-2
28 30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2        Lotus Europa
29 15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4      Ford Pantera L
30 19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6        Ferrari Dino
31 15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8       Maserati Bora
32 21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2          Volvo 142E
> mtcars$cyl <- as.factor(mtcars$cyl) #cyl的4/6/8这几类可作为因子分组
> split(mtcars,mtcars$cyl) #split分组函数
$`4`
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb          Model
3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1     Datsun 710
8  24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2      Merc 240D
9  22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2       Merc 230
18 32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1       Fiat 128
19 30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2    Honda Civic
20 33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1 Toyota Corolla
21 21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1  Toyota Corona
26 27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1      Fiat X1-9
27 26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2  Porsche 914-2
28 30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2   Lotus Europa
32 21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2     Volvo 142E

$`6`
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb          Model
1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4      Mazda RX4
2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4  Mazda RX4 Wag
4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1 Hornet 4 Drive
6  18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1        Valiant
10 19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4       Merc 280
11 17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4      Merc 280C
30 19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6   Ferrari Dino

$`8`
    mpg cyl  disp  hp drat    wt  qsec vs am gear carb               Model
5  18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2   Hornet Sportabout
7  14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4          Duster 360
12 16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3          Merc 450SE
13 17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3          Merc 450SL
14 15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3         Merc 450SLC
15 10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4  Cadillac Fleetwood
16 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4 Lincoln Continental
17 14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4   Chrysler Imperial
22 15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2    Dodge Challenger
23 15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2         AMC Javelin
24 13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4          Camaro Z28
25 19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2    Pontiac Firebird
29 15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4      Ford Pantera L
31 15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8       Maserati Bora

针对非因子类型分组

##以mtcars中mpg这一列为例
> cut(mtcars$mpg,c(seq(10,50,10)))
 [1] (20,30] (20,30] (20,30] (20,30] (10,20] (10,20] (10,20] (20,30] (20,30] (10,20] (10,20] (10,20] (10,20] (10,20] (10,20] (10,20] (10,20] (30,40] (30,40] (30,40]
[21] (20,30] (10,20] (10,20] (10,20] (10,20] (20,30] (20,30] (30,40] (10,20] (10,20] (10,20] (20,30]
Levels: (10,20] (20,30] (30,40] (40,50]
> ?table # 进行频数统计,有一维列联表和多维列联表                                               > table(mtcars$cyl)

 4  6  8 
11  7 14 
> table(cut(mtcars$mpg,c(seq(10,50,10))))

(10,20] (20,30] (30,40] (40,50] 
     18      10       4       0 
> prop.table(table(mtcars$cyl)) #proportion比率=频数除以总数

      4       6       8 
0.34375 0.21875 0.43750 
> prop.table (table(cut(mtcars$mpg,c(seq(10,50,10)))))

(10,20] (20,30] (30,40] (40,50] 
 0.5625  0.3125  0.1250  0.0000
> prop.table(table(mtcars$cyl))*100 #频率✖100即所占百分比

     4      6      8 
34.375 21.875 43.750                       
多维频数统计
##多维频数统计
> library(grid)
> library(vcd)
> head(Arthritis)                         
  ID Treatment  Sex Age Improved
1 57   Treated Male  27     Some
2 46   Treated Male  29     None
3 77   Treated Male  30     None
4 17   Treated Male  32   Marked
5 36   Treated Male  46   Marked
6 23   Treated Male  58   Marked
> table(Arthritis$Treatment,Arthritis$Improved) #返回的是二维列联表
         
          None Some Marked
  Placebo   29    7      7
  Treated   13    7     21
> with(data = Arthritis,{table(Treatment,Improved)}) #变量多可以用with函数提前加载数据
         Improved
Treatment None Some Marked
  Placebo   29    7      7
  Treated   13    7     21    
> ?xtabs #处理二维列联表,可使用formula参数
> xtabs(~ Treatment+Improved, data=Arthritis)#~ Treatment+Improved表示根据这两个参数进行计算
         Improved
Treatment None Some Marked
  Placebo   29    7      7
  Treated   13    7     21  
> ?margin.table #边际频数统计,单独按照行或者列来统计处理(对于数组形式的列联表,请计算给定边距或一组边距的表项总和。)
> x <- xtabs(~ Treatment+Improved, data=Arthritis)
> margin.table(x) #不给定第二个参数则计算的是总和
[1] 84
> margin.table(x,1) # 1表示行总和row sums
Treatment
Placebo Treated 
     43      41 
> margin.table(x,2) # 2表示列总和colnum sums
Improved
  None   Some Marked 
    42     14     28 
> prop.table(x,1) #以行总和为分母计算频率
         Improved
Treatment      None      Some    Marked
  Placebo 0.6744186 0.1627907 0.1627907
  Treated 0.3170732 0.1707317 0.5121951                       
> addmargins(x) #将边际和添加到频数表中
         Improved
Treatment None Some Marked Sum
  Placebo   29    7      7  43
  Treated   13    7     21  41
  Sum       42   14     28  84
> addmargins(x,1) #同样可以设置只添加行或者列
         Improved
Treatment None Some Marked
  Placebo   29    7      7
  Treated   13    7     21
  Sum       42   14     28
> addmargins(x,2)
         Improved
Treatment None Some Marked Sum
  Placebo   29    7      7  43
  Treated   13    7     21  41

##三维列联表的频数统计
> x <- xtabs(~ Treatment+Improved+Sex, data=Arthritis)
> x
, , Sex = Female

         Improved
Treatment None Some Marked
  Placebo   19    7      6
  Treated    6    5     16

, , Sex = Male

         Improved
Treatment None Some Marked
  Placebo   10    0      1
  Treated    7    2      5
> ftable(xtabs(~ Treatment+Improved+Sex, data=Arthritis)) #转换成屏幕式更为简洁的列联表
                   Sex Female Male
Treatment Improved                
Placebo   None             19   10
          Some              7    0
          Marked            6    1
Treated   None              6    7
          Some              5    2
          Marked           16    5

P46 独立性检验函数

独立性检验是根据频数信息判断两类因子彼此相关或相互独立的假设检验。所谓独立性就是指变量之间是独立的,没有关系。

比如一种药物单独对男性起作用或者单独对女性起作用,这就是独立性,反之就是相关性

假设检验

假设检验(Hypothesis Testing)是数理统计学中根据一定假设条件由样本推断总体的一种方法。原假设——没有发生;备择假设——发生了;

具体作法是:根据问题的需要对所研究的总体作某种假设,记作HO;选取合适的统计量,这个统计量的选取要使得在假设HO成立时,其分布为已知;由实测的样本,计算出统计量的值,并根据预先给定的显著性水平进行检验,作出拒绝或接受假设HO的判断。

假设检验中两个假设的选取是个重要问题,通常应遵循以下原则:

  • 应当把如果它成立但是误判为不成立时后会造成严重后果的命题选为原假设。

    例如,要检验治疗心脏病的药是否有效。原假设应当选为该药无效,因为如果该药本身的确是无效的,但是误判为有效,那么心脏病人急用时因为它无效会造成病人死亡,这属于严重后果。

  • 应当把分析人员想证明它正确的命题作为备择假设,把分析人员努力证明它不正确的命题作为原假设.

    例如,据说有一种新方法可能够改进生产效率,我们想知道这是否是真的。我们希望这是真的,并努力证明这是真的,所以应把这种新方法能改进生产效率作为备择假设。

  • 应当把大众普遍认为它成立的命题作为原假设。因为原假设不能轻易拒绝,除非有足够的证据表明它不对。

    例如,据说跑步有益健康,我们想知道这是否是真的。因为是常识,所以应把跑步有益健康选作原假设。

p-value

p-value就是Probability的值,它是一个通过计算得到的概率值,也就是在原假设为真时,得到最大的或者超出所得到的检验统计量值的概率。
一般将p值定位到0.05,当p<0.05拒绝原假设,p>0.05,不拒绝原假设。

原假设:研究者想收集证据予以反对的假设。
备择假设:研究者想收集证据予以支持的假设。

总而言之,P值越大越靠谱(符合原假设),越小越不靠谱

P值可根据数据噪音大小调整,背景噪音大临界值可以是0.1,对于要求精确的数据临界值可以是0.01

卡方检验

卡方检验是一种用途很广的计数资料的假设检验方法。它属于非参数检验的范畴,主要是比较两个及两个以上样本率( 构成比)以及两个分类变量的关联性分析。其根本思想就是在于比较理论频数和实际频数的吻合程度或拟合优度问题。

通俗解释就是检验两个参数之间有没有关系

> library(grid)
> library(vcd)
mytable <- table(Arthritis$Treatment,Arthritis$Improved) #依然以风湿病数据集为例,H0:变量之间独立
> ?chisq.test #列联表的卡方检验与拟合
> chisq.test(mytable)

	Pearson's Chi-squared test

data:  mytable
X-squared = 13.055, df = 2, p-value = 0.001463  
##原假设是没有效果,这里P值小于0.05,说明有效
> mytable <- table(Arthritis$Sex,Arthritis$Improved)
> chisq.test(mytable)

	Pearson's Chi-squared test

data:  mytable
X-squared = 4.8407, df = 2, p-value = 0.08889 #P值大于0.05,说明Sex和Improved两个因素可能独立

Warning message:
In chisq.test(mytable) : Chi-squared近似算法有可能不准

Fisher精确概率检验

Fisher精确概率检验是用来判断两bai个变量之间是否存du在非随机相关性zhi的一种统计学检验方法。

> mytable <- xtabs(~Treatment+Improved, data=Arthritis)
> fisher.test(mytable)

	Fisher's Exact Test for Count Data

data:  mytable
p-value = 0.001393  ##和卡方检验的P值0.0014稍有出入,但都小于0.05,说明变量不独立,拒绝原假设
alternative hypothesis: two.sided
Cochran-Mantel-Haenszel检验
> ?mantelhaen.test #假设不存在三向交互作用,则对两个标称变量在每个层中有条件独立的零值执行Cochran-Mantel-Haenszel卡方检验。(即三个变量相互独立,进行检验)
> mytable <- xtabs(~Treatment+Improved+Sex, data=Arthritis)
> mytable
, , Sex = Female

         Improved
Treatment None Some Marked
  Placebo   19    7      6
  Treated    6    5     16

, , Sex = Male

         Improved
Treatment None Some Marked
  Placebo   10    0      1
  Treated    7    2      5

> mantelhaen.test(mytable)

	Cochran-Mantel-Haenszel test

data:  mytable
Cochran-Mantel-Haenszel M^2 = 14.632, df = 2, p-value
= 0.0006647  ##P值小于0.005,拒绝原假设,三个变量不独立

> mytable <- xtabs(~Treatment+Sex+Improved, data=Arthritis) #调换变量顺序会出现不同结果
> mantelhaen.test(mytable)

	Mantel-Haenszel chi-squared test with continuity
	correction

data:  mytable
Mantel-Haenszel X-squared = 2.0863, df = 1, p-value =
0.1486
alternative hypothesis: true common odds ratio is not equal to 1
95 percent confidence interval:
 0.8566711 8.0070521
sample estimates:
common odds ratio 
         2.619048 

> mytable #出现不同结果的原因是分组依据上的变化
, , Improved = None

         Sex
Treatment Female Male
  Placebo     19   10
  Treated      6    7

, , Improved = Some

         Sex
Treatment Female Male
  Placebo      7    0
  Treated      5    2

, , Improved = Marked

         Sex
Treatment Female Male
  Placebo      6    1
  Treated     16    5

课程外=

Mann-Whitney U 检验是用得最广泛的两独立样本秩和检验方法。简单的说,该检验是与独立样本t检验相对应的方法,当正态分布、方差齐性等不能达到t检验的要求时,可以使用该检验。其假设基础是:若两个样本有差异,则他们的中心位置将不同。

P47 相关性分析函数

相关性分析是指对两个或多个具备相关性的变量元素进行分析,从而衡量两个变量因素的相关密切程度。相关性的元素之间需要存在一定的联系或者概率才可以进行相关性分析。简单来说就是变量之间是否有关系。

相关性衡量指标:Pearson相关系数、Spearman相关系数、Kendall相关系数、偏相关系数、多分格(polychoric)相关系数和多系列(polyserial)相关系数

> ?cor #var,cov和cor计算x的方差以及x和y的协方差或相关性(如果它们是向量)。 如果x和y是矩阵,则计算x列与y列之间的协方差(或相关性)。可选是否删除NA以及选用哪种相关系数进行衡量。
> cor(state.x77)
            Population     Income  Illiteracy    Life Exp     Murder     HS Grad      Frost        Area
Population  1.00000000  0.2082276  0.10762237 -0.06805195  0.3436428 -0.09848975 -0.3321525  0.02254384
Income      0.20822756  1.0000000 -0.43707519  0.34025534 -0.2300776  0.61993232  0.2262822  0.36331544
Illiteracy  0.10762237 -0.4370752  1.00000000 -0.58847793  0.7029752 -0.65718861 -0.6719470  0.07726113
Life Exp   -0.06805195  0.3402553 -0.58847793  1.00000000 -0.7808458  0.58221620  0.2620680 -0.10733194
Murder      0.34364275 -0.2300776  0.70297520 -0.78084575  1.0000000 -0.48797102 -0.5388834  0.22839021
HS Grad    -0.09848975  0.6199323 -0.65718861  0.58221620 -0.4879710  1.00000000  0.3667797  0.33354187
Frost      -0.33215245  0.2262822 -0.67194697  0.26206801 -0.5388834  0.36677970  1.0000000  0.05922910
Area        0.02254384  0.3633154  0.07726113 -0.10733194  0.2283902  0.33354187  0.0592291  1.00000000
##在R中进行相关性的计算很容易,但关键在于分析,也就是数据的挖掘,比如计算得到的结果这是一个典型的斜对角数据集,相关性的区间[-1,1],每个因素跟自己比较相关性都是1,比如看Murder这一列,跟收入Illiteracy的相关性达到0.7,以及跟高中毕业与否HS Grad因素相关性达到0.58,都有很强的相关关系,说明教育程度和谋杀存在关联
评论 1 您还未登录,请先 登录 后发表或查看评论
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页

打赏作者

twocanis

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值