《R语言入门与数据分析》

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

文章目录

- P1 课程介绍
- P2 数据分析
- P3 数据挖掘
- P4 数据可视化
- P5 R语言介绍
- - R语言的特点
  - R语言的缺点
- P6 案例演示
- P7 R软件的安装
- P8 R软件的运行与设置
- P9 Rstudio
- - - 左上脚本窗口
  - 左下控制台窗口
  - 右上环境和历史记录窗口
  - 右下功能模块窗口
  - 快捷键
- P10 Rstudio 基本操作
- - - 图片另存
- P11 R包的安装
- P12 R包的使用
- P13 获取帮助
- P14 Excel案例
- P15 内置数据集
- P16 数据结构
- P17 向量
- P18 向量索引
- - - 正（负）整数索引
  - 逻辑向量索引
  - 名称索引
  - 如何修改向量（包括添加、删除和修改数据）
- P19 向量运算
- - - 数值运算
  - 逻辑运算
  - 向量运算的函数
  - - 数学函数
    - 统计函数
- P20 矩阵与数组
- - - - 创建一个矩阵
  - 数组
  - 矩阵的索引（如何访问矩阵的数据）
  - 矩阵运算
- P21 列表
- P22 数据框
- P23 因子
- - - 变量分类
- P24 缺失数据
- P25 字符串
- - - - 正则表达式
  - 统计字符串
  - 提取字符串
  - 字符串匹配
  - 分割字符串
  - 字符串成对组合技巧——笛卡尔积
- P26 日期和时间
- P26 常见错误
- P28 获取数据
- P29 读取文件（一）
- P30 读取文件（二）
- P31 写入文件
- P32 读写Excel文件
- P33 读写R格式文件
- P34 数据转换（一）
- - - - 矩阵转换为数据框
  - 数据框转换为矩阵
  - is判断类型和as转换类型
  - 向量转换为其他类型
- P35 数据转换（二）
- - - - 取子集
  - 删除固定行的数据
  - 数据框的添加与合并
  - 单独的行和列的添加
  - 删除重复项行列
- P36 数据转换（三）
- - - - 在R中的行列转换
  - 单独翻转某一行
  - 单位的转换
- P37 数据转换（四）
- - - - apply series函数
  - 数据的中心化与标准化
- P38 reshape2
- P39 tidyr包
- P40 dplyr包
- P41 R函数
- - - - 输入数据类型适用函数
- P42 选项参数
- - - - 1、输入控制部分
  - 2、输出控制部分
  - 3、调节部分
- P43 数学统计函数
- P44 描述性统计函数补笔记
- P45 频数统计函数
- - - - 一维频数统计
  - 多维频数统计
- P46 独立性检验函数
- - - - 卡方检验
  - Fisher精确概率检验
  - Cochran-Mantel-Haenszel检验
- P47 相关性分析函数

P1 课程介绍

R语言用途：

统计
绘图

课程设置：

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

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

P2 数据分析

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

目的：指导决策

数据分析过程：

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

数据挖掘：非线性数据，一般指从大量的数据中通过算法搜索隐藏于其中信息的过程（探索的过程）

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

P3 数据挖掘

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

P4 数据可视化

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

P5 R语言介绍

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

R语言的特点

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

用于计算、统计、绘图、编程、分析（扩展包）

R语言的缺点

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

P6 案例演示

0.5mg	1mg	2mg
橙汁
维生素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
>  
[/code]

>
> 可直接显示查看对象

  * History：敲过的代码 

####  右下功能模块窗口

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

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

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

####  快捷键

> Ctrl + ↑

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

> Esc

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

    * 比如一个函数没敲完换行，出现连续几行的“+”的情况，此时可以直接按Esc中断操作 

>
[code]>     > sum(X

>     +
>     +
>     +
>     +
>  
>     >
>  
[/code]

  * 若语句太长，需要一个个删除太麻烦也可以直接按Esc中断操作 

> Alt + shift + K

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

* * *

##  P10 Rstudio 基本操作

  1. 设定工作目录：输入和输出文件的默认位置，包括读取和写入数据文件、打开和保存脚本文件以及保存工作空间映像等 
  2. 可使用getwd命令 **查看当前默认的工作目录**

```code
    > getwd()
    [1] "C:/Users/Lin/Documents"

R中的函数必须加小括号，因为在R中常量、变量、函数甚至图形都被称为对象，而对象都可以用自定义字母表示

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

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

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

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

可使用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

查看工作空间中已经定义的变量和函数：

    > 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"

删除变量（对象）

    > 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())
    #列表和删除的组合函数

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

列出历史命令

    > history(25)
    #适用于清屏后，最大只支持最近25条记录，会在右上角环境窗口显示

保存

图片另存

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

[code] > q()

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

* * *

##  P11 R包的安装

 官网包的位置：进入任意一个R的镜像下载页面（这里以中科大的镜像为例），点击左侧的“ [ Packages
](https://mirrors.ustc.edu.cn/CRAN/web/packages/index.html) ”，再点击正文的“ [ CRAN
Task Views ](https://mirrors.ustc.edu.cn/CRAN/web/views/)

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

R包的安装方式有两种

  * **R包的在线安装（推荐）**

首次安装包应打开R而不是 ~~Rstudio~~ ，并输入：

```code
    > 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 数据结构

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

R中的数据类型

数值型：数值可以用于直接结算，加减乘除；
字符串型：可以进行连接、转换，提取等
逻辑型：真或者假
日期型等

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

一般变成数据结构

普通数据结构：向量、标量、列表、数组、多维数组
特殊数据结构：
- perl中的哈希
- Python中的字典
- C语言中的指针等

R对象

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

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

客服电话

电子邮件