R语言笔记-WHU

985本硕/综合本院优秀老师课件/轻松拿下R语言满绩/笔考机考均适用，数据科学是使用科学方法从数据中获取知识的科学。

引言

• 数据科学简介
  • 什么是数据科学
    • 定义
      • 数据科学是使用科学方法从数据中获取知识的科学
    • 三方面
      • 统计学
        • 统计学是数据科学的核心，因为数据科学的科学性是由统计学体现的
      • 计算机科学
        • 运用计算机能力成为数据科学中最重要的技能
      • 领域知识
        • 行业里的分析经验，在此专指不依赖于计算机程序和统计模型的经验
    • 两两交叉
      • 机器学习：统计学+计算机科学
      • 传统数据分析：统计学+领域知识
      • 商业智能：计算机科学+领域知识
    • 三者的完美结合就是数据科学
• R语言简介
  • 优势
    • 数据分析功能强大
    • 编程简单
    • 整合能力强：多数据接口
    • 实现了可重复性分析：自动生成分析报告
    • 开源和免费
    • 跨平台：可以在多种操作系统下运行
    • 更新快速且文档完备
  • 缺点
    • 某些方面效率低下：不支持多线程
    • 单机环境下大数据处理能力不强
    • 没有一套完美的语言体系
    • 第三方包的质量良莠不齐
• R的使用
  • R的基本使用
    • 1console 控制台
    • 2R语言是区分大小写的解释性语言（x与X代表不同的变量），在命令提示符>后输入命令后敲回车键，R会自动输出结果
    • 3R操作的规律就是命令式操作，基本上R中所有操作是函数加对象方式
    • 4R中的多数功能是由程序内置函数、用户自编函数、对对象的创建和操作所提供的的
    • 5在R中，万物皆对象，即无论是函数还是数据都是对象；将对象赋值给变量，就可以通过变量名进行调用和操作
    • 6一个对象可以是任何能被赋值的东西，数据、函数、图形、分析结果.....
    • 7每一个对象都有一个类属性，类属性可以告诉R怎么对之进行处理
    • 8R语句由函数和赋值构成，赋值符号<-,而不是传统的=作为赋值符号
    • 9注释由符号#开头，在#之后出现的任何文本都会被R解释器忽略
    • 10计算机程序里的变量对应了一块内存空间，其中可以存储不同的值
  • 管理包
    • 包
      • 包是R函数、数据、预编译代码以一种定义完善的格式组成的集合
    • 库
      • 计算机上存储包的目录称为库（library)
    • 管理包的函数
      • 安装包和移除包
        • install.packages("knitr")
        • remove.packages("knitr)或者到library目录中删除该子文件夹
      • 更新包、查看已安装的包
        • update.packages()
        • installed.packages()
      • 查看和更改包的安装路径
        • .libPaths(）
        • .libPaths("c:/rlib")
      • 载入、查看、卸下包
        • library("knitr")
        • help(package="knitr")
        • detach(package:"knitr")
  • 工作目录和工作空间
    • 工作目录(working directory)
      • 定义：工作目录是R用来读取文件和保存结果的默认目录。操作R时有一个默认的工作目录，在该目录下的文件可以直接访问，否则需要输入完整路径
      • 查看当前的工作目录：getwd()
      • 设定当前的工作目录：setwd()
      • 如果需要读入一个不在当前工作目录下的文件，则需在调用语句中写明完整的路径
      • 补：工作目录与安装路径
        • 均是指电脑里某个硬盘下的文件夹
        • 但是一般把软件安装包单独放到一个文件夹里
    • 工作空间workspace
      • 定义：工作空间就是当前R的工作环境，它存储着所有用户定义的对象
      • 在一个R会话结束时，你可以将当前工作空间保存到一个镜像中，并在下次启动R时自动载入它
      • 每次退出R之前会提示是否保存工作空间。如果选择是，就会默认当前工作空间作为一个镜像，存在工作目录下一个默认名为“.Rdata"的文件中，并在下次启动R时自动载入它
      • 可以使用save.image()函数来指定保存的文件名
      • 一般不建议保存工作空间，最好是把代码脚本保存下来，下次启动后重新运行一遍即可
  • R语言编程中的常见错误
    • 使用了错误的大小写
    • 忘记使用必要的引号
    • 在函数调用时忘记使用括号，即使无需参数也应该加上（）
    • 在windows上，路径使用了“\",应该是”/“或”\\“
    • 使用了一个尚未载入包中的函数

编程基础

• 对象与函数
  • R的用户界面
    • R和RStudio是与计算机对话的两个工具
    • 在RStudio控制台中利用R语言编写一个命令，并让计算机执行该命令，真正去执行这个任务的是计算机而不是R
    • R是一种动态编程语言，意味着在运行R代码时，编译操作会由R自动完成
    • 键入的代码称作命令；键入代码所在的行称做命令行
    • 【】用中括号内嵌数字来标示每一行的起始数值在整个返回结果中的序号
    • 冒号运算符（：）表示返回两个整数值之间的所有整数
    • +表示R在等待你键入接下来的命令，即命令没有完成，也可以按Ese键中断命令进入下一个命令
    • 终止程序的运行：Ctrl+C
  • 对象：存储数据
    • 保存操作在R中叫做创建一个R对象
      • 创建一个对象，先确定一个名称，然后使用赋值符将数据赋值给它
    • 对象的命名规则
      • 变量名由字母、数字、下划线"_"和“.”组成
      • 对象名不能以数字开头
      • 一些特殊符号不能在名称中出现
      • R区分大小写，name和Name时两个不同的对象
    • 注
      • 同一个对象如果再次被赋值的话，R就会自动覆盖存储在对象中的信息
      • 只要是在命令中出现了一个R对象的名称，R在执行时处理的就会是该对象所存储的数据
      • R使用元素方式执行，当对一个数字集执行操作时，R会将相同的运算运用于该数字集中的每个元素
      • 如果要使用矩阵运算，需要用特别的运算符
    • 对对象的一些常见操作
      • 查看已命名的对象ls()
      • 从内存中移除对象remove(）或rm()
      • 将内存中所有对象移除remove(list=ls(）)
  • 函数：操作数据
    • 函数
      • 函数使用方法：将函数的名称敲出来并在其后的括号中键入相应的数据
      • R函数的执行方式是从内到外
    • 参数
      • 传递到函数中的参数称为该函数的参数
      • 参数可以是原始数据、R对象、另一个R函数的返回值
      • 需要设置哪个数据对象赋值给该函数的哪个参数：将这个数据对象与参数名用等号=连起来
      • 如果没有写出参数名称，那么R会按顺序将你的值与函数中的参数匹配，没明确赋值的用默认值
• 帮助页面
  • 每个R函数都有自己的帮助页面，只需要键入问号+一个函数的名称就可以查看该函数的帮助页面
    • ?keyword
    • help("keyword")
  • 忘记函数的确切名称，可以尝试关键词搜索，即：两个问号+关键词
    • ??keyword
    • help.search("keyword")
  • 帮助页面的组成
    • description函数描述：一段简短的有关该函数功能的描述
    • usage使用方法：告诉该如何键入该函数和相应的参数名
    • arguments参数：列出该函数所包含的所有参数
    • details相关细节：关于函数原理的进一步描述
    • value返回值：关于该函数运行后返回值的描述
    • see also另请参阅：与该函数相关的函数列表
    • examples代码示例：确保无错运行的代码示例
• 定义环境
  • R脚本
    • R脚本是用来保存R代码的纯文本文件
    • 单机脚本面板，在菜单栏上选择file-save as（或者直接按保存键）,即可保存脚本
  • 定义环境重要性
    • 通过自定义启动环境可以设置R选项，设置工作目录，加载常用的包，加载用户编写的函数，设置默认的CRAN下载网站以及执行其它各种常见任务
    • 可以通过站点初始化文件（Rprofile.site）或目录初始化文件（.Rprofile）自定义R的环境，R在启动时会执行这几个文本文件中的代码
  • 在脚本中定义环境
    • 在不同项目脚本中个性化定义环境
      • 为每个项目建立单独的文件夹和子文件夹
      • 在脚本中首先储存下初始的环境
      • 定义项目环境
        • 工作目录
        • 清除已有变量，释放内存
        • 载入需要的包
        • 定义数据
      • 在脚本最后恢复环境
        • 清除变量
        • 恢复工作目录
  • 利用RStudio定义环境
    • 定义全局环境：在RStudio中在菜单栏中依次点击tools-global options
    • 建立新项目，将与该项目相关的数据、脚本、分析结果和图表放在一起：在RStudio中在菜单栏中依次点击files-new project
    • 定义项目环境：在RStudio中在菜单栏中依次点击tools-project options

图形初步

• 创建和保存图形
  • 图形构建
    • plot()最基本的作图函数
      • 使用方法plot(x,y,type=" ")
      • 参数type
        • p:points 点
        • l:lines线
        • b:both点连线
        • c线断电
        • o:点重线
    • 图形及其函数
      • 点 points() :向基本图形中添加点
      • 线
        • abline()向图形添加直线
        • lines()向图形添加各种线条，直线或曲线
      • 条形图barplot
      • 饼图pie()
      • 直方图hist()
      • 箱型图boxplot()
  • 保存图形
    • 通过图形化界面保存：点击plot面板的export按钮
    • 通过代码保存
      • 步骤
        • 打开一个图形设备
          • 常见的图形设备
            • bmp(filename.bmp)
            • pdf(filename.pdf)
            • png(filename.png)
            • jpeg(filename.jpg)
            • win.metafile(filename.wmf)
          • 图形设备语句:file<-paste(nwd,"/out/tuxing.pdf",set="") pdf(file) 解释：paste()函数连接字符串，nwd工作目录，out工作目录下的子文件夹，tuxing文件名，pdf文件类型，set=""连接符
        • 画图
        • 关闭图形设备dev.off(）
• 图形参数
  • 图形参数概述
    • 方法一：通过par()函数来指定选项；相当于一个全局变量，因此一般会先保存最后再回复初始的图形参数 即opar <- par(no.readonly = TRUE) par(opar)
    • 方法二：通过高级绘图函数（如plot）中的图形参数来赋值，但并不是所有的高级绘图函数都允许指定全部可能的图形参数
  • 点线参数
    • pch:指定绘制时使用的符号，有0-25
    • cex:指定符号的大小；以默认值的相对大小来表示，默认大小为1；1.5表示放大为默认值的1.5倍
    • lty:指定线条类型；有1-6六种
    • lwd:指定线条宽度，以默认值的相对大小来表示，默认大小为1；lwd表示将生成一条两倍于默认宽度的线条
  • 颜色参数
    • 函数colors()可以返回所有可用颜色的名称
    • 参数
      • col默认的绘图颜色 col="green"
      • col.axis坐标轴刻度文字的颜色
      • col.lab标签（名称）的颜色
      • col.main标题颜色
      • col.sub副标题颜色
      • fg图形的前景色
      • bg图形的背景色
  • 文本参数
    • 控制文本大小的参数
      • cex文本的大小，表示相对于默认大小缩放倍数的数值
      • cex.axis坐标轴刻度文字的缩放倍数
      • cex.lab坐标轴标签名称的缩放倍数
      • cex.main标题的缩放倍数
      • cex.sub副标题的缩放倍数
    • 控制字体族和字样的参数
      • front指定绘图使用的字体样式：1=常规，2=粗体，3=斜体，4=粗斜，5=符号字体
      • front.axis坐标轴刻度文字的字体样式
      • front.lab坐标轴标签名称的字体样式
      • front.main标题的字体样式
      • front.sub副标题的字体样式
  • 图形尺寸与边界尺寸
    • 控制图形尺寸和边界大小的参数
      • pin以英寸表示的图形尺寸（宽和高）；pin=c(4,3)，4寸宽3寸高
      • mai以数值向量表示的边界大小，顺序为“下左上右”，单位为英寸；mai=c(1,.5,1,.2)上下边界为1英寸，左边界为0.5英寸，右边界为0.2英寸的图形
      • mar以数值向量表示的边界大小，顺序为“下左上右”，单位为英分，默认值为c(5,4,4,2)+0.1
• 添加文本、自定义坐标轴和图例
  • 标题
    • 使用title()函数为图形添加标题和坐标轴标签
      • Usage :title(main="",sub="",xlab="",ylab="")
      • 函数title中也可以指定其它图形参数（如文本大小、字体...）
  • 坐标轴axis
    • 使用函数axis()来创建自定义坐标轴
      • axis(side=,at=,labels,pos=,lty=,col=,las=)
      • 参数
        • side表示在图形的哪边绘制坐标轴1=下，2=左，3=上，4=右
        • at需要绘制刻度线的位置
        • labels置于刻度线旁边的文字标签
        • pos坐标轴线绘制位置的坐标即与另一条坐标轴相交位置的值
        • lty线条类型
        • col线条与刻度线颜色
        • las标签平行于（=0）或垂直于（=2）坐标轴
        • tck刻度线的长度，以相对于绘图区域大小的分数表示
      • 注意
        • 创建自定义坐标轴时，应当禁用高级绘图函数自动生成的坐标轴
        • 参数axes=FALSE将禁用全部坐标轴（包括坐标轴框架线）除非添加了参数frame.plot=TRUE
        • 参数xaxt=“n"和yaxt="n"将分别禁用x轴和y轴（会留下框架线，只是除去了刻度）
        • 要创建次要刻度线需要使用Hmisc包中的minor.tick()函数
  • 参考线
    • 函数abline()可以用来为图形添加参考线；abline(a=,b=)向图形中添加直线 a代表纵截距 b代表斜率
  • 图例
    • 函数legend（）来添加图例
  • 文本注释
    • 函数text(）可向绘图区域内添加文本 text(location,"text to place",pos,...)
    • 函数mtext(）则向图形的四个边界之一添加文本 text("text to place",side,line=n,...)
• 图形的组合
  • 使用par()来组合图
    • mfrow=c(nrows,ncols)按行填充图形矩阵
    • mfcol=c(nrows,ncols)按列填充图形
  • 使用layout来组合函数
    • layout(mat)其中的mat是一个矩阵，它指定了所要组合的多个图形的所在位置
    • 可以更精确地控制每副图形的大小，可以有选择地在layout()函数中使用widths=和heights=两个参数
  • 图形布局的精细控制
    • 使用图形参数fig=完成图形布局的精细控制；参数fig=的取值是一个形如c（x1,x2,y1,y2）的数值向量

ggplot2

• 总述：在ggplot2中:图是用加号将多个函数串联起来而创建，每个函数负责修改属于自己的一部分
• 一般方法：ggplot()+geom_*()+分面函数（可选）+修饰函数（可选）+坐标系函数
  • 允许出现多个几何函数geom_*(),每个几何函数代表一个图层，多个图层可以相互叠加
• 详情
  • ggplot()
    • 作用：创建一个坐标系，可以在上面添加图层
    • 用法：ggplot(data= ,mapping=aes(x= ,y= ))
    • 参数
      • data : 用于指定绘图时使用的数据框
      • aes:用于指定横轴、纵轴等使用的变量；aes()内的参数与几何函数相配合；对不同的几何函数，aes()内的参数有所不同
    • 补：ggplot(data=mpg)会创建一张空白图
  • 几何函数geom_*()
    • 作用：用于绘制图形
    • 几何函数
    • 常见的几何函数
      • geom_point()
        • 作用：用于绘制点图
        • 使用：可以指定点的符号shape、颜色color、尺寸size等
        • 过绘制
          • 原因：geom_point()会将坐标值进行取整
          • 现象：当图中点很多时，可能发生多个点彼此重叠，导致在图看到的数量小于数据点的数量，该问题称为过绘制
          • 解决
            • 在geom_point()中设置position="jitter",即为每个点添加一个很小的随机扰动，这样就可以让重叠的点散开
            • 影响：这种方式会损失图的精确性，但可提高图的启发性
            • 例：ggplot(data=mpg,mapping=aes(x=displ,y=hwy))+ geom_point(position="jitter")
        • 注：如果绘图数据中含有NA值，geom_point()会忽略这些点，同时给出一条warning信息；不想看到warning信息，可以使用geom_point( ,na.rm=TRUE)
      • geom_line()
        • 作用：用于绘制线图
        • 可选参数：线的颜色color、线型linetype、线的粗细size等
        • 例：ggplot(data=cars,mapping=aes(x=speed,y=dist))+ geom_line(linetype=1,size=1,color="blue")
        • 注：需要有个变量是连续型变量，若两个变量都是分类变量（且是一对一的关系），则需要在aes()里加上group=1
      • geom_bar()
        • 作用：用于绘制条形图
        • 变量（特殊）：只需指定横轴变量（必须为离散型变量，即因子型的列或字符串的列）；纵轴的值会根据横轴变量的值计算出来，不需要指定纵轴变量，因此在ggplot()中，aes只需要指定x参数
        • 可选参数
          • width:表示每个条形的宽度，标准宽度为1
          • color:表示每个条形的外边框颜色
            • 补：color与fill区别
              • 空心形状的边界颜色由color决定
              • 实心形状的边界颜色由fill决定
              • 填充形状的边界颜色由color决定，填充颜色由fill决定
          • fill、alpha:表示每个条形内的填充色和色彩饱和度；alpha=0表示完全透明、alpha=1表示完全实色
          • 改变统计方式
            • stat
              • 默认情况下，stat的值为“count”,此时，geom_bar()会统计每个组的行数作为各条形图的高度
              • 若设置stat="identity"，且在aes（)中指定一个y值，那么将会统计各组y值的和作为各条形的高度；而每个条形由多个小格堆叠而成，每个小格的高度由y值决定，条形的总高度由y的和决定
              • 例1： a<-c("China","USA","British","German"); b<-c(35,23,57,15); mydata<-data.frame(country=a,score=b）ggplot(data=mydata,mapping=aes(x=country,y=score))+ geom_bar(stat="identity",width=0.4)
              • 例2： ggplot(data=mtcars,mapping=aes(x=factor(cyl),y=wt))+ geom_bar(stat="identity",width=0.4,color="red",fill="blue",alpha=0.2)
            • weight
              • 绘制条形图时，默认情况是各条形的高度等于每组的行数
              • 参数weight表示每一行的权值
              • 如果为weight赋值，那么各条形的高度将等于每组中各行的权值之和
              • 例(与stat例2基本同图)： ggplot(data=mtcars,mapping=aes(x=factor(cyl),weight=wt))+ geom_bar(width=0.4,color="red",fill="blue",alpha=0.2)
            • 两者区别：stat可以将每个条形分成多个小格，而weight的每个条形都是一个整体
        • 两个统计量
          • geom_bar()在绘图过程中，对每个条形图会计算出两个统计量
            • count：每个条形的点数
            • prop:表示在分组内每个条形的点数所占比例
          • 作用：可以作为纵坐标，即条形图的高度
          • 使用：为与数据源中的变量相区别，这些统计量的名字要前后加上两个点，或者将含有这些统计量的表达式放入函数stat()中
          • 例
            • 1.ggplot(data=diamonds,mapping=aes(x=cut))+ geom_bar() #默认count为纵坐标,显示每种切割质量的钻石的数量
            • 2.ggplot(data=diamonds,mapping=aes(x=cut,y=stat(count/max(count)))+ geom_bar() #显示每种切割质量的钻石的相对比例
            • 3.ggplot(data=diamonds,mapping=aes(x=cut,y=..prop..,group=1))+ geom_bar() #显示每种切割质量的钻石所占的比例
              • 比例条形图需要设定group=1
              • 若想在此图基础上，对每个cut的值以color进行填充，则需要添加fill=color,group=color
            • 以上三种条形图的形状相同，只是纵坐标的尺度不同
        • 如何调整横坐标轴上各条形的顺序
          • 条形图的横轴对应着一个因子型或字符串型的列，各条形按照因子的水平值由小到大排列，或按照字母顺序由小到大排列
          • 若横轴对应着一个因子列，那么只需要调整因子的水平值顺序即可调整各条形的顺序
          • 例：a<-c("China","USA","German","British") ； a<-factor(a,levels=c("China","German","British","USA")) #指定各水平值的顺序
        • 注：默认情况下，垂直绘制条形，但可以用coord_filp()将条形调整成水平
        • 例：ggplot(data=mtcars,mapping=aes(x=factor(cyl)))+ geom_bar(width=0.5,fill="red")+ coord_filp()
      • geom_histogram()
        • 作用：绘制直方图
        • 变量（特殊）：只需要指定横轴变量，因此在ggplot()中只需要指定x参数变量
        • x参数：既可以使用离散型变量也可以使用连续性变量
        • 常用参数
          • color,fill,alpha,weight,stat
          • bins,binwidth（只对连续型变量有效)
            • 对连续性变量：geom_histogram()会自动将横轴划分为多个区间，统计每个小区间内点的数量作为纵坐标值
            • 对离散型变量：geom_histogram()会把每个x值作为一个条形，不需要划分统计区间
            • 作用：帮连续型变量划分统计区间
            • 例：ggplot(data=diamonds,mapping=aes(x=carat))+ geom_histogram(color="white",fill="red",bins=50) #将x轴划分为50个小区间
        • 对离散变量的直方图
          • geom_histogram()与geom_bar()功能基本相同，但是在调用geom_histogram()时需要使用参数stat="count"
          • 例：ggplot(data=mtcars,mapping=aes(x=factor(cyl),y=wt))+ geom_histogram(stat="identity",width=0.4,color="red",fill="blue",alpha=0.2) #与stat例2同图
        • 对连续型变量的直方图
          • geom_histogram()会将横轴划分成若干小区间（成为分箱bin）
          • geom_histogram()会对每个分箱计算出四个统计量
            • 四个统计量
              • count
                • 表示每个分箱内点的数量
                • 例：ggplot(data=diamonds,mapping=aes(x=carat))+ geom_histogram(fill="red",bins=50)
              • ncount
                • 表示每个分箱内点数的相对比例，就是将所有的条形都进行同比例缩放，使得点数最多的条形高度为1
                • 例：ggplot(data=diamonds,mapping=aes(x=carat,y=..ncount..))+ geom_histogram(fill="red",bins=50)
              • density
                • 表示每个分箱的概率密度，就是将所有的条形图都进行同比例缩放，使得所有条形的总面积为1
                • 例：ggplot(data=diamonds,mapping=aes(x=carat,y=..density..))+ geom_histogram(fill="red",bins=50)
              • ndensity
                • 表示每个分箱的相对频率，实际上与ncount计算值相同
                • 例：ggplot(data=diamonds,mapping=aes(x=carat,y=stat(ndensity)))+ geom_histogram(fill="red",bins=50)
            • 作用：可以使用这些统计量作为纵坐标即条形的高度；为与数据源中的变量相区别，这些统计量的名字前后要加上两个点，或者将含有这些统计量的表达式放入函数stat(）中
          • 默认情况下，会使用每个分箱内点的数量作为该分箱条形的高度
      • geom_freqpoly()
        • 作用：绘制折线
        • 与geom_histogram()作用相同，只是不绘制条形，而是使用折线
        • 例：ggplot(data=diamonds,mapping=aes(x=carat))+ geom_histogram(color="white",fill="red",bins=50)+ geom_freqpoly(color="blue",size=1.5,bins=50)
      • geom_boxplot()
        • 作用：用于绘制箱线图
        • 变量
          • 同时需要横坐标变量和纵坐标变量
          • 特殊：横坐标变量应当是离散型变量（字符串或因子）
        • 原理
        • 例：ggplot(data=mtcars,mapping=aes(x=factor(cyl),y=wt))+ geom_boxplot()
        • 补：若要使用连续型变量作为横坐标，那么需要对连续型变量进行分组
          • 做法：借助grooup参数和cut_width()函数
          • 例：ggplot(data=diamonds,mapping=aes(x=carat,y=depth,group=cut_width(carat,0.1)))+ geom_boxplot()+ xlim(NA,2.05) #根据钻石重量carat分组，每组宽度为0.1；用箱线图显示每组钻石的depth的分布
      • geom_smooth()
        • 作用：添加一系列的平滑曲线和置信区间
        • 常用参数
          • method:使用的平滑函数
            • 允许的值
              • lm:线性
              • glm:广义线性
              • smooth:默认值
              • rlm
              • gam
              • loess
          • formula:在平滑函数中使用的公式
            • y~x:默认
            • y~log(x)
            • y~ploy(x,n)
              • 表示n次多项式
              • 例：method="lm" ,formula=y~(x,2) #表示使用x的二次多项式来表示y，即拟合曲线为y=a+bx+cx^2
            • y~ns(x):表示自由度为n的样条拟合
          • se:是否绘制置信区间，默认值为TRUE
          • level:置信区间的水平，默认值为95%
          • linetype:线型
          • size:线的粗细
          • color:线的颜色
          • fill:填充区的颜色
          • alpha:色彩饱和度（alpha=0表示完全透明；alpha=1表示完全不透明）
          • fullrange:拟定是否应当涵盖全图，默认值为FALSE
        • 例：ggplot(data=cars,mapping=aes(x=speed,y=dist))+ geom_smooth(method="lm")
      • geom_density()
        • 作用：绘制密度函数
        • 变量：仅需要横坐标变量
        • 例：ggplot(data=mtcars,mapping=aes(x=wt))+ geom_density(fill="blue",color="white")
      • geom_count()
        • 作用：用于绘制两个离散变量的各种组合出现的次数，用点的大小表示次数的多少
        • 例：ggplot(data=diamonds,mapping=aes(x=cut,y=color))+ geom_count(color="blue",alpha=0.3)
      • geom_tile()
        • 作用：用于绘制两个离散变量的各种组合出现的次数，用色块的颜色表示次数多少
        • 例：diamonds%>%conut(color,cut)%>% ggplot(mapping=aes(x=cut,y=color,fill=n))+ geom_tile()
    • 补
      • geom_jitter()
        • 例：ggplot(data = mpg, mapping = aes(x = cty, y = hwy, color = class)) + geom_jitter()
        • 参数
          • height
          • width
  • 分面函数
    • 作用：将若干幅图形组成一个矩阵形式（称为分面）；这种矩阵图称为分面图
    • 注：分面函数应该放在几何函数之后
    • 两个函数
      • facet_wrap(~var,nrow|ncol)
        • 通过单个变量对图进行分面
        • 作用：可指定分面图的行数或列数
        • 参数
          • var:因子变量，每个因子水平将绘制一幅图;离散型
          • nrow:指定分面的行数；ncol:指定分面的列数（二者选其一）
        • 也可以实现对多个离散型变量进行组合再对图形进行分面 ~var1+var2+...
      • facet_grid(rowvar~colvar)
        • 作用：可绘制两个因子组成的分面图（通过两个变量对图进行分面）
        • 参数
          • rowvar
            • 行变量，必须为因子
            • 若省略即用.代替，那么分面就只有一行
          • colvar
            • 列变量，必须为因子
            • 若省略用.代替，那么分面图将只有一列
      • 标度控制
  • 修饰函数
    • 作用：用于修改图形的标题、坐标轴、图例等
    • 常见的几种修饰函数
      • labs(title="", x="", y="")
        • 作用：可修改图名title、坐标轴名x、y
        • 例：ggplot(data=cars,mapping=aes(x=speed,y=dist))+ geom_point(shape=17)+ +labs(title="速度与刹车距离的关系",x="速度",y="刹车距离")
        • 补：也可以分别使用ggtitle()、xlab()、ylab()分别修改图名、横坐标名、纵坐标名
      • 坐标轴
        • 取连续值的坐标轴，用于表示数值向量
          • 函数
            • scale_x_continuous(breaks,labels,limits)
            • scale_y_continuous(breaks,labels,limits)
            • 参数
              • breaks:表示坐标轴上的刻度值
              • labels:表示各刻度的标签
              • limits:用于设置坐标轴的取值范围 例：limits=c(0,10)
        • 取离散值的坐标轴，用于表示因子
          • 函数
            • scale_x_discrete(breaks,labels)
            • scale_x_discrete(breaks,labels)
        • 例：ggplot(data=Salaries,mapping=aes(x=rank,y=salary))+ geom_boxplot()+ scale_x_discrete(breaks=c("AssProf","AssocProf","Prof"),labels=c("助教","副教授","教授"))+ scale_y_continuous(breaks=c(50000,100000,150000,200000),labels=c("$50K","$150K","$200K"))
      • 主题theme
        • 函数：theme()
          • 作用：用于控制图形的绘制参数，包括背景色、字体、符号、图例位置、坐标轴、网格等;也可以直接用于修改主题
          • 此函数参数众多，每个参数对应着图形的一个设置
            • theme(panel.grid=element_blank()) :去掉网格线
          • theme_*()函数簇：可以分别设置某一类图形参数
            • theme_bw():去掉图形的背景色
  • 坐标系
    • 描述了数据是如何映射到图形所在平面的，它同时提供了看图所需的坐标轴和网格线
    • 函数coord_function()
      • coord_cartesian():笛卡尔直角坐标系，默认
      • coord_flip():翻转的笛卡尔坐标系，交换x轴和y轴
      • coord_polar():极坐标系
      • coord_map():地图映射
      • coord_fixed()
• 进阶
  • 图层
    • 每个几何函数生成一个图层，多个几何函数生成的图层相互叠加可生成一幅复杂的图
    • 每个几何函数都有参数data和mapping,用于设置该图层绘图时的数据；如果没有为一个几何函数指定data和mapping，那么它使用ggplot()函数里的参数值
    • 映射
      • 局部映射：在几何函数中设置的参数称为局部映射，它仅对该图层有效；若局部映射与全局映射有冲突的话局部映射会扩展或覆盖全局映射
      • 全局映射：在ggplot()中设置的参数值称为全局映射，它会传递给每个图层
    • 几何函数中aes()可以使用函数，且将列变量作为函数的参数
      • 例：ggplot(data=mpg)+ geom_point(mapping=aes(x=mean(displ),y=mean(hwy)),color="blue",size=4) #只是一个点
    • 绘制图层时，允许直接使用向量绘图，但需要设置data=NULL
      • 例：ggplot(data=NULL,mapping=aes(x=cars$speed,y=cars$dist))+ geom_point()
  • 分组
    • 方法一：将某个图形属性映射为一个离散变量
      • 理解：组常用离散型变量（指因子、字符串）来定义，离散型变量的每个唯一值对应一个组；每个组在作图时用不同的图形属性（颜色、点的大小、透明度...）来表示
      • 做法：把几何函数的部分参数（如color、size、alpha...）等放在mapping=aes()参数中，用离散变量作为它们的值，从而实现图形分组
      • 注：表达式mapping=aes()的作用是将离散变量映射到图形属性（color、size...），离散变量的每个唯一值会对应一个图形属性值（这个过程称为标度变换），从而实现图形分组
      • 如果要手动设置一个图形属性，那么应当将该设置写在aes()之外，作为几何函数的一个参数
        • #正确的代码 ggplot(data=mtcars)+geom(mapping=aes(x=wt,y=mpg),color="blue")
        • #错误的代码 ggplot(data=mtcars)+geom(mapping=aes(x=wt,y=mpg,color="blue"))
      • 此时，几何函数可以设置参数 show.legend=TRUE是否要图例，默认为是
    • 方法二：使用参数group
      • 做法：将几何函数的group参数映射为一个离散变量，实现分组
      • 例：ggplot(data=mpg)+ geom_smooth(mapping=aes(x=displ,y=hwy,group=drv))
    • 方法三：分面（也是一种分组）
    • 堆叠图
      • 对于条形图和直方图，如果存在多个分组，可以通过参数position来设置堆叠方式;可解决绘制点图的“过绘制”
      • 参数position:位置调整
        • position="satack":绘制堆叠图，避免重叠，是默认值
          • 例：ggplot(data=diamonds,mapping=aes(x=color,fill=cut))+geom_bar()
        • position="fill" :绘制堆叠图，但会把每个条形的总高度都缩放成1
          • 例：ggplot(data=diamonds,mapping=aes(x=color,fill=cut))+geom_bar(position="fill")
        • positon="dodge" :绘制并列图
          • 例：ggplot(data=diamonds,mapping=aes(x=color,fill=cut))+geom_bar(position="dodge")
        • position="identity" :绘制覆盖图，即同组的多个条形图会使用同一位置
          • 例：ggplot(data=diamonds,mapping=aes(x=color,fill=cut))+geom_bar(position="identity")
        • position="jitter" :给点添加扰动，避免重合
  • 统计变换stat
    • 含义：绘图时计算新数据的算法称为stat(statistical transformation统计变换)
    • 很多图形绘制的是图形的原始数据，如散点图；另外一些图则可以绘制那些计算出的新数据，如条形图
      • 条形图、直方图、频率多边形图可以对数据进行分箱（即划分成小区间），然后绘制出分箱数量和落在每个分箱的数据点的数量
      • 平滑曲线会为数据拟合一个模型，然后绘制出模型预测值
      • 箱线图可以计算出数据分布的多种摘要统计量，并显示一个特殊形式的箱体
    • 每个几何函数都有一个默认的统计变换，每个统计变换函数都有一个默认的几何变换，通常来说，几何对象函数和统计变换函数可以互换使用
      • 例：用stat_count()来代替geom_bar() ggplot(data=diamonds)+stat_count(mapping=aes(x=cut))
    • stat_count()、stat_bin()、stat_boxplot()、stat_density()、stat_smooth()、stat_sum()、stat_summary()、stat_unique()
      • stat_summary():为x的每个唯一值计算y值的摘要统计
      • stat_smooth()

数据

• 数据对象
  • 数据类型
    • 基本数据类型
      • 数值型numeric/双整型double
      • 字符型character
      • 逻辑型logical
        • 只有FALSE和TRUE两种值，可以分别简写为F和T
        • 可以参与数值运算，TRUE会被当作1，FALSE会被当作0
      • 整型integer
      • 复数型complex
      • 原始型raw
    • 特殊的常数值
      • Inf
        • 表示Infinite，表示无穷大
        • 数值型常数
        • 相关函数
          • is.infinite(x):判断变量x是否是无穷大（Inf或-Inf）
          • is.finite(x):判断变量x是否是有限值
      • NA
        • 表示缺失值，表示未知的值，是“可传染的”
        • 如果运算中包含了未知值，那么运算结果一般来说也是一个未知值
        • 排序排在最后面
        • 判断：is.na(), !is.na()
        • 在一些函数中让缺失值不参与运算，选参数：na.rm=F
      • NaN
        • 表示not a number
        • 在数值计算中，如果计算结果不能用一个数值表示，那么将结果记为NaN
        • is.nan(x):判断变量x值是否为NaN值
      • Null
        • 表示空值
        • is.null(x):判断变量x是否为空值
      • 补：以上值都是常数，不需要用引号括起来
      • 例
        • a<-1/0 #Inf
        • b<-(1/0+1/0) #Inf
        • c<-(1/0-1/0)
          • c #NaN
          • is.nan(c) #TRUE
          • is.na(c) #TRUE
        • d<-(NaN+Inf)
          • d #NaN
          • is.infinite(d) #FALSE
        • e<-c(10,Inf,NULL,NaN,NA)
          • e # 10 Inf NaN NA
          • is.nan(e) #FALSE FALSE TRUE FALSE
          • is.na(e) #FALSE FALSE TRUE TRUE
        • NaN==NaN #NA
        • NA==NA #NA
        • NA^0 # 1
        • NaN^0 #1
    • 相关函数
      • mode()函数 可以查看数据类型
      • typeof()函数 可以查看数据类型，但比mode更精确，可以区分整型与数值型
  • 数据结构
    • 含义：用于存储数据的对象类型称为数据结构
    • 可以根据数据集中数据的特征对
    • 对象类型class()
      • 数据类型单一
        • 1维：原子型向量atomic vector
          • 含义：构成其它对象类型的基本元素，R中最简单的对象类型
          • 基本函数
            • vector(mode="", length=)
              • 可用于生成一个原子型向量，定义其数据类型和向量长度
            • c()函数
              • 给向量赋值
              • 与C语言提前界定不同，R会根据相应的规范识别输入，将其定义为对应类型的原子型向量
              • 不同数据类型输入方式基本规则：字符型要打双引号，其它直接输入
          • 相关函数
            • mode()/typeof() :查看和赋值原子型向量的数据类型
            • length() :查看和赋值原子型向量的长度
          • 六种数据类型
            • 双整型double
              • 数值可正可负，可大可小，可包括或不包括小数部分
              • 在R中键入的数值会默认以双整型存储
              • 在R中，计算机会给双整型对象分配64字节的内存，导致一个双整型的数值只会大约精确到小数点后16位，会带来一点小误差，叫做浮点误差
                • 例子：sqrt(2)^2-2 #4.440892e-16
              • 延伸
                • 日期与时间
                  • 数值型向量的拓展
            • 整型integer
              • 在R中，明确设定整型的方法是在该数值之后加大写字母L
              • 延伸
                • 因子factor
                  • 理解
                    • 因子是用来存储分类信息，如性别、人种等
                    • 只可以取某些特定的值，而这些值可能有一些特殊的顺序规定
                    • 常用于表示离散型数据，其值域是一个有限的集合，因子也被称为分类变量
                  • 基本函数
                    • factor()函数
                      • 理解
                        • 传递一个原子型向量即可以生成一个因子，R会将向量中的值重新编码为一串整数值，再将编码的结果存储在一个整型向量中
                        • R会将一个level属性和一个class属性添加到该整型向量中
                          • level属性:显示因子值的一组标签
                          • class属性为factor
                      • 用法
                        • myfactor<-factor(myvector, ordered=bValue, levels=mylevels)
                        • 参数
                          • oedered:指定生成的因子是否是有序型因子
                          • levels:指定了生成的因子的值域
                            • 允许省略参数levels,此时factor()会找出myfactor的取值范围，将各值按字母排序，作为因子水平
                            • myvector的元素都必须是levels中的值，不在levels中的值会被当作NA值处理
                            • levels()函数：可以直接获取因子的有效集合水平
                            • levels=unique(factor)可以让因子的顺序与初始的顺序保持一致
                              • 例：f<-factor(x1,levels=unique(x1))
                              • 等价形式：使用fct_inorder()函数 f<-factor(x1)%>%fct_inorder()
                        • 在R内部，因子是以整数向量1、2、3...来保存的
                          • 对于myfactor<-factor(myvector, ordered=bValue, levels=mylevels)，mylevels[1]对应于1，mylevels[2]对应于2，依次类推
                      • 例
                        • gender<-c("male","female","female") new_gender<-factor(gender,ordered=FALSE,levels=c("male","female")) nem_gender #male female female #Levels:male female
                        • status<-c("poor","improved","excellent","poor") new_status<-factor(status,ordered=TRUE,levels=c("poor","improved","excellent")) new_status #poor improved excellent poor #Levels:poor<improved<excellent
                    • unclass()函数
                      • 作用：可以查看数据是如何存储的
                  • 处理因子的包forcats
                    • 对于因子来说，水平值的顺序很重要，例：在绘制条形图时，用因子做横轴变量，各条形图将按因子的水平值排序，如果要改变条形的顺序就需要重新排列因子的水平集
                    • 不是tidyverse的核心包，需要单独加载
                    • 主要功能：集中于修改因子的水平集
                      • 重编码水平值
                      • 合并水平值
                      • 重排水平值
                    • 函数
                      • fct_recode()
                        • 作用
                          • 可以将一个因子的部分或全部水平值重编码
                            • new.partyid<-fct_recode(gss_cat$partyid, "new name1"="old name1",...)
                            • 会让没有明确提及的水平保持原样
                            • 如果修改了一个不存在的水平，会发出警告
                          • 将若干个水平值合并为一个水平值
                            • gss_cat%>%mutate(partyid=fct_recode(partyid,"new"="old1","new"="old2"))
                            • 将水平值old1,old2合并为new
                            • 变体：fct_collapse()函数对于每个新水平，可以提供一个包含原水平的向量
                        • 补：在数据集中常与mutate()结合使用
                      • fct_lump（）
                        • 作用
                          • 指定保留的水平值个数，剩余的水平值被合并成一个
                            • skin_color<-fct_lump(skin_color,n=5) #仅保留skin_color频数最高的5个水平值，其他水平值被合并在一起
                          • 指定保留的比例
                            • skin_color<-fct_lump(skin_color,prop=0.1) #仅保留占比高于或等于10%的水平值，占比低的水平值被合并在一起
                          • 补：被合并在一起的水平值默命名为Others,可以使用参数other_level指定名字
                            • skin_color<-fct_lump(skin_color,prop=0.1，other_level="new name")
                      • 重排水平集
                        • fct_inorder(f,ordered=NA)：按照各值出现的先后顺序重排水平集
                        • fct_infreq(f,ordered=NA)：按照各值出现的次数重排水平集
                        • fct_insaq(f,ordered=NA)：按照各值的大小重排水平集，用于重排数值因子的水平集
                  • 基本属性
                    • 名称属性：NULL
                    • 维度属性：NULL
                    • 类属性：factor
                    • 水平levels()
                      • 可以使用函数levels()查看一个因子的水平值
                      • 用nlevels()计算一个因子水平值的个数
                  • 补
                    • 在加载或者生成数据时，R会尝试将字符串向量转化为因子型，除非需要这样转化，一般禁止R这样做（stringAsFactors=F）
                    • as.character()将因子型强制转化为字符串，R会将因子的标签信息保存为一个字符串向量，摒弃内存中的整数值信息
                • 变量的三种类型
                  • 名义型
                    • 例如：性别，可取"male""female"
                    • 值没有大小之分
                  • 有序性
                    • 例如：学历，可取"primary""middle""high"
                    • 值有大小之分，可以进行比较，但是不能进行加减运算
                  • 连续型
                    • 例如：身高、体重，可取连续值
                    • 值有大小之分，并可以进行算术运算
                  • 注：名义型变量和有序性向量在R中通常转化为因子进行处理
                    • 如：c("male","female","male","male"),如果直接用字符串保存会非常占用磁盘空间，计算时也很缓慢；通常做法是，用0和1来表示性别，将上面的向量转换为c(0,1,0,0)
            • 逻辑型logic
              • TRUE/FALSE;T/F
            • 字符型character
              • 字符型向量用来存储一小段文本
              • 字符要加双引号，用c()组合起来构成一个字符型向量
              • 字符型向量中单个元素称作字符串string
                • 字符串可包括英文字母、中文文字、数字、符号...
            • 复数型complex
            • 原始型raw
          • 基本属性
            • 名称属性
              • names()函数
                • 作用：可以将一串字符向量赋给原子型向量对象，作为该对象每个元素的名称属性
                • 要求：字符向量的长度应该与对象的长度相等
            • 维度属性
              • dim()函数
                • 可以查看和修改向量的维度属性
                • 查看：dim(die),原子型向量的维度为NULL
                • 修改
                  • c(x,y) : 将第一个值赋给行，第二个值赋给列,即x行y列；"按列填充"
                  • 例子：dim(die)<-c(2,3) 将原子型向量die改为2行3列的矩阵/数组
            • 类属性
              • class()函数可以查看和赋值向量的类属性
              • 对于原子型向量的六个数据类型，都具体定义了类
              • 当改变原子型向量的维度的时候，R就为其增加了一个类属性
        • 2维：矩阵matrix
          • 理解：一种新的类；储存原子型向量的二维数组
          • 基本函数
            • matrix()函数
              • 用于查看和赋值一个矩阵
              • 用法
                • matrix(data=, nrow=, ncol=, byrow=FALSE, dimnames=)
                • 参数
                  • nrow:定义行数
                  • ncol:定义列数
                  • byrow:是否按行填充，默认为否
                  • dimnames:给行列命名
                    • dimnames=list( c(), c() )
          • 基本属性
            • 名称属性
              • dimnames()：查看和赋值矩阵的行名和列名
              • rownames()：查看和赋值矩阵的行名
              • colnames()：查看和赋值矩阵的列名
            • 维度属性
              • dim()：查看和赋值矩阵的维度
              • nrow()：查看和赋值矩阵的行长度
              • ncol()：查看和赋值矩阵的列长度
            • 类属性
              • 类属性为matrix
        • n维：数组array
          • 理解：一种新的类；储存原子型向量的n维数组
          • 基本函数
            • array()函数
              • 用法：array(data, dim=, dimnames=NULL)
              • 填充数据时，会先填充最后一个维度
        • 补：三者的转换
          • dim()函数：用于原子型向量、矩阵、多维数组的转换
            • 例子：dim(die)<-NULL 用NULL转换为一维数组
      • 数据类型多元
        • 1维：列表list
          • 基本函数：list()函数
            • 与c函数创建向量的方式相似，不同元素用逗号隔开
            • 列表中元素用双括号[[]]表示，各个组件的名称叫标签tags
            • 创建：mylist<-list(object1,object2,...)
          • 列表属性
            • 名称属性
              • names() 查看和赋值列表中每个元素的名称，也叫标签
                • 例：names(list)[2]<-"mysalary" #仅为第二个元素命名
              • 创建列表时也可以为各元素命名
                • 语法：mylist<-list(name1=object1,name2=object2,...)
                • 注：各元素的名字都需要用引号括起来，但是如果作为名字的字符串不含空格或其它特殊字符，可以省略掉引号
            • 维度属性：NULL
            • 类属性：使用class()查看
            • 长度属性
              • length()查看和赋值列表的长度
              • 空列表： a<-list();length(a)<-3 有三个元素的空列表
          • 访问列表的元素
            • $ 例：mylist$mysalary
            • 数值下标，放在[[]]中，以示列表与向量的区别 例：mylist[[2]]
            • 名字下标 例：mylist[["mysalary"]]
        • 2维：数据框data frame
          • 理解
            • 可以视为列表的二维版本
            • 将向量组织在一个二维的表格之中，每个向量都是这个表格中的一列
            • 行叫观察，列叫变量
          • 基本函数：data.frame()
            • 将任意数量的向量交给data.frame,每个向量用逗号隔开，每个向量都应该有自己的名称
            • 用法：data.frame(data, stringAsFactors=FALSE)
            • 例：mydata<-data.frame(col1=,col2=,col3,....)
          • 数据框属性
            • 名称属性
              • 使用data.frame(col1=,col2=,col3,....)创建数据框时，R自动用col1、col2、col3、...为各列命名
              • 默认情况下，data.frame()会使用行号作为行的名字
                • 注：每一行的名字都是唯一的，所以每一行的名字就是这一行的ID，用数据库的术语来说，row.names就是数据框的关键字段
              • names()、colnames():查看和赋值数据框列变量的名称
                • 例：names(mydate)[1]<-"学号" #给数据框mydate的第一列单独重新命名
              • rownames():查看和赋值数据框行的名称
              • dimnames():查看和赋值数据框行、列的名称
            • 维度属性
              • 查看和赋值数据框两个维度的长度
            • 类属性
          • 访问元素
            • 数值下标[]
              • 1个下标值
                • 例：mydate[1] #数据框mydate的第一列
                • 此时是把数据框看做由多个列组成的一维数组
              • 2个下标值
                • 例：mydate[1,2]
                • 此时是把数据框当作一个矩阵
            • $
            • [[]]
          • 延伸:tibble
            • tibble包：用来创建tibble对象
            • 理解：用来替换data.frame类型的扩展的数据框，与data.frame有相同的语法，使用起来更方便
            • 创建tibble对象
              • tibble()函数
                • 语法与传统data.frame()类似
                • 注
                  • 会在输出时多出一行，用来指定每一列的数据类型，并用缩写展示
                  • 会自动重复长度为1的输入，并可以使用刚刚创建的新变量
                  • 可以使用在R中不符合语法的名称作为列名称，例如列名称可以不以字母开头，也可以包含特殊字符，但是需要使用反引号‘将它们括起来（例：':)'）
                  • 比data.frame()少的功能：不能改变输入的类型（如不能将字符串转换为因子）、变量的名称，也不能创建行名称
                • 例： tibble(studentID=c(1001,1002,1003), studentName=c("Zhang","Chen","Hu"), studentAge=c(20,21,19))
              • tribble()函数
                • 可以逐行书写，第1行是各列的名字（以~开始），其后各行是数据；各列之间用逗号分隔
                • 例： tribble( ~studentID,~studentName,~studentAge, 1001,"Zhang",20, 1002,"Chen",21, 1003,"Hu",19)
              • as_tibble()
                • 将现有的data.frame数据转换成tibble
            • 显示tibble内容
              • tibble默认情况下只打印前10行，并且会根据屏幕宽度只输出部分列
              • print()函数
                • 可用来改变tibble输出结果
                • 使用：print(data,n=nrow,width=nchar)
                • 参数
                  • data:tibble
                  • n:指定了要显示的行数
                  • width:指定了输出宽度，会限制显示出来的列的数量；width=Inf会显示所有的列
                • 例：print(flights,n=5,width=Inf)
              • 可以更改工作区的参数
                • options(tibble.width=Inf)：打印所有列，不考虑屏幕宽度
                • options(tibble.print_max=n,tibble.pring_min=m):如果多于m行，则只打印出n行
                • options(tibble.print_min=Inf):表示打印所有行
            • 与data.frame
              • 区别
                • tibble
                  • 不关心输入类型，可存储任意类型，包括list类型
                  • 支持任意的列名，会自动添加列名
                  • 做屏幕打印时只显示10行，且列适合屏幕；传统需要使用head()函数
                  • 会显示数据类型
              • 相同：取子集时一样，用$、[[]]、[]
              • 互换
                • 换到tibble : as_tibble()
                • 换到data.frame : as.data.frame()
  • 数据对象的属性
    • 属性attributes: 附加给数据对象的额外信息
    • attributes()/attr()函数 ：可以用来查看属性和对属性赋值
    • 注意
      • 作用：将与这个对象相关的信息以一种便捷的形式存起来，并附加给该对象
      • 属性不会影响该对象的取值，在显示该对象时也不会出现属性信息
      • 不同数据对象的属性有较大差别
• 基本数据管理
  • 预备知识
    • 算术运算
      • 算术运算符
        • +:加 -:减 *:乘 / :除
        • ^或**：幂
        • %%:求余数
        • %/%：求商（整数）
      • 既可以对标量进行运算，也可以对向量进行运算；向量运算的结果仍然是向量
    • 集合运算
      • 向量和列表被当做集合使用
      • 函数
        • union(x,y):计算集合x和y的并集
        • intersect(x,y):计算x和y的交集
        • setdiff(x,y):求出只在x中但是不在y中的元素集合
        • setequal(x,y):判断两个集合是否相同，不考虑元素顺序
        • is.element(x,y):逐个判断x的每个元素是否在集合y中，返回一个与x等长的逻辑向量
        • x%in%y:功能与is.element相同
        • match(x,y):计算x的每个元素在集合y中的位置
      • 处理单个集合的函数
        • unique(x):返回集合x的值域，即去掉x中的重复值
        • duplicated(x):一次判断集合x中的元素是否在之前重复过，返回与x等长的逻辑向量
    • 逻辑运算
      • 运算符
        • <,<=,>,>=
          • 对于比较大小的运算，向量运算的结果仍然是向量
        • ==,!=
          • 不要用==来判断两个浮点数是否相等（计算机表示浮点数的精度有限）
        • !x
        • and,or运算
          • and
            • x&y
              • 对两个逻辑向量的元素两两对应进行and运算，输出值也是向量
            • x&&y
              • 对两个标量进行运算，计算结果也是一个标量
              • 如果x或y是向量，那么R会取出它们的第1个元素作为x或y的值，将向量当作标量使用，得到的结果仍然是标量
          • or
            • x|y
              • 进行向量or运算
            • x||y
              • 进行标量or运算
          • 补：&&和||通常只在if语句中使用，在其他场景通常是使用&和|
          • 会执行短路原则，与C语言相同：在计算一个逻辑表达式的值时，如果根据表达式前面的部分就已经可以确定最终的结果了，那么表达式后面的部分就会被跳过
        • 类似
          • any(x)
            • 如果逻辑向量x中存在有TRUE，那么返回TRUE；否则返回FALSE
            • x中存在TRUE吗
          • all(x)
            • 如果逻辑向量x全都是TRUE，那么返回TRUE；否则返回FALSE
            • x中全是TRUE吗
          • which(x)
            • 返回逻辑向量x中为TRUE的元素的下标
          • 这三个函数常用来测试向量的内容
      • 逻辑值可以参与数值计算，TRUE会被当作1，FALSE会被当做0
      • 用逻辑向量筛选
        • result<-myvector[logicVector]
          • logicVector是一个由逻辑值组成的向量，长度与myvector相同
          • 对于vector中的每个元素
            • 如果它在logicVector中对应的元素为TRUE，那么它将被放入result
            • 如果它在logicVector中对应的元素为FALSE，那么它会被跳过
            • 如果它在logicVector中对应的元素为NA，那么会将NA放入result
        • 也可以用于筛选数据框中的行或列
          • 常见错误
            • 漏写数据框的名称
              • 错误：mtcars[mpg>10,]
              • 正确：mtcars[mtcars$mpg>10,]
            • 漏写逗号
              • 错误：mtcars[mtcars$mpg>10]
              • 正确：mtcars[mtcars$mpg>10,]
            • 使用连接不等式
              • 错误：cars[15<cars$speed<20,]
              • 正确：cars[cars$speed>15&cars$speed<20,]
    • 缺失值NA
      • 几乎所有NA参与的运算，其结果都是NA
      • 仅有少数例外
    • 向量的修改
      • 修改向量元素的值
        • 可以直接为向量中的元素赋值，从而改变向量的值
        • a[3:5]<-c(12,13,14)
      • 删除向量中的元素
        • 只能用剩下的元素来创建一个新向量，再赋值给原向量
        • 向量的下标可以使用负数，负数的下标表示要剔除相应的元素
        • a<-c(1:5) a<-a[c(1,2,4,5)] #删掉a[3] 等价于a<-a[-3]
        • 正值下标与负值下标不能混合在一起
          • a[c(-1,3)]错误
      • 插入元素
        • 创建一个新向量，包含原元素和插入的元素，再将新向量赋值给原向量变量
      • 添加元素
        • 将元素赋值给指定的下标即可
          • a<-c(1,2,3) a[4]<-4
        • 或a<-c(1,2,3) a<-c(a,4)
      • 补：对向量的修改操作对因子同样适用，但是因子的元素只能在其levels范围内取值
    • 循环补齐规则
      • 对向量进行运算时，如果向量的长度不相等，那么R将会短的向量进行重复，使得它与长的向量等长
      • 注：循环补齐时，要求短向量被重复整数倍，即长向量的长度是短向量长度的整数倍；如果短向量不是被重复了整数倍，那么有些函数会给出一个警告，但仍可以运行，而另一些函数不接受这种情况，会报错
  • 基本数据操作（对数据框）
    • 创建新的列变量
      • mydata$var<-vectorValue
      • 例：cars$time<-cars$dist/(5280*cars$speed/2)*3600
    • 删除列变量
      • mydata$var<-NULL
    • 列变量的重编码
      • 指将该列的值划分成若干类别
    • 列变量的重命名
      • names()函数
        • 使用：names(mydata)<-colnames
        • colnames是一个字符串向量，包含了各列的名字
        • 可以只从所有列的名字中抽取若干个，只为这些列重命名
          • 例：names(cars)[1:3]<-c("速度","距离","类型")
    • 处理缺失值
      • 在分析时，通常需要把缺失值排除掉
      • 许多函数中都有一个na.rm参数，设置na.rm=TRUE将在计算时排除NA
      • na.omit()函数
        • 将包含缺失值的行都剔除掉
        • newdata<-na.omit(mydata)
    • 处理日期值
      • 日期型数据不能直接输入，通常是先输入字符串表示的日期，然后再将字符串转换为日期
      • 将字符串转换为日期的函数：as.Date()
        • mydata<-as.Date(str,format=FormatString)
        • format参数用来指定字符串str的格式
        • 例：mydate<-as.Date("2018年03月06日",format="%Y年%m月%d日") mydate #"2018-03-06"
        • as.Date()能识别的默认格式是"%Y-%m-%d",如果字符串刚好是这种默认格式，则可以省略掉format参数
      • 可返回当前时间的函数
        • Sys.Date():返回当前年月日
        • Sys.time():返回当前的时刻，包括年月日时分秒
      • 将日期转换为字符串：函数format
        • mystr<-format(mydata,format=FormatString)
        • format()为泛函数，能够将多种数据类型转换成字符串
    • 数据类型转换
      • 查看变量的数据类型
        • 三个函数
          • 侧重于表示变量在内存的存储类型
            • mode()函数
            • typeof()函数
          • 侧重于变量的面向对象特性
            • class()函数
      • 强制转换
        • 自动强制转换
          • 如果将不同数据类型的数据塞进一个向量中，R会尝试将它们转换为一种类型的数据
          • 优先级别：字符串>数值型>逻辑型
          • 将logical转换为integer,将integer转换为double/numeric,将double/numeric转换为character
        • is.系列函数查看数据类型
          • is.numeric()
          • is.character()
          • is.vector()
          • is.matrix()
          • is.data.frame()
          • is.factor()
          • is.logical()
          • is.list()
          • is.finite()
          • is.infinite()
          • is.nan()
          • is.na()
        • as.系列函数强制转换数据类型
    • 数据排序
      • 对向量（数值型，字符型）排序的函数：order()
        • 使用：myresult<-order(myvector,decreasing=FALSE,na.last=TRUE)
        • 参数
          • decreasing=FALSE：进行升序排序，默认
          • na.last=TRUE:将NA值排在最后，默认
        • 会返回排序后各位置上的下标编号
        • 将向量排序的方法：newvector<-myvector[order(myvector)]
      • 函数sort(myvector,decreasing=TRUE)
        • 会直接输出排序结果，不能进行多重排序
      • 函数rank(x)
        • 可以计算出各元素排序后的名次，默认为升序排列
        • a[rank(a)<=2] #找出a最小的两个元素
    • 数据集的合并
      • 列合并
        • 把多个行数相同的数据框合并
        • 函数cbind()
          • 使用：newdata<-cbind(data1,data2,...)
          • 要求：data1,data2,..具有相同的行数
          • 在合并时，只是简单的把各列拼接起来；因此，在用cbind()合并时，各数据框中行的顺序要一致
        • 函数merge()
          • 在合并时会使用若干个关键字段
          • 合并对齐的数据
            • 使用：newdata<-merge(data1,data2,by=KeyCol)
            • 参数
              • KeyCol:该值是字符串向量，所指定的列是合并data1和data2的依据；若没有指定合并所依据的列，那么会将data1和data2共有的列作为合并依据
            • 合并数据框时，允许两个数据框的行顺序不一致
          • 合并不完全对齐的数据
            • 使用：newdata<-merge(data1,data2,by.x=key1,by.y=key2,all.x|all.y|all)
            • 四选一
              • 左连接：all.x=TRUE，data1的行将全部都保留下来
              • 右连接: all.y=TRUE，data2的行将全部都保留下来
              • 全连接：all=TRUE，两个数据框的数据都将被保留下来
              • 内连接：以上三个参数都未使用时，那么只会保留出现在data1和data2都出现的行
            • merge()会先计算出data1和data2的笛卡尔积，然后根据all.x,all.y或all的值从笛卡尔积中挑选出一部分数据
            • 在合并时会将by.x,by.y合并成一列，在合并结果中这一列被命名为by.x的值
      • 行合并
        • 函数rbind()
          • 使用：newdata<-rbind(data1,data2,...)
          • 要求：data1,data2,...的列结构相同，即列数相同且各列的名字也相同
      • 补：rbind()和cbind()也可以用于向量、矩阵、数据框之间的合并
    • 提取数据子集
      • 使用逻辑向量或行列下标
      • 使用subset()函数
        • 使用：newdate<-subset(mydate,condition,select=colnums)
        • 参数
          • condition:可以直接使用列名，不需要$
          • select:提取哪些列，如果不使用该参数那么将提取所有的列
        • 例：newdata<-subset(mtcars,wt>2.5&drat<3,select=c(wt,mpg))
      • 随机抽样
        • nrow()
          • 作用：返回数据框的行数
          • 使用：n<-nrow(mydata)
        • sample()
          • 作用：从一个向量中随机抽取若干个元素
          • 使用：myset<-sample(x,size,replace=FALSE)
          • 参数
            • 从向量x中随机抽取出size个元素
            • replace:是否放回，默认不放回抽样
        • set.seed()
• 记号体系
  • 作用：从R对象中提取值
  • 两种记号体系
    • 对象名称+[ ，] 即deck[ ，]
      • 理解：中括号内两个索引参数，用逗号分隔；索引参数用来告诉R需要提取哪些值；第一个索引参数选择数据框中相应的行，第二个索引参数选择相应的列
        • 行或列的下标可以是一个数值，也可以是一个向量
      • 6种索引编写方式
        • 正整数索引
          • deck[i,j]: 返回deck数据集第i行第j列的元素
          • 重复提取：deck[c(1,1), ]
          • 索引开始于1
        • 负整数索引
          • 使用负整数效果与正整数相反，返回的元素将不包括其绝对值所代表的的索引位置的元素
          • 例：deck[-1, ]返回deck数据集中除第一行的所有元素
          • 注：不能在相同的索引位置同时使用正整数和负整数如, 如：deck[c(1,-1),1] 但可以将正整数和负整数用在不同的索引位置, 如: deck[-1,1]
        • 零索引
          • R不会提取任何信息，会返回一个空的对象
        • 逻辑索引
          • 如果在索引时提供一个包含TRUE和FALSE的逻辑向量，那么R会匹配索引值为TRUE的行/列位置，并提取相应的元素，而忽略所有索引值为FALSE的行/列位置
          • 要求：索引向量的长度必须与提取元素向量的长度相同
        • 名称索引
          • 如果被索引的对象有名称属性，就可以采取待提元素的名称作为索引值
        • 空格索引
          • 可以使用空格告诉R提取该索引位置所代表维度的所有元素
          • 例：mpg[,"cyl"]提取mpg数据集整个cyl列的数据
      • 注：该方法用于提取列表中的元素，会返回列表；数据框是特殊的列表，有同样的效果，[]会返回一个数据框
    • 美元符号$与双中括号[[]]
      • 元素有名称，使用$
      • 元素有无名称，均可使用[[]]
      • 返回元素值，而不会返回结构
    • 补：R中实际上只有两种组合数据类型，向量vector和列表list
      • 向量
        • 标量、矩阵、数组都是特殊的向量vector
        • 向量的特点是各元素都是同一类型
        • 访问向量的元素是使用[]
      • 列表
        • 可以将不同的数据类型放入列表
        • 列表的每个元素仍是列表
        • []可以访问到列表的元素，仍是一个列表
        • [[]]则可以访问到列表各元素内的值

字符串与网页抓取数据

• stringr包
  • tidyverse包的一个子包
• 字符串基础
  • 转义及特殊字符
    • 转义符
      • 表达：\
      • 创建字符串可以使用“xxx”或'xxx'，推荐使用前者但当字符串里想使用同样的双、单引号时，需要用\来转义，格式为\"或\'
      • writeLines() 作用：可以用来查看打印形式，即转义后的内容（R运行结果为存储的数据形式，而非打印形式）
    • 转义字符
      • \n ： 表示换行
      • \t ：表示制表符
      • \b ：表示退格
      • \\ :表示\
      • \'' : 表示''
      • \nnn :代码为nnn(8进制)的ASCII字符
      • \xnn:代码为nn(16进制)的ASCII字符
      • 使用？Quotes可以查看完整的特殊字符列表
  • str_系列函数
    • 字符串长度
      • str_length(string) 返回向量string的长度
    • 字符串拼接
      • str_c( )
        • str_c(...,sep="")
          • sep:字符串的分割符，把多个字符串拼接为一个大的字符串
        • str_c(...,collapse=" ")
          • collapse:字符串的分割符，把多个向量参数拼接为一个大的字符串
        • NA值
          • NA值会传染 str_c("123",NA) #NA
          • x<-c("123",NA);str_c("[",x,"]") # "[123]"NA
            • 想输出"NA"
              • 可使用str_replace_na()
                • x<-c("123",NA);str_c("[",str_replace_na(x),"]") #"[123]""[NA]"
              • 可直接输入"NA"
                • x<-c("123","NA") ;str_c("[",x,"]") #"[123]""[NA]"
        • str_c()是向量化的，具有向量循环功能
          • fruit<-c("apple","banana","orange);sx<-str_c(1:3,fruit,sep="-")
          • #"1-apple""2-banana""3-orange
      • 去掉字符串的空格
        • str_trim(string,side="both"/"left"/"right")
        • 例：str_trim(string,side="left") 去掉string左边的空格
      • 补充字符串的长度
        • str_pad(string,width，side="left"/"right"/"both",pad=" ") pad指填充符号
        • 例：str_pad(string,width=40,side="both",pad="*") 以*在左右两边填补string的长度到40
      • 复制字符串并连接
        • str_dup(string,times) times指重复次数
        • 例：str_dup(string,2) "string string"
      • 控制字符串输出格式
        • str_wrap(string,width=,indent=,exdent=) width指每一行宽度；indent指第一行的缩进；exdent指第一行以外的其它缩进
    • 字符串提取
      • str_sub(string,start=,end=) string:字符串/字符串向量 start:开始位置 end:结束位置
      • 两种用法
        • 提取子字符串 str_sub(string,start=,end=)
          • 补
            • str-sub(string,6) 截取从6到结束的索引位置的字符串
            • str_sub(string,end=6) 截取从开始到6的索引位置的字符串
            • str-sub(string,c(2,5),c(6,9)) 分两段截取字符串， 第一段截取2-5索引位置的字符串，第二段截取6-9索引位置的字符串
            • str_sub(string,-3) 截取后三位索引位置的字符串
            • str_sub(string,3,-2) 截取从第3个到倒数第二个
              • 即负数表示倒着来
        • 替换子字符串str_sub(string,start=,end=)<-
    • 区域设置
      • 不同的语言体系有不同的转换规则，可以使用区域设置选择使用哪种规则
      • 大小写转换
        • 参数： string字符串或字符串向量；locale设置语种
        • str_to_upper(string,locale="") 英文字符串转换为大写
        • str_to_lower(string,locale="") 英文字符串转换为小写
        • str_to_title(string,locale="") 将单词首字母转换为大写
      • 字符串值排序
        • 两种
          • str_sort(x,decreasing=F,na_last=T,lacale="",...)
            • 返回排序后的实际值
          • sre_order(x,decreasing=F,na_last=T,locale="",...)
            • 返回排序后的索引（下标）
          • 参数
            • x:字符串或字符串向量
            • decreasing:是否倒序
            • na_last:NA值的存放位置，一共三个值
              • T放到最后
              • F放到最前
              • NA过滤处理，去掉NA值
            • locale:按哪种语言习惯排序
• 正则表达式
  • 使用场景(帮助理解)
    • 1给定一段文本，其中包含若干个身份证号码，想从文本中提取出所有的身份证号码 方法是：编写一个表示身份证号码的正则表达式，用它查找出所有匹配的结果
    • 2在http://www.whbsz.com.cn/上可以看到武汉白沙洲农副产品大市场上的蔬菜价格，我们想爬取所有的价格。这需要编写一个网络爬虫，基本原理是首先获取网页的源代码（一段文本），找到包含价格的部分，编写适当的正则表达式，用它提取所有的价格数据
    • 3在一段程序中要求用户填写自己的Email地址，在用户提交前需要检查Email地址的合法性。方法是：编写一个表示Email的正则表达式，检查用户填写的文本能否匹配正则表达式
    • 4写了一个合作企业的通讯录，要求重新写电话的格式，由027-68753355换成（[phone]。方法是：编写一个正则表达式，完成子串替换
  • 正则表达式
    • 用于描述/匹配一个文本集合的表达式
    • str_view()、str_view_all() 显示字符串如何被匹配
      • str_view( ....,match=TRUE)只显示已匹配的内容
      • 匹配不会重叠
  • 正则表达式的基本匹配规则
    • 精准匹配：精准匹配字符串
      • 所有英文字母、数字和很多可显示的字符本身就是正则表达式，用于匹配他们自己
    • 特殊字符匹配
      • 元字符
        • 含义：一些特殊字符在正则表达式中不再用来描述它自身，它们在正则表达式中已经被转义
        • 字面含义：在正则表达式中表示元字符本身的字面含义需使用“\\”加在元字符前进行转义（在字符串中“\”表示转义，在正则表达式中“\\”表达转义）
        • 特殊含义
          • 特殊符号
            • 12个字符被保留用做特殊用途
            • 具体
              • []：括号内任意字符将被匹配
                • 连字符-可以定义字符区间
                  • [0-9]等价于[0123456789]
                  • [c-h]等价于[cdefg]
              • \:对元字符进行转义
              • ^:从字符串开头进行匹配，写在字符串前面
              • $:从字符串的末尾进行匹配，写在字符串后面
              • . :匹配除换行符以外的任意字符
              • | :将两个条件进行逻辑“或”运算，表示从该运算前后二选一
                • 优先级很低，因此通常需要放在一个子表达式中
                • abc|def表示从abc或def中二选一
              • （）：表示一个字符组，括号内的字符串将作为一个整体被匹配
                • 使用子表达式
                  • 子表达式：使用圆括号括起来的部分，一个子表达式被作为一个整体进行处理
              • 量词
                • ？：重复0次或1次
                • *：重复0次或以上
                • +：重复1次或以上
                • {}
                  • {n}：重复n次
                  • {n,m}：最小重复n次，最多重复m次
                  • {,m}:最多重复m次
                  • {n,}：重复n次或以上
                • 量词表示一个字符的重复次数；将量词放在一个字符之后，表示将该字符重复指定的次数
                • 贪婪型匹配：正则表达式在进行匹配时会进行贪婪型匹配，即每次匹配时会设法匹配尽可能长的字符串
                • 懒惰型匹配：在量词之后加上问号？
          • 字符类与字符选项
            • 总：小写为正向匹配，大写为负向匹配
            • \b :匹配一个单词边界
            • \B :匹配非单词边界
            • \d :匹配一个数字字符，等价于[0-9]
            • \D :匹配一个非数字字符,等价于[^\d]
            • \s :匹配任何空白，包括空格、制表符、换页符......
            • \S :匹配任何可见字符
            • \w :匹配任意一个字母或数字或下划线，等价于[0-9a-zA-Z_]
            • \W :匹配任何非单词自负
            • \< ：匹配单词开头的位置
            • \> :匹配单词结束的位置
            • [abc] :匹配a、b或c
            • [^abc] :匹配除a、b、c外的任意字符
          • 回溯引用
            • 回溯引用指的是模式的后半部分引用在前半部分中定义的子表达式，即用（）括起来的正则表达式片段
            • 如：\1引用第一个分组；\2引用第二个分组
          • R预定含义的字符组
      • 关于\
        • 字符串\\\\表示正则表达式\\
          • 处理过程：\\\\
            • R语言解释器
              • \\
                • 正则表达式解释器
                  • \
        • 在使用字符串表示正则表达式时，\总是成对出现
    • 正则表达式运算顺序
  • 使用正则表达式
    • 结合stringr函数应用正则表达式
      • 模式检测，即检测一个字符串中是否出现了指定的正则表达式
        • str_detect(string,pattern)
          • 返回与输入向量同样长度的逻辑向量
          • 可检测字符串string是否能匹配正则表达式pattern
        • str_subset()
          • 作用：直接找出匹配的整体
        • 例：words[str_detect(words,"x$")] 等价于str_subset(words,"x$")
        • str_count(string,pattern="")
          • 计算出字符串中能匹配正则字符串pattern的次数
      • 提取子字符串，即将一个字符串中匹配正则表达式的子串提取出来（一般与str_subset结合使用）
        • str_extract(string,pattern)
          • 对string的每个元素仅做一次匹配
          • 将从字符串string中提取出能够匹配正则表达式pattern的子串
          • 若未发现匹配则返回NA
          • str_extract()找出一个匹配即停止，而str_extract_all()找出所有匹配
        • str_extract_all() 提取全部匹配的元素，返回结果默认为列表list
          • str_extract_all(...,simplify=T)返回一个矩阵
        • 正则表达式含有子表达式即分组，那么还可以提取出这些子表达式匹配到的内容
          • str_match(string,pattern)
            • 返回一个矩阵，第一列是整个正则表达式匹配到的子串，其后各列是各正则表达式匹配到的子串
            • 对string的每个元素仅做一次匹配
          • str_match_all()
            • 会找出所有的匹配
      • 替换，即将一个字符串中匹配正则表达式的子串替换为另一个字符串
        • str_replace() ：使用新字符替换匹配内容
        • str_replace_all() ：执行多次替换
        • 例：x<-c("apple","pear") str_replace(x,"[aeiou]","-") [1] "-pple" "p-ar" str_replace_all(x,"[aeiou]","-") [1] "-ppl-" "p--r"
        • 在替换时，可以用正则字符串来找到替换目标，再使用回溯引用来插入匹配中的分组
      • 字符串拆分，即使用正则表达式作为分隔符，将一个长字符串拆分成若干小段
        • str_split(string,pattern）
          • 使用正则表达式pattern作为分隔符，将字符串string拆分成若干小段
          • 返回值为一个列表；如果是拆分一个句子，那么只要提取返回值的第一个元素
          • 拆分单词时，可以使用boundary("word")来表示单词边界
            • 例：x<-"apples,pears,and bananas" str_split(x,boundary("word"))[[1]] #"apples" "pears" "and" "bananas"
        • str_split_all()
        • 其它参数
          • simplify:输出类型
            • simply=TRUE输出矩阵
            • simply=FALSE默认值 输出list
          • n 控制输出片段的个数
      • 定位匹配内容
        • str-locate():对每个字符串给出第一个匹配开始位置和结束位置，返回一个matrix
        • str_locate_all() :对每个字符串给出每个匹配开始位置和结束位置,返回一个list
  • 其它类型的匹配模式
    • str_系列函数中，可加的参数控制具体的匹配方式
    • str_*(string,regex(pattern,paramenters))
      • regex()函数
      • paramenters指regex里的参数
        • ignore_case=TRUE忽略大小写
        • multiline=TRUE改变锚点作用位置，可以从每行的开头和末尾匹配
        • comments=TRUE忽略在正则表达式的字符串书写形式中加入的注释和空白
        • dotall=TRUE：使.可以匹配换行符\n
• 网页爬虫
  • 还没有懂

输入与输出

• 使用readr包输入数据
  • 输入
    • 步骤：先输入将文件转化为tibble，再将tibble中的数据转化为需要的数据形式
    • 输入函数系列：将输入文件转化为数据框
      • readr包：readr包中的大多数函数是将没有相对关系记录的文件转换为tibble(并且不会将字符向量转化为因子，不使用行名称，也不会随意改变列名称)
      • 函数
        • read_csv( )：读取逗号定界文件
        • read_csv2( ):读取分号定界文件
        • read_tsv( ):读取制表符定界文件
        • read_delim( ):读取特定符定界文件
        • read_fwf( ):读取固定宽度文件
        • read_table( ):读取空格分隔的表
        • 补：查看read_csv()和read_tsv()共有的参数
          • union(names(formals(read_csv)), names(formals(read_tsv)))
      • 基本格式（以read_csv为例子）
        • 使用
          • read_csv( file, col_names=TRUE, col_types=NULL, locale=default_locale(), na=c("","NA"), quoted_na=TRUE, quote="\", comment="", trim_ws=TRUE, skip=0, n_max=Inf, guess_max=min(1000,n_max), progress=show_progress() )
        • 参数
          • file:文件名/指定读取路径
          • col_names
            • col_names=TRUE 输入文本的第一行自动成为列
            • col_names=FALSE 自动给列名：x1,x2....
            • col_names=c( ) 自定义列名
          • na=c("")
            • 定义缺省值的表示
            • 例：read_csv("a,b,c\n1,2,.",na=".") 即定义.为NA
          • comment="#",忽略注释（注释的标识为#）
          • skip=n 忽略文件前n行，即忽略一些表头信息
          • col_types=cols(colname1=col_*(),colname2=col_*（）)
            • 使用read_*()函数簇读取数据文件时，这些文件会根据数据文件初始的若干行（默认是前十行）来推测各列的数据类型，如果这种推测不正确，那么需要手动指定各列的数据类型
            • 例：mydata<-read_csv(myfile, col_types=cols(colname1=col_integer(),colname2=col_character)) #指定colname1的数据类型为integer,指定colname2的数据类型为character
          • n_max=Inf :界定最大读取记录
          • progress=show_progress( ) :显示读取进度
          • "\n"为增加行的快捷表达
          • locale=default_locale( ):地点界定，缺省是以美国为中心的，不同的地点/国家在time zone,encoding,decimal mark,big mark, and day/month names等方面存在差异
        • 补:该函数实际上是一行一行地读入记录文件
    • 解析一个向量:将数据转化为需要的形式
      • parse_*()函数族
        • 1.parse_* ()函数族接受一个字符向量，并返回一个特定向量，如逻辑、整型或日期向量
        • 2.解析失败时，会收到一条警告；解析失败的值在输出时以缺失值的形式存在
        • 3.当缺失值太多时，可以用problems()函数得到完整的集合，显示期望值和实际值。然后可以用dplyr做进一步的操作
        • 用法：第一个参数是需要解析的字符向量，na参数设定了哪些字符应该当做缺失值来处理
      • 具体解析函数
        • 解析逻辑值：parse_logical( )
        • 解析整数：parse_integer( )
        • 解析数值
          • parse_double( )严格的数值型解析函数
            • 可以解决分隔实数中的整数和小数部分采用的符号不同的问题
            • 参数：locale=locale(decimal_mark=" ")
            • 例子：pares_double("1,234",locale=locale(decimal_mark=",")) #1.234
          • parse_number( )灵活的数值型解析函数
            • 可以解决数值周围有表示某种意义的其它字符/忽略数值前后的非数值型字符，如$1000或10%
            • 参数
              • locale=locale(grouping_mark=" ")：忽略分组符号
              • 例子：parse_number("123'456'789",locale=locale(grouping_mark="'")) #123456789
            • 例子：parse_number("$100") #100
        • 解析字符串
          • parse_character( )
            • charToRaw():可以查看一个字符背后的16进制数值--从16进制到字符的映射成为编码
            • guess_encoding()函数：帮助找出编码方式
              • 第一个参数可以是一个文件路径，也可以是一个原始向量
              • 例：guess_encoding(charToRaw(x))
            • 参数：locale=locale(encoding=" ") 设定编码方式
        • 解析因子
          • parse_factor()
            • 可以创建因子，来表示分类变量，该变量具有固定数目的已知值
            • 参数：levels=c(...)
              • 如果levels参数被赋予一个已知向量，那么只要向量中没有的值，就会生成一条警告信息
        • 解析日期、日期时间、时间
          • 解析
            • 日期时间
              • parse_datetime()
                • 解析:年、月、日、小时、分钟、秒
            • 日期
              • parse_date()
                • 解析:年、月、日
                • 期待的格式："2022-04-26","2022/04/26"
            • 时间
              • parse_time()
                • 解析：小时、分钟、秒、标识符a.m./p.m.
                • 期待的格式："小时：分钟（：秒）（a.m./p.m.）"
            • 补：第一个参数是需要解析的向量，若为期待的格式，则不需要再设置格式；若不是期待的格式，则需要根据要解析的向量来设置格式
            • 格式
              • 年
                • %Y：4位数
                • %y: 2位数
              • 月
                • %m: 2位数
                • %B：完整名称 如January
                • %b：简写名称 如Jan
              • 日
                • %d：1或2位数
                • %e：2位数
              • 小时
                • %H：0-23小时
                • %I：0-12小时 必须和%p一起运用（%p表示a.m./p.m.）
              • 分钟
                • %M
              • 秒
                • 整数秒：%S
                • 实数秒：%OS
              • 其它
                • 时区：%Z
                • 与国际标准时间的时差：%z 如+0800
                • 非数值字符
                  • %. ：跳过一个非数值字符
                  • %* :跳过所有非数值字符
• 输出数据
  • write_csv()
    • write_csv(x,path,na="NA",append=FALSE,coi_names=!append)
    • 参数
      • x:要保存的数据框
      • path:保存文件的位置
      • na:设定如何写入缺失值
      • append:是否追加到现有文件
  • write_tsv()
  • write_excel_csv()
    • 可以将CSV文件导入为Excel文件
  • write_delim()

tidyr包整理数据

• tidyverse包的一部分，用于改变data.frame和tibble的行列结构，以使数据更便于应用tidyverse包来处理
• 什么是整齐的数据 tidy dataset
  • 整理数据集三个相互关联的规则
    • 每个变量对应一列
    • 每个观察对应一行
    • 每个值对应一个数据格
  • 整齐数据的实践标准
    • 将数据集放到tibble中
    • 将每个变量单独放一行
• 扩展与收拢（宽窄变换）
  • 原因：大部分数据不是整齐的，意味着在很多情况下需要进行整理数据
  • 收拢
    • gather() 函数
      • 作用：把若干列合成一列
      • 使用
        • gather(data, key="", value="", col1,col2,..., na.rm=FALSE, convert=FALSE, factor_key=FALSE)
      • 参数
        • col1、col2:数据集data中的列名，要将他们合成一列； 这些列的名字会被放在一列，列名由参数key指定； 这些列的值会被放在另一列，列名由参数value指定
        • 补：各列的名字col1、col2等如果是普通的标识符（以英文字母开始且不含特殊字符），可以省略引号
        • convert=FALSE 是否自动转换数据类型，默认为否
        • factor_key=FALSE 是否自动转为因子，默认为否
      • 使用场景：某个变量的值变成了多个列名
    • 结果：从形式上，gather()会将一个宽数据集变成一个长数据集
  • 扩展
    • spread()函数
      • gather()函数的逆向操作
      • 作用：将一列拆分成若干列
      • 使用
        • spread(data, key, value, fill=NA, convert=FALSE, drop=TRUE, sep=NULL)
        • 参数
          • data:指定了数据集
          • key:所指列的值将作为各个新列的名字
          • value:所指列的值将做为新列的值
        • 结果：从形式上看，spread()会将一个长数据集变成一个宽数据集
      • 使用场景：变量名成为了值
• 值的合并与分开
  • 值聚合
    • 将多列数据合并成一列，并用特殊分隔符连接原有数据
    • unite()函数
      • 使用
        • unite(data, col="name", col1,col2,..., sep="", remove=TRUE)
      • 参数
        • col :定义新列的变量名
        • col1,col2 :要合并的一组列
        • sep=" " :分隔符
        • remove=TRUE 是否删除原有列
        • fill=NA 空缺值用NA填充；fill="0"空缺值用0填充
  • 值拆分
    • 将一列的值拆分成若干段，从而生成多个列
    • separate()函数
      • 使用
        • separate(data, col, into, sep=" ", remove=TRUE, convert=FALSE, extra="warn", fill="warn")
      • 参数
        • col :指定要拆分列
        • into:定义新变量的名字，使用c()函数
        • sep
          • 分隔符，使用正则表达式表示，即如果分隔符中有特殊字符，那么需要转义
          • sep="n" 从字符串的指定位置n开始分割
          • sep="/" 从/开始分割 并去掉/
        • remove=TRUE 是否删除原有列
        • fill
          • fill="warn"发出警告，并在右侧填充
          • fill="left" 填充在左侧
          • fill="right"填充在右侧
        • extra
          • extra="warn"发出警告并删除额外值
          • extra="drop"在不发出警告的情况下删除额外值
          • extra="merge"
        • convert=FALSE 是否自动转换数据类型，默认为否
• 补充
  • 对于两个分类变量：绘图时常用geom_count()和geom_tile();在使用geom_tile()时通常结合count()和管道语言使用，计算各种分类变量的组合数量
  • 对于一个分类变量和一个连续变量：常用geom_bar()、geom_histogram()、geom_freqpoly()、geom_boxplot()
  • 对于两个连续性变量：可以使用geom_point()；当数据过于庞大时:A可以使用geom_bin2d()进行二位分箱B可以对一个连续性变量进行分箱，因此这个连续性变量的作用就相当于分类变量，借助aes(group=cut_width(变量，分箱宽度)），aes(group=cut_number(变量，分箱宽度))可以近似显示每个分箱中的数据点的数量

数据转换

• 对行的操作
  • 筛选行
    • 相关函数
      • filter()
        • 根据列的值筛选出符合条件的行
        • 使用：filter(.data,condition1,condition2,...)
        • 参数
          • .data:一个data.frame或tibble
          • condition :用列表示的筛选条件，只有满足所有条件的行才会被留下来；返回值为筛选出的行
        • 构建条件表达式时可使用
          • 关系运算：==,>=,>,<,<=,!=
          • 逻辑运算
            • 并&
            • 或|
            • 异或 xor(x,y ):x与y的并集，并且去除交集的部分
            • 非！
            • %in%
              • 例：filter(flights,month%in%c(1,2))
          • 对缺失值的判断：is.na()
          • 其它
            • near() :用于比较浮点数是否相等
              • 例：near(1/49*49,1) #TRUE
            • between()
              • 作用：可以帮助抽取变量在某个范围内的观测；也是返回逻辑值
              • 例：filter(flights,between(month,1,3))
      • distinct(.data,...,keep_all=FALSE)
        • 作用：将重复值的行剔除
        • keep_all=TRUE 保留表中所有变量
      • sample_frac(tbl,size=)
        • 作用：从tbl中抽取size比例的数据
        • 参数
          • size:0-1抽取多少比例
          • btl:数据框
        • 例：sample_frac(flights,size=0.05) #随机抽取flights数据集中5%的观测
      • sample_n(btl,size,replace=FALSE)
        • 作用：随机产生固定案例数的样本
        • 参数
          • tbl:数据框
          • size:抽取多少行
          • replace:是否重复抽取
        • 例：sample_frac(flights,size=10,replace=10) #随机抽取flights数据集中的10行，可以重复
      • slice(.data,...)
        • 作用：根据位置选择行，不能与关系函数并用
        • 参数
          • .data:数据框
          • ... :整数型的行值，即挑选哪些行
        • 例：slice(flights,1:6) 挑选flights数据集的前6行
      • top_n(x,n,wt)
        • 作用：排序并选择前面的案例
        • 参数
          • x:数据框
          • n:展示前n行
          • wt:结合别的变量操作
  • 排序
    • 含义：将表中的行按某一列或几列的值，从低到高或从高到低排序
    • 函数
      • arrange(.data,colname1,colname2,...)
        • 排序函数，可对各行进行排序
        • 参数
          • colname:列的名字，也可以是变量名称的相关表达式，但是表中不会多出关于这个表达示的变量，但是会按照这个排序
          • data:data.frame或tibble
        • 排序规则
          • 默认为升序，从小到大排序
          • 可用desc(colname)改为降序
          • 无论升序降序，缺省值NA总排列在最后
          • 如果指定了多个排序的列名，那么将进行多重排序：先根据colnames1的值对各行进行排序，若两行的colname1的值相同，再根据colname2的值进行排序，依次类推
          • 通常只会对数值型、字符串、逻辑型数据排序，对于TRUE/FALSE,有TRUE>FALSE
        • 例：arrange(flights,desc(distance/air_time) 观测按照distance/air_time降序排列 arrange(flights,year,month,day)
  • 案例添加add cases
    • 含义：对表添加一行或几行案例
    • add_row(.data,...)
      • 参数
        • data:需要增加行的数据框
        • ... :填写各变量的值
      • 例：add_row(df,x=4,y=0)
• 对列的操作
  • 选择列
    • 含义：选取特定变量形成子集，作为一张新的表
    • 函数
      • select(.data,colname1,colname2,...)
        • 作用：从数据集中筛选出指定的列
        • 参数
          • colname:列的名字
          • data:data.frame/tibble
        • 在筛选时，可以将筛选出的列重命名
          • new.colname=old.colname
        • 帮助函数（与select结合使用）
          • contains("abc"):选取名称中包含abc的变量
          • starts_with("abc"):选取名称以abc开始的列
          • ends_with("abc"):选取名称以abc结尾的列
          • matches(）：匹配正则表达式
          • everything():表示剩余的所有列，应在最后使用此函数
            • 例：select(flights,day,month,year,everything())
          • one_of()
            • 例：select(flights,one_of("dep_delay","arr_delay")) #抽取flights数据集中的列dep_delay和arr_delay
          • columnA:columnB 即用冒号连接连个列名，表示从columnA到columnB的所有列
          • -columnA :表示删掉columnA列
            • 例：select(flights,-distance,distance) #将distance放在最后一列
          • num_range(prefix,range)
        • 补：若一个变量多次出现，那么select()会自动忽略不是第一次出现的重复变量
  • 将列重命名
    • rename(.data,new.colname1=old.colnames1,...)
      • 作用：给列重命名
      • 参数
        • .data:data.frame/tibble
        • new.colname=old.colname: 重命名 新=旧（新的在左，旧的在右）
      • 例：rename(flights,Year=year)
      • 注：如果列名中含有特殊字符，应该使用引号
        • 例：rename(flights,"年"=year)
  • 计算新的列
    • 含义：用向量化的函数来创建新列；向量化函数以已有向量为输入，输出相同长度新向量
    • 函数
      • 主要函数
        • mutate(.data,...)
          • 作用：创建新列，保留旧列；新列的值通常是根据现有各列的值计算而得
          • 会将计算出的新列附加在原数据集之后
          • 例：mutate(flights,gain=arr_time-dep_time)
          • 关于刘的没有补充完
        • transmute(.data,...)
          • 作用：创建新列，忽略旧列
        • 注：计算新列时，除了可以使用算术运算符之外，还可以使用函数，但是要求这种函数能够进行向量运算（因为列都是向量）；因此如果要使用ifelse()函数，那么在逻辑条件中应使用|和&,而不是||和&&
      • mutate_at(.btl, .cols, .funs,...)
        • 作用：特定化某列
        • 例：mutate_at(flights,vars(contains("dep")),(~./60)) #对flights数据集中包含dep的变量全部除以60
      • add column(.data, ... , .before=NULL, .after=NULL)
        • 作用：在特定位置增加新列，归入到tibble包
• 分组统计
  • 函数
    • 主要函数
      • group_by(.data,...)
        • 作用：用于将数据集指定的列进行分组
      • summarise(.data,...)
        • 作用：通常和group_by()一起使用，用于对各组进行统计计算
        • 例：不和group_by()一起使用summarise(flights,delay=mean(dep_delay,na.rm=TRUE)) #delay 12.6
        • 补：在该函数中还可以使用的函数/常用的摘要函数
          • 位置度量
            • range()：求值域
            • mean()
            • median()
          • 分散程度度量
            • var()：方差
            • sd()：标准误差
            • IQR()：四分位距
            • mad():绝对中位差
          • 秩的度量
            • quantile(x,0.25)：会找出x中从小到大顺序大于前25%而小于后75%的值
            • min()
            • max()
          • 计数
            • n()：计算组内的行数，该函数不需要参数
            • n_distinct(colname): 计算colname列唯一值的个数
          • 定位度量
            • first(colname)：返回colname列的第1个值
            • last(colname)：返回colname列的最后一个值
            • nth(colname,n)：返回colname列的第n个值
          • 逻辑值的计数和比例
            • 除了可以对数值型的列进行统计，summarize()也允许对逻辑型的列进行统计，此时会将TRUE转换为1，将FALSE转换为0
            • sum(x)可以计算出x中为TRUE的行数
              • 例：summarize(flights,long_air_time_count=sum(air_time>200,na.rm=TRUE)) #计算出飞行时间超过200分钟的航班数
            • mean(x)可以计算出x中为TRUE的比例
              • 例：summarize(flights,long_air_time_ratio=mean(ari_time>200,na.rm=TRUE)) #计算出飞行时间超过200分钟的航班比例
      • ungroup()：取消分组，回到未分组的状态
    • 其它
      • count(data,colname)
        • 作用：用于配合管道运算符计算组内行数
        • 例：flights%>%group_by(origin)%>%count(carrier) #在各机场运营的航空公司在2013年的航班数量
        • 完整语法
          • count(data,colnames1,colnames2,...,wt=NULL,sort=FALSE，name="n")
          • 参数
            • colname:用于分组的列名
            • wt:每行的权重，默认值为NULL,表示计算行数
            • sort：表示是否将结果按统计量的值进行降序排列，默认为不排序
            • name:指定了统计量的列名，默认为"n"
      • summarise_all()
      • summarise_if()
      • summarise_at()
  • 分层统计
    • 含义：当使用多个变量进行分组时，每次的summarize()会用掉一个分组变量，因此，我们可以分层对数据集进行由细而粗的统计，即进行统计分层
    • 例： 1.daily<-group_by(flights,year,month,day) daily #有year,month,day三个分组变量，共有365个组 2.per_day<-summarize(daily,flights=n()) #统计每天的航班数,会用掉day这个变量 per_day #剩下year,month这两个分组变量，共有12个组 3.per_month<-summarize(per_day,flights=sum(flights)) #统计每月的航班数,会用掉month这个变量 per_month #剩下year这一个分组变量，共有一个组 4.per_year<-summarize(per_month,flights=sum(flights)) #统计每年的航班数量 per_year #不再有分组
  • 分组的影响
    • 在分组操作中，filter()和mutate()是如何与n(),mean(),rank()等统计函数一起工作的
      • 在分组之后，n()、mean()、rank()等统计函数是以小组为单位进行计算，计算结果作为新列添加在原数据集之后，filter()和mutate()在分组进行统计
    • 不受分组的影响
      • select()
      • arrange（）
        • 默认情况下不受分组影响
        • 若设置参数by_group=TRUE,那么会先按照分组排序，再在各分组内排序
    • 受影响
      • filter(),mutate()每次处理一个分组，在分组内逐行计算
      • sample_n()和sample()受分组影响，会在各分组内抽样
      • n()、mean()、rank()、first()、n_distinct()等统计函数总是以小组为单位进行计算
• DIY
  • 排秩
    • rank()
    • min_rank()
    • dense_rank()
    • row_number()
    • percent_rank()
    • cume_dist()
    • ntile()
  • 偏移函数
    • lead()
    • lag()
  • 累加和滚动聚合
    • cumsum()：累加和
    • cumprod()：累加积
    • cummin()：累加最小值
    • cummax()：累加最大值
    • cummean()：累加均值
• dplyr包
  • 进行数据转换时常用的第三包，可以进行数据筛选、排序、计算等工作
  • tidyverse包的一部分
  • 使用nycflights13包里面的数据作为示例
  • 注：dplyr包的所有函数（filter,arrange,select,rename,mutate,group_by,summarize等）都会返回一个新生成的数据集，原数据集不变
• 管道操作magrittr
  • magrittr包:管道操作工具包，通过管道的连接方式，让数据或表达式的传递更高效
  • magrittr包的使用：4个管道操作符
    • %>%向右操作符
      • 把左侧准备的数据或表达式，传递给右侧的函数调用或表达式进行运行，可以连续操作
      • 最常用
    • %T%向左操作符
    • %$%解释操作符
    • %<>%复合赋值操作符
    • 补：当管道语言无法在一行写完时，需用管道符号结尾表示代码还未写完
• 刘的课件中还有好多例子不明白

处理关系型数据

• 键key
  • 含义：用来连接一对表的变量
  • 主键
    • 一个表的主键能够唯一识别所在数据表的观测，这里的主键可以是一个也可以是多个
    • 可以把主键理解为表的ID
    • 如果一个表的主键由多个列构成，那么处理起来会比较麻烦，通常会人为的为它添加一个ID列作为主键
    • 判断某变量是否为表的主键
      • count()
        • 例：planes%>%count(tailnum)%>%filter(n>1)
  • 外键
    • 若有两个表A、B，C是A的主键，B中也有C列，则C就是B的外键
    • 外键约束主要用来维护两个表之间数据的一致性
  • 代理键
    • 没有主键，可以用mutate()和row_number()生成一个
    • 例：flights%>%mutate(ID=row_number())
• 关系型数据典例
• 关系型数据的操作
  • 连接操作前的准备
    • 最好对每个表都建立主键
    • 检查主键的值是否有缺省
    • 检查外键是否与另一张表的主键是否匹配
      • 可以通过anti_join()来完成
  • 合并连接（以集合的笛卡尔积为基础）
    • 四个连接函数
      • 全连接full join
        • 含义：连接两个tibble时，保留所有x和y中的行
        • full_join(x,y,by=keyCol)
      • 内连接inner join
        • 含义：连接两个tibble时，仅保留同时在两个tibble都出现的行
        • inner_join(x,y,by=keyCol)
          • 理解：x和y是两个tibble,均有keyCol列；在合并时，将keyCol列的值相等的行拼接成一行
      • 左连接left join
        • 含义：连接两个tibble时，保留所有在x中的行
        • left_join(x,y,by=keyCol)
      • 右连接right join
        • 含义：在连接两个tibble时，保留所有在y中的行
        • right_join(x,y,by=keyCol)
    • 注：以上四个函数都是用于连接两个tibble，它们会先计算两个数据集的笛卡尔积，然后再从中挑选出符合要求的数据；四个函数的区别在于挑选的规则不同
    • 定义键列
      • by=NULL
        • 自然连接，使用两个表中所有共同变量作为连接
      • by="x"
        • 自定义连接，使用两个表中一些共同的变量作为连接
      • by=c("a"="b")
        • 匹配两个表中名字不一样的两个变量作为连接
        • 匹配x中的a变量和y表中的b变量，输出结果使用的是x表中的变量
  • 筛选连接（半连接）
    • semi_join(x,y,by=keyCol)
      • y的keyCol的列的值域是一个向量，称为向量值域；该函数的功能就是：检查x的每一行，如果一行的keyCol值在值域向量中，就把这一行保留下来；否则跳过此行。函数的返回值就是所有保留下来的行
      • 即保留x表中与y表中的观测相匹配的所有观测
    • anti_join(x,y,by=keyCol)
      • 与semi_join()相反
      • 功能：将x不在值域范围内的行保留下来
      • 即丢弃x表中与y表中的观测相匹配的所有观测
  • 集合操作
    • 要求参与操作的两个数据集具有相同的列
    • 函数
      • intersect(x,y)：求x和y的交集
      • union(x,y)：求x和y的并集
      • setdiff(x,y)：求在x中但不在y中的行

处理因子的包forcats

• 介绍
  • 对于因子来说，水平值的顺序很重要，例：在绘制条形图时，用因子做横轴变量，各条形图将按因子的水平值排序，如果要改变条形的顺序就需要重新排列因子的水平集
  • 不是tidyverse的核心包，需要单独加载
  • 主要功能：集中于修改因子的水平集
    • 重排水平值:修改因子向量顺序
    • 重编码水平值：修改因子水平值
    • 合并水平值
    • 增加或删除水平值
• 函数
  • 重排水平集
    • 手动调整顺序
      • fct_relevel
        • 例子：F<-factor(c("a","b","c","d"),levels=c("b","c","d","a"))
        • 把c,d放在第一位第二位：fct_relevel(f,c("c","d"))
        • 把a放在第三的水平：fct_relevel(f,"a",after=2)
        • 把a放到最后的位置：fct_relevel(f,"a",after=Inf)
        • 按照某个函数重新排列：fct_relevel(f,sort)
        • 按照随机顺序排序：fct_relevel(f,sample)
    • 类似的三个
      • fct_inorder(f,ordered=NA)：按照各值出现的先后顺序重排水平集
      • fct_infreq(f,ordered=NA)：按照各值出现的次数重排水平集
      • fct_inseq(f,ordered=NA)：按照各值的大小重排水平集，用于重排数值因子的水平集
    • 根据另外一个变量的值调整顺序
      • fct_reorder()
        • 例：fct_reorder(df$color,df$a,min) #color列的因子水平按照a列的值由小到大排
      • fct_reorder2()
    • 随机重新排列
      • fct_shuffle()
        • 注：每次运行都会出现不同的顺序，除非设置种子数即set.seed()
    • 反转顺序
      • fct_rev()
    • fct_shift()
      • 作用：将因子水平左右移动，默认左移
      • 也可以修改向左移动的位数：fct_shift(x,2) #将因子水平向左移动两位
      • 向右移动：fct_shift(x,-1) #将因子水平向右移动
  • 重编码水平值
    • fct_recode()
      • 作用
        • 可以将一个因子的部分或全部水平值重编码
          • new.partyid<-fct_recode(gss_cat$partyid, "new name1"="old name1",...)
          • 会让没有明确提及的水平保持原样
          • 如果修改了一个不存在的水平，会发出警告
        • 将若干个水平值合并为一个水平值
          • gss_cat%>%mutate(partyid=fct_recode(partyid,"new"="old1","new"="old2"))
          • 将水平值old1,old2合并为new
      • 补：在数据集中常与mutate()结合使用
    • fct_lump（）
      • 作用
        • 指定保留的水平值个数，剩余的水平值被合并成一个
          • skin_color<-fct_lump(skin_color,n=5) #仅保留skin_color频数最高的5个水平值，其他水平值被合并在一起
        • 指定保留的比例
          • skin_color<-fct_lump(skin_color,prop=0.1) #仅保留占比高于或等于10%的水平值，占比低的水平值被合并在一起
        • 补：被合并在一起的水平值默命名为Others,可以使用参数other_level指定名字
          • skin_color<-fct_lump(skin_color,prop=0.1，other_level="new name")
      • fct_lump_min()
        • 把小于某些次数的归为其他类
      • fct_lump_prop()
        • 把小于某个比例的归为其它类
      • fct_lump_n()
        • 把个数最多的n个留下，其它的归为一类（如果n<0,则个数最少的n个留下）
      • fct_lump_lowfreq()
        • 将最不频繁的级别合并在一起
    • fct_anon()
      • 作用：用数字标识符替换原因子水平值，原值和顺序不会被保留
    • fct_collapse()
      • 作用：给因子分组，手动定义新的组
      • 例：fct_collapse(gss_cat$partyid,new1=c("",""),new2=c(""))
    • fct_other()
      • 把某些因子归为其它类
      • 例
        • fct_other(f,keep=c("A","B"),other_level="other") #保留水平A和B，其它水平值改为other
        • fct_other(f,drop=c("A","B"),other_level="other") #将A和B归为一类，水平值改为other,其它保持不变
  • 合并水平值
    • fct_c()
      • 拼接因子向量
    • fct_cross()
      • 输出的因子水平定义为输入因子水平的所有组合
  • 增加/删除水平值
    • fct_expand()
      • 增加因子水平
    • fct_explicit()
      • 使缺失值显式显示
      • fct_explicit_na()
        • 给NA一个水平，确保画图或汇总时能用上
        • 例：fct_explicit_na(f,na_level="missing")
    • fct_unify()
      • 作用于列表，用于统一列表内的因子水平
    • fct_drop()
      • 删除特定的级别
  • 其它
    • fct_count()
      • 统计因子个数
      • 例：fct_count(f,sort=T,prop=T) #对统计各个水平个数，并按照个数由大到小排列，并计算各个水平值的比例

lubridate包

• 还有一部分没有看完 期中考试后补
• 关于包
  • 不是tidyverse的核心包，需要单独加载
  • 用于处理日期和时间
• 创建日期或时间
  • 通过字符串创建
    • 日期
      • ymd()函数
        • 例
          • ymd("2021-01-31") #"2021-01-31"
          • ymd(20170131) #"2017-01-31"
        • 如果使用参数tz设置了时区，那么会将日期强制转换为日期时间
          • ymd("2021-1-10",tz="UTC") #"2021-01-10 UTC"
      • mdy()函数
        • 例
          • mdy("January 31st,2021") #"2021-01-31"
      • dmy()函数
        • 例
          • dmy("31-Jan-2021") #"2021-01-31"
      • 也可以将整数转化为日期，实际是先将整数转换为字符串，再解析
    • 时间
      • 各分量可用双位数或单位数，相互之间必须用冒号分隔
      • hms()函数
        • 例：hms("09:23:31") #"9H 23M 31S"
      • hm()函数
      • ms()函数
    • 日期时间
      • ymd_hms()函数
      • ymd_h()函数
    • 补：之前学过将字符串解析为日期时间数据
  • 通过各个成分创建
    • 创建日期
      • make_data(year=1970L,month=1L,day=1L)
        • 可将表示日期的各个成分连接起来
        • 例：make_date(2021,6,10) #"2021-06-10"
        • 注：若是提取数据集中的列，则需要使用$符号，而不能直接使用变量名
      • 常见情景：日期时间数据的各个成分分布在表的多个列当中
        • flights%>%select(year,month,day,hour,minute)%>%mutate(departure=make_datetime(year,month,day,hour,minute))
    • 创建日期时间
      • make_datatime(year=1970L,month=1L,day=1L, hour=0L,min=0L,sec=0,tz=""UTC)
      • 例：make_datetime(2021,6,10,9,25,31.86512) 秒是浮点数，可以有小数位 #"2021-06-10 09:25:31 UTC"
  • 通过其它数据类型创建
    • as_date(x)
      • 将参数x转换成日期
      • 例：as_date("2013/06/10") #"2013-06-10"
      • x若为数值，数值表示距离1970-01-01的天数
        • 例：as_date(10) 偏移10天 #"1970-01-11"
    • as_datetime(x)
      • 将参数x转换成日期时间
      • 例：as_datetime("2013-06-10 23:59:59") #"2013-06-10 23:59:59 UTC"
      • x若为数值，数值表示距离1970-01-01 00:00:00的秒数
        • 例：as_datetime(10*60*60+15*60+23) 偏移10小时15分23秒 #"1970-01-01 10:15:23 UTC"
• 日期时间成分
  • 获取成份
    • 含义：提取日期中的独立成分
    • 可以使用的函数
      • year()
      • month()
        • 参数：lable=TRUE 返回月份的缩写
        • 组合：lable=TRUE abbr=FALSE返回全名
      • yday():一年中的第几天
      • mday():一个月中的第几天
      • wday():一周中的第几天（一个星期的第1天是Sunday）
        • 参数：lable=TRUE返回星期数的缩写
        • 组合：lable=TRUE abbr=FALSE返回全名
      • hour()
      • minute()
      • second()
  • 舍入
    • round_date()
      • 四舍五入
      • 例：myvar<-ymd_hms("2021-06-03 21:35:40") round_date(myvar,"minute") 舍入，精确到分钟 #"2021-06-03 21:36:00"
    • ceiling_date()
      • 入上
      • 例：ceiling_date(myvar,"day") 向上取整，精确到天 #"2021-06-04 UTC"
    • floor_date()
      • 舍下
      • 例：floor_date(myvar,"day") 向下取整，精确到天 #"2021-06-03 UTC"
    • 作用：这些函数可以将日期或日期时间舍入到临近的一个时间单位；这些函数的参数都包括一个待调整的日期或日期时间向量，以及时间单位名称，函数会将这个向量四舍五入、入上、舍下到这个时间单位
    • 参数：时间单位可以是second、minute、hour、day、week、month、bimonth、quarter、season、halfyear、year
  • 设置成分
    • 为日期时间的访问函数赋值，以设置日期时间中的成分，会直接修改日期时间变量本身
    • 使用update()函数，该函数不会修改原日期时间变量，会返回一个新的日期时间
      • 例：dep_hour<-update(dep_time,yday=1)将月份和日都改为这一年的第一天
      • 可以用来帮助将日期中的较大成分设定为常数来探索其中较小成分
• 时间间隔
  • 时期
    • 含义：以秒为单位表示一段精确的时间
    • as.duraton()
    • 创建时期
      • dseconds():将秒数转化为时期
      • dminutes():将分钟数转化为时期
      • dhours():将小时数转化为时期
      • ddays():将天数转化为时期
      • dweeks():将周数转化为时期
      • dyears():将年数转化为时期
    • 计算
      • 可以对时期进行加减法操作
      • 可以和日期型数据相加减
  • 阶段
    • 含义：表示由人工定义的一段时间，如几周或几个月
    • 创建阶段
      • seconds()
      • minutes()
      • hours()
      • days()
      • weeks()
        • 会转化为天
      • months()
      • year()
    • 计算
      • 可以对阶段进行加法和乘法操作
      • 阶段可以和日期相加
  • 区间
    • 含义：表示从起点到终点的一段时间
• 补
  • 当日期时间型数据作为数值使用时（比如在直方图中），1表示1秒，因此分箱宽度86400才能够表示1天；对于日期型数据，1则表示1天
  • 得到当前日期时间：now()函数
  • 得到当前日期：today()函数
• 时区
  • 相关函数
    • Sys.timezone():找出你的当前时区
    • OlsonNames():查看完整的时区名称列表
  • 理解：在R中，时区是日期时间型数据的一个属性，仅用于控制输出；涉及日期时间的操作经常会丢失时区信息，在这种情况下，日期时间会显示你的本地区时
  • 除非使用了其他设置，lubridate总是使用UTC（国际标准时间）
  • 改变区时
    • 保持时间不变，修改其显示方式：newdate<-with_tz(date,tzone=" ")
    • 修改内部时间（区时被标错）：newdate<-force_tz(date,tzone=" ")

函数

• 基础
  • 常用数学函数
    • abs(x):x的绝对值
    • sqrt(x):x的平方根
    • ceiling(x)
      • 向上取整，即不小于x的最小整数
      • 例：ceiling(3.7)=4
    • floor(x)
      • 向下取整，即不大于x的最大整数
      • 例：floor(3.7)=3
    • trunc(x)
      • 阶段取整
      • 例：trunc(-1.6)=-1;trunc(2.4)=2
    • round(x,digits=n)：对x进行四舍五入，保留到小数点后第n位
    • signify(x,digits=n):将x四舍五入成n位有效数字
    • sin(x)、cos(x)、tan(x)：x的正弦、余弦、正切
    • asin(x)、acos(x)、atan(x):x的反正弦、反余弦、反正切
    • log(x,base=n):x的对数，以n为底数；如果省略参数base,则取自然对数
    • exp(x):x的自然对数 exp(5)=e^5
    • 补：以上函数中的x既可以是标量，也可以是向量、矩阵、数据框；通常情况下，将标量定义的函数应用到向量（或其它组合型数据）时，结果是将该函数应用到向量的每个元素上，这种运算被称为向量化
  • 常用统计函数
    • length(x):x的长度
    • mean(x):平均值
    • median(x):中位数
    • sd(x):标准差
    • var(x):方差
    • md(x):平均绝对偏差
    • quantile(x,prob):求样本x的分位点
      • 例：x<-norm(1000); quatile(x,c(0.0.25,0.5,0.75,1)) #计算最小值和最大值，以及各四分位点
    • range(x):求样本的值域
    • sum(x):求和
    • min(x):求最小值
    • max(x):求最大值
    • scale()
      • 将样本x标准化，即将样本转化为均值为0，方差为1的新样本
      • 使用：scale(x,center=TRUE,scale=TRUE)
      • 参数
        • center:在标准化时是否要将均值化为0，默认为TRUE
        • scale:在标准化时是否要将标准差化为1，默认为TRUE
    • diff(x, lag=n)
      • 求滞后n步的差分，默认lag=1
  • 常用概率函数
    • 概率函数名：[d b q r]DistributionName()
      • 第一个字母d、p、q、r表示函数的功能
        • d:表示密度函数
        • p:表示累计分布函数
        • q:表示分位点函数，即累计分布函数的逆函数
        • r:表示生成随机数
      • DistributionName：概率分布的名字
        • 常用的分布：norm正态分布；unif均匀分布
        • 每个概率分布函数都有若干参数：正态分布有参数mean和sd;均匀分布有参数min和max
    • 例
      • rnorm(100,mean=10,sd=3)从正态分布N(10,9)随机抽取100个点
      • runif(100,min=1,max=5)从均匀分布U[1,5]随机抽取100个点
  • 其它实用函数
    • c()：连接
    • cut(x,n)
      • 将连续型变量x分割为有x个水平的因子
    • length(x)
      • 求向量或列表x的长度
    • str(x)
      • 查看对象x的结构
    • print(x)
      • 作用：将x转换成字符串，打印到屏幕上
    • veiw(flights):会直接出现数据集flights文件
    • glimpse()
    • args()：查看函数的格式
    • formals():查看函数的所有参数以及默认值
    • replicate(x,y) ：重复运行y重复x次
    • pretty(x,n)
      • 将向量x指定的区间分成n等份，通常在绘图时使用此函数创建横坐标值
• 自定义函数
  • 创建
    • name<-function(){}
    • name:为函数命名
    • functon():列举出function中所用的输入，即参数
    • {}：放置编写好的代码，即函数体
  • 条件执行
    • 条件
      • if(condition){} else{}
        • condition的值：要么是TRUE要么是FALSE；如果是向量会收到警告；如果是NA，程序会出错
        • 关于条件为逻辑表达式
          • 可以使用||和&&来组合多个逻辑表达式，且具有短路效应
          • 不能使用|和&，它们是向量化的操作符，只可以用于多个值
          • 若一定要使用逻辑向量，可以使用any()或all()函数将其转化为单个逻辑值
        • 关于测试相等关系时
          • ==是向量化的，很容易输出多个值
          • 可以检查结果的长度是否为1，然后使用all()或any()函数进行转换
          • 使用非向量化的函数：identical()返回一个TRUE或一个FALSE
          • 浮点数：使用near() (需加载dplyr包)
        • 如果if语句非常短，可以在一行内写下，那么可以不用大括号
    • 多重条件
      • 将多个if语句串联起来
        • if(this){} else if(that){} else{}
      • 借助switch()和cut()
        • switch(1, "apple", "banana", "cantaloupe") #> [1] "apple"
  • 函数参数
    • 分类
      • 一类提供需要进行计算的数据
      • 一类控制计算过程的细节
    • 注：通常情况下，数据参数一个放在最前面，细节参数则放在后面，而且一般都有默认值
    • 参数名称
      • R中一些短的通用名称
        • x,y,z:向量
        • w:权重
        • df:数据框
        • i,j:数值索引（通常用于表示行和列）
        • n:长度或行的数量
        • p:列的数量
    • 点点点
      • ... : 特殊参数，会不活任意数量的未匹配参数
  • 返回值
    • 函数的返回值通常是最后一个语句的值，但是可以通过return()语句提前返回一个值

数据集

• 绘图ggplot2
  • mpg
    • 该数据集包含 EPA 在 https://fueleconomy.gov/ 上提供的燃油经济性数据的子集。 它仅包含 1999 年至 2008 年间每年发布新版本的车型 - 这被用作汽车受欢迎程度的代表。
    • 变量/列名
      • character
        • manufacturer：生产商名字
        • model：model name
        • drv: the type of drive train, where f = front-wheel drive, r = rear wheel drive, 4 = 4wd 驱动类型，有4种
        • trans：传输类型
        • fl：汽油种类
        • class：汽车类型
      • integer
        • cty：每加仑城市英里数
        • hwy：每加仑公路英里数
        • cyl： 气缸数
        • year：生产的年份
      • double
        • displ： 发动机排量，单位：升
  • diamonds
    • 包含大约54000颗钻石的信息
    • 变量
      • price:价格
      • carat:钻石重量
      • cut:切割质量，五种：Fair, Good, Very Good, Premium, Ideal
      • color:钻石颜色，from D (best) to J (worst)，7种
      • clarity: 钻石清晰度 ,共8种：I1 (worst), SI2, SI1, VS2, VS1, VVS2, VVS1, IF (best)
      • x:长度length in mm (0–10.74)
      • y:宽度width in mm (0–58.9)
      • z:depth in mm (0–31.8)
      • table:钻石顶部相对于最宽点的宽度（43–95）
      • depth:总深度百分比
• dplyr关系型数据
  • nycflights13包
    • flights
      • 是一个tibble,包含了2013年从New York City出发的所有航班信息，每个航班为一行
      • 变量/列名
        • year，month,day:航班的年、月、日
        • dep
          • dep_time : departure time 起飞时刻 ，格式为：小时+分钟 例：517表示5:17
          • sched_dep_time : scheduled departure time 计划起飞时刻
          • dep_delay : departure delay 起飞延误时长 =dep_time - sched_dep_time
        • arr抵达时间
          • arr_time 实际值
          • sched_arr_time计划值
          • arr_delay延误值
        • hour,minute
          • 计划起飞时刻，与sched_dep_time的值一致
        • time_hour
          • 计划起飞时刻（只有日期与小时）
        • air_time
          • 飞行时长（单位：分钟）
        • carrier
          • 航空公司（简称）
        • tailnum
          • 飞机的ID tail number
        • flight
          • 航班的编号
        • origin,dest
          • 出发地与目的地（简称）
        • distance
          • 航线长度（单位：mile）
    • planes
      • 记录了每架飞机的信息
      • 列名
        • tailnum:飞机的机尾编号，是每架飞机的ID
        • year:飞机的制造年份
        • type:飞机的类型
        • manufacture:飞机的制造商
        • model:飞机型号
        • engines:引擎数量
        • engine:引擎的类型
        • speed:平均巡航速度（单位：mph）
    • weather
      • 记录了每个机场的逐小时天气状况
      • 列名
        • origin:气象站所在的机场
        • year,month,day,hour:记录的时间点
        • temp:温度
        • dewp:露点
        • humid:相对湿度
        • wind_
          • wind_dir:风向
          • wind_speed:风速
          • wind_gust:降风速率
        • precip:降水量precipitation
        • pressure:海平面标准气压
        • visib:能见度
        • time_hour:记录的日期和小时
    • airlines
      • 记录了各航空公司的简称和全称
      • 列名
        • carrier:航空公司的简称
        • name：航空公司的全称
    • airports
      • 记录了各机场的信息
      • 列名
        • faa:机场的简称，每个机场的ID
        • name:机场的名字
        • lat,lon:机场的经纬度
  • babynames包
    • 美国1880-2017年婴儿姓名
    • babynames
      • 包含五个变量的数据框架：年份、性别、姓名、n和prop
      • 变量
        • year:年份
        • sex:性别
        • name:姓名
        • n：在该年份该性别下该姓名的总数
        • prop=n/n_all
    • applicants
      • 变量
        • year:年份
        • sex：性别
        • n_all:在该年份该性别下的总姓名申请数
    • births
      • 变量
        • year:年份
        • briths:出生人数
    • lifetables
      • 变量
        • year:年份
          • 仅有12个值：1900/1910/1920/1930/1940/1950/1960/1970/1980/1990/2000/2010
          • 每个年份按性别分别选取0-119岁，因此每个年份count=240
        • sex:性别
        • x:在该年份year下的年龄
        • qx:在该年龄下死亡的概率
        • lx:
        • dx=qx*lx 在该年龄下的死亡人数
        • Lx:
        • Tx：x年龄以外的总人数
        • ex：同龄人在x岁时平均剩余寿命年数
• tidyr包 5个数据集
  • 5个数据集均记录了Afghanistan,Brazil和China在1999年和2000年肺结核病例数量cases和人口数量population,但是这5个数据集的行列结构不同，只有table1是一个tidy数据集，其它均不满足要求
• 数据框处理
  • cars
    • 数据框cars记录了50次刹车实验的结果，共有2列
    • 变量
      • speed:记录了刹车时的速度，单位：英里/小时
      • dist:记录了刹车所用的距离，单位：英尺

向量

• 向量基础
  • 向量类型
    • 原子向量
      • 逻辑型
      • 数值型
        • 整型
        • 双精度
      • 字符型
      • 复数型
      • 原始型
    • 列表：又称递归向量，因为列表中也可以包含其它列表
  • 区别：原子向量的各个值都是同种类型的，列表中的值可以是不同类型的；
  • NULL
    • 一个与向量相关的对象，用于表示空向量，通常指长度为0的向量
    • 与表示向量中的一个值为空的NA不同·
  • 属性
    • 每个向量都有两个关键属性
    • 类型：使用函数typeof()
    • 长度：使用函数length()
  • 特性
    • 含义：可以向向量中任意添加额外的元数据，这些元数据称为特性
    • 相关函数
      • attr()函数：用来读取和设置单个特性值
      • attributes()函数：同时查看所有特性值
    • 3种重要的特性
      • 名称
      • 维度
      • 类
• 原子向量
  • 重要的原子向量
    • 逻辑型：只有三种可能的取值TRUE、FALSE、NA
    • 数值型
      • R中默认数值是双精度型的，想要创建整型数值可以在数字后面加一个L
      • 双精度和整型的重要区别
        • 双精度是近似值，表示的是浮点数，不能由固定数量的内存精确表示
          • 在处理浮点数时，不能使用==，而应该使用dplyr::near()
        • 整型数据有一个特殊值NA，双精度型数据则有四个特殊值：NA,NaN,Inf,-Inf
          • 其它三个特殊值都可以由除法产生：c(0,1,-1)/0
          • 不要使用==来检查特殊值
    • 字符型
      • 每个元素都是一个字符串，而字符串可以包含任意数量的数据
    • 补：缺失值
      • 每种类型的原子向量都有自己的缺失值
  • 使用原子向量原子
    • 强制转换
      • 显式强制转换
        • as.logical()
        • as.integer()
        • as.double()
        • as.character()
      • 隐式强制转换
        • 当在特殊的上下文环境中使用向量，而这个环境有要求使用特定类型的向量时，就会发生隐式强制转换
    • 检验函数
      • is_*()
    • 标量与循环规则：见5-6部分
    • 向量命名
      • 在使用c()函数创建向量时命名：c(x=1,y=2)
      • 在向量创建完成后，使用purrr::set_names()函数来命名：set_names(1:3,c("a","b","c"))
    • 向量取子集
      • 见5-6
• 递归向量（列表）
  • 相关函数
    • list()：创建列表
    • str():显示列表结构
  • 列表取子集
    • 使用[]:结果总是一个列表
    • 使用[[]]:提取单个元素
    • 使用$：提取单个元素
    • 补：对tibble取子集的情况和list相同，使用[]提取tibble的子集，返回的结果仍是tibble
• 拓展向量
  • 因子
    • 是设计用来表示分类数据的，只能在固定集合中取值
    • 在整型向量基础上构建的，添加了水平特性
  • 日期与日期时间
    • R中的日期是一种数值型向量
    • 日期时间是带有POSIXct类的数值型向量，表示从1970年1月1日开始的秒数
  • tibble
    • 是拓展的列表
    • 有三个类：tbl_df,tbl,data.frame
    • tibble与列表的之间的主要区别就是tibble中所有元素都必须是长度相同的向量

动态报告

• R Markdown
  • 构成
    • YAML
      • 是Rmarkdown的头部文件
      • 定义了Rmarkdown的性质，比如：title,author,date,指定output文件类型
    • 代码块
      • rmarkdown的一个主要功能是可以执行文件内的代码块，并将代码执行结果展示在markdown里
      • 插入代码
        • 快捷键：Ctrl+Alt+I
        • 点击：C R
        • 手动输入代码段标记'''{r }'''
      • 编写代码
        • r后面接代码名字
        • 选项
          • collapse=TRUE会将一个代码块所有的代码、输出都写到同一个文本块中
          • comment=""结果不会用##保护
          • promot=TRUE代码会以>开始
          • result
            • 默认情况下，会把文本型结果变成HTML的原样文本格式
            • result='hide'运行了代码后不显示运行结果
            • result='hold'一个代码块的代码都显示完，才显示所有结果
          • 常用
            • eval=FALSE：不运行代码（相应的也不会有结果），但是会显示代码
      • 全局代码块
        • 一般设置在YAML文件下方
        • '''{r} knitr::opts_chunk$set(选项) '''
    • markdown文本
      • 是rmarkdown里的主要内容，由编辑人员按照markdown语法自行编写文本内容
• 基于knitr的报告

purrr包

• 简介
  • tidyverse的一个子包，用于实现向量化运算
  • 功能：将一个函数（或算子）依次应用在一个向量或列表的每个元素上
• 常用函数
  • map函数簇
    • 功能：将一个函数（或称为算子）依次应用在一个向量或列表的每个元素上
    • map_*()
      • 具体
        • map()：用于输出列表
        • map_lgl():用于输出逻辑型向量
        • map_int():用于输出整型向量
        • map_chr():用于输出字符型向量
        • map_dbl():用于输出双精度型向量
      • 配合匿名函数使用
        • 使用单侧公式：用"."
  • 多参数映射
  • 多函数映射