认识美好的 R

class: center, middle, inverse, title-slide

# 认识美好的 R
## R basics 1
### Chris Qi
### 2018

---

background-image: url(https://www.dropbox.com/s/zk8948u32y01sj8/logo.png?dl=1)
background-size: 700px
background-position: 50% 50%

???

这里可以看笔记哟

---
background-image: url(https://www.dropbox.com/s/zk8948u32y01sj8/logo.png?dl=1)
background-size: 200px
background-position: 95% 3%

# 预备动作

要愉快地使用R, 我们需要走两步：

--
* 到这个网站 CRAN（Comprehensive R Archive Network）[http://www.r-project.org/](http://www.r-project.org/) ，下载R程序。Linux、Mac OS X和Windows都有相应的版本，根据你的电脑系统，选择对应的安装包，下载安装即可。如果你找不到程序位置，那么请看这里[http://ftp.ctex.org/mirrors/CRAN/](http://ftp.ctex.org/mirrors/CRAN/)

--
* 到Rstudio官网[http://www.rstudio.com/ide/download/](http://www.rstudio.com/ide/download/)，下载Rstudio程序，选择desktop那种，免费的就够用了。

* 一般来说，我们不在R里面直接操作，在安装R以后，我们在安装Rstudio，在Rstudio里完成我们所有的工作。R 与 RStudio 是什么关系呢？你可以简单的理解为，RStudio 是话筒，而 R 则是沟通所用的语言。

---
# 预备动作

![](https://www.dropbox.com/s/cy1ls5p6f4qqcya/rstudio.png?dl=1)

---
# 预备动作

R是一种区分大小写的解释型语言。你可以在命令提示符（>）后每次输入并执行一条命令，或者一次性执行写在脚本文件中的一组命令。R中有多种数据类型，包括向量、矩阵、数据框（与数据集类似）以及列表（各种对象的集合）。

---
# 基本运算
可以当作最基本的计算器来使用。

---
# 基本运算
* 加: +

```r
5 + 5
```

```
## [1] 10
```

---
# 基本运算
* 减: -

```r
5 - 5 
```

```
## [1] 0
```

---
# 基本运算
* 乘: *

```r
3 * 5
```

```
## [1] 15
```

---
# 基本运算
* 除: /

```r
(5 + 5) / 2 
```

```
## [1] 5
```

---
# 基本运算
* 乘方: ^

```r
2^5
```

```
## [1] 32
```

---
# 基本运算
* 取余数: %%

```r
28%%6
```

```
## [1] 4
```

---
# 赋值

R使用<-作为赋值符号。

---
# 赋值
* 简单说来，赋值就是给一些东西取个名字，这样以后方便叫它。

---
# 赋值

* 是这么操作的：

```r
my_var<-42
```

---
# 赋值

* 然后你只需要输入my_var，R Console就将42输出来：

```r
my_var
```

```
## [1] 42
```

---
# 对象

一个对象可以是任何能被赋值的东西。对于R来说，对象可以是任何东西（数据、函数、图形、分析结果，等等）

---
# 对象
* 例如：

```r
my_var<-42
my_var
```

```
## [1] 42
```

---
# c() 这个函数

我们也可以使用c() 这个函数 function（c 意指是 combine）来赋值，它把多个对象放到一起，组成向量。

---
# c() 这个函数

```r
lucky_numbers <- c(7, 77)
lucky_numbers
```

```
## [1]  7 77
```

---
#注释

* 注释由符号#开头。在#之后出现的任何文本都会被R忽略而不运行。

---
#注释

```r
#我是注释
# 2+3
```

---
background-image: url(https://github.com/yihui/xaringan/releases/download/v0.0.2/karl-moustache.jpg)
background-size: cover
class: center, bottom, inverse

### 唔，朕很满意！

---

# 帮助查询

* 输入?c 或者help(c)，在RStudio 右下角的介面 召唤出帮助文件 Help。

---
# 功能包

* 上面的c()是我们遇到的第一个函数，我们以后还会遇到许许多多的函数。而功能包则是函数的有机组合，以实现更丰富的功能。

---
# 功能包
* R自带了一系列默认包（包括base、datasets、utils、grDevices、graphics、stats以及methods），它们提供了种类繁多的默认函数和数据集。其他包可通过下载来进行安装。安装好以后，它们必须被载入到会话中才能使用。命令search()可以告诉你哪些包已加载并可使用。

---
# 功能包
* 第一次安装一个包，使用命令install.packages()即可，例如：

```r
install.packages("dplyr")
```

---
# 功能包
* 一个包仅需安装一次。但和其他软件类似，包经常被其作者更新。使用命令update.packages()可以更新已经安装的包。

---
# 功能包
* 要在R会话中使用包，还需要使用library()命令载入这个包：

```r
library(dplyr)
```
--

* 当然，载入前，一定要先下载，确保有包可以调用才行。

--
* 然后我们就可以愉快的使用包了，具体来说里面的各种函数和数据。包中往往提供了演示性的小型数据集和示例代码，能够让我们尝试这些新功能。

---
# 功能包
* 使用 help(package="package_name")可以查看某个包的简短描述以及包中的函数名称和数据集名称的列表。使用函数help()可以查看其中任意函数或数据集的更多细节。

---
# 查看路径和设置路径

路径（工作路径）是我们读取数据和存贮结果的地方。

---
# 查看路径和设置路径
* getwd()

---
# 查看路径和设置路径
* setwd(yourpath)

---
# 查看路径和设置路径
* 或者使用RStudio右下方,Files这个tab里的齿轮来查看和更改。

---
# 数据类型

主要有这几种：

* 数值型 numerics (1, 2.5)
--

* 逻辑判断 logical (TRUE or FALSE)

--
* 字符型 characters

--
* 因子 factors

---
# 数据类型

```r
# Change my_numeric to be 42
my_numeric <- 42

# Change my_character to be "universe"
my_character <- "universe"

# Change my_logical to be FALSE
my_logical <- FALSE
```
--

* 因子 factors复杂一点，也非常有用，单独来讲一下。

---
# 如何判断数据类型

* 使用 class() 函数

```r
# Declare variables of different types:
my_numeric <- 42
my_character <- "universe"
my_logical <- FALSE
```

---
# 如何判断数据类型

```r
class(my_numeric)
```

```
## [1] "numeric"
```
---
# 如何判断数据类型

```r
class(my_character)
```

```
## [1] "character"
```
---
# 如何判断数据类型

```r
class(my_logical)
```

```
## [1] "logical"
```

---
# 数据结构
有这么几个：vector 向量、matrix 矩阵，dataframe 数据集，list 列表。

--
* 向量可以构成矩阵

--
* 矩阵是特殊的数据集

--
* list 是个筐，什么都能装

---
# vector 向量

向量是用于存储数值型、字符型或逻辑型数据的一维数组。执行组合功能的函数c()可用来创建向量。

---
# vector 向量

```r
a <- c(1, 2, 5, 3, 6, -2, 4)
b <- c("apple", "pear", "orange")
c <- c(TRUE, FALSE, TRUE, FALSE, TRUE, FALSE)
```

--
**注意:** 同一向量中无法混杂不同模式的数据。

---
# 提取向量中的元素

通过在方括号中给定元素所处位置的数值，我们可以访问向量中的元素。例如'a[c(2)]'用于访问向量a中的第二个元素。

```r
a[c(2)]
```

```
## [1] 2
```

---
# 提取向量中的元素

```r
b[c(1,3)]
```

```
## [1] "apple"  "orange"
```

```r
c[c(2:4)]
```

```
## [1] FALSE  TRUE FALSE
```

* 最后一个语句中使用的冒号,意思是取第二个到第三元素。

---
# matrix 矩阵

* 矩阵是一个二维数组

* 只是每个元素都拥有相同的模式（数值型、字符型或逻辑型）。

* 可通过函数matrix()创建矩阵。

---
# matrix 矩阵
* 一般使用格式为：

```r
myymatrix <- matrix(vector, nrow=number_of_rows, ncol=number_of_columns,
                    byrow=logical_value)
```

```r
myMatrix <- matrix(1:15, nrow=3, ncol=5)  
myMatrix
```

```
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    4    7   10   13
## [2,]    2    5    8   11   14
## [3,]    3    6    9   12   15
```

---
# matrix 矩阵
* 我们可以使用下标和方括号来选择矩阵中的行、列或元素。

---
# matrix 矩阵
* X[i, ]指矩阵 X 中的第 i 行

```r
y <- matrix(1:18, nrow=2)

y
```

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

```r
y[2,]
```

```
## [1]  2  4  6  8 10 12 14 16 18
```
---
# matrix 矩阵
* X[ ,j]指第 j 列

```r
y <- matrix(1:18, nrow=2)
y
```

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

```r
y[,1]
```

```
## [1] 1 2
```

---
# matrix 矩阵
* X[i, j] 指第 i 行第 j 个元素。

```r
y <- matrix(1:18, nrow=2)
y
```

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

```r
y[2, 3]
```

```
## [1] 6
```

---
# matrix 矩阵
* 选择多行或多列时，下标 i 和 j 可为数值型向量

```r
y <- matrix(1:18, nrow=2)
y
```

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

```r
y[2,c(3:5)]
```

```
## [1]  6  8 10
```
--
* 矩阵都是二维的，和向量类似，矩阵中也仅能包含一种数据类型。

---
# dataframe 数据框

* 数据框将是你在R中最常处理的数据结构

---
# dataframe 数据框
* 不同的列可以包含不同模式（数值型、字符型等）的数据

---
# dataframe 数据框
* 下面的向量包含了数值型和字符型数据。由于数据有多种模式，无法将此数据集放入一个矩阵。

```r
students <- c("A", "B", "C", "D")
students
```

```
## [1] "A" "B" "C" "D"
```

```r
math_score<-c(100, 80, 70, 95)
math_score
```

```
## [1] 100  80  70  95
```

```r
english_score<-c(96, 86, 77, 99)
english_score
```

```
## [1] 96 86 77 99
```

---
# dataframe 数据框
在这种情况下，使用数据框是最佳选择。

```r
students_scores<-data.frame(students, math_score,english_score)
```

--
* 列与列之间数据类型可以不一样，但是每一列数据类型必须一致。

--
* 我们在讨论数据框时将交替使用术语列和变量。

---
# dataframe 数据框

* 选取数据框中元素的方式：可以使用前述（如矩阵中的）下标记号，亦可直接指定列名，例如：

```r
students_scores
```

```
##   students math_score english_score
## 1        A        100            96
## 2        B         80            86
## 3        C         70            77
## 4        D         95            99
```

---
# dataframe 数据框

```r
students_scores[,2]
```

```
## [1] 100  80  70  95
```

```r
students_scores[,"math_score"]
```

```
## [1] 100  80  70  95
```

```r
students_scores$math_score
```

```
## [1] 100  80  70  95
```

---
# dataframe 数据框
* 如果你想生成学生名字变量students和数学成绩变量math的新数据框，使用以下代码即可：

```r
data.frame(students_scores$students, students_scores$math_score)
```

```
##   students_scores.students students_scores.math_score
## 1                        A                        100
## 2                        B                         80
## 3                        C                         70
## 4                        D                         95
```

---
# 因子 factor

* 因子 factor又叫分类变量，有两种：名义型、有序型。

--
* 名义型，例如，学生的名字，它们之间是没有顺序的。

--
* 有序型，例如，好评，中评，差评，它们之间有顺序关系，但是没有数量关系，得不出来不同级别之间的差异具体是多少。

---
# 因子 factor
* 相对应的，像之前栗子里，分数则是一个连续性变量，呈现为某个范围内的任意值，并同时表示了顺序和数量，例如95分就是比90分要高，并且是高5分。

---
# 因子 factor
* 函数factor()以一个整数向量的形式存储类别值，整数的取值范围是[1...k]（其中 k 是名义型变量中唯一值的个数），同时一个由字符串（原始值）组成的内部向量将映射到这些整数上。

---
# 因子 factor
是不是有点晕，不着急，我们看点例子：
--

```r
excellence<- c("excellent", "bad", "good", "okay", "bad")
excellence
```

```
## [1] "excellent" "bad"       "good"      "okay"      "bad"
```
---
# 因子 factor

```r
excellence<- factor(excellence)
excellence
```

```
## [1] excellent bad       good      okay      bad      
## Levels: bad excellent good okay
```

```r
excellence <- factor(excellence, order=TRUE,
                     levels=c("bad", "okay","good","excellent"))
excellence
```

```
## [1] excellent bad       good      okay      bad      
## Levels: bad < okay < good < excellent
```

--
* 这里我们成功的把字符型变量excellence，先转换成了无序因子变量，再转换成了有顺序的因子变量。

---
# 因子
* 数值型变量可以用levels和labels参数来编码成因子。如果男性被编码成1，女性被编码成2，则以下语句：

```r
sex<-c(1,2,2,1,2,1,1,3) 
sex
```

```
## [1] 1 2 2 1 2 1 1 3
```
--

```r
sex <- factor(sex, levels=c(1, 2), labels=c("Male", "Female"))
sex
```

```
## [1] Male   Female Female Male   Female Male   Male   <NA>  
## Levels: Male Female
```

--
* 在这个栗子里，性别被当成类别型变量，标签“Male”和“Female”替代了1和2在结果中输出，而且所有不是1或2的性别变量将被设为缺失值。

---
# list 列表

* 列表（list）是R的数据类型中最为复杂的一种。一般来说，列表就是一些对象（或成分，component）的有序集合。

---
# list 列表
* 列表允许你整合若干（可能无关的）对象到单个对象名下。例如，某个列表中可能是若干向量、矩阵、数据框，甚至其他列表的组合。

---
# list 列表
* 可以使用函数list()创建列表：

```r
a <- "My First List"
b <- c(25, 26, 18, 39)
c <- matrix(1:10, nrow=5)
d <- c("one", "two", "three")
mylist <- list(title=a ,b,c,d)
```

---
# list 列表

```r
mylist
```

```
## $title
## [1] "My First List"
## 
## [[2]]
## [1] 25 26 18 39
## 
## [[3]]
##      [,1] [,2]
## [1,]    1    6
## [2,]    2    7
## [3,]    3    8
## [4,]    4    9
## [5,]    5   10
## 
## [[4]]
## [1] "one"   "two"   "three"
```

--
* 本例创建了一个列表，其中有四个成分：一个字符串、一个数值型向量、一个矩阵以及一个字符型向量。可以组合任意多的对象，并将它们保存为一个列表。

---
# 常用函数
* length(object) ：显示对象中元素/成分的数量

```r
length(mtcars)
```

```
## [1] 11
```

```r
length(mtcars$mpg)
```

```
## [1] 32
```

---
# 常用函数
* dim(object)： 显示某个对象的维度

```r
dim(mtcars)
```

```
## [1] 32 11
```

---
# 常用函数
* str(object) ：显示某个对象的结构

```r
str(mtcars)
```

```
## 'data.frame':	32 obs. of  11 variables:
##  $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
##  $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
##  $ disp: num  160 160 108 258 360 ...
##  $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
##  $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
##  $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
##  $ qsec: num  16.5 17 18.6 19.4 17 ...
##  $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
##  $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
##  $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
##  $ carb: num  4 4 1 1 2 1 4 2 2 4 ...
```

---
# 常用函数
* class(object)： 显示某个对象的类或类型

```r
class(mtcars)
```

```
## [1] "data.frame"
```

---
# 常用函数
* names(object)：显示某对象中各成分的名称

```r
names(mtcars)
```

```
##  [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
## [11] "carb"
```

---
# 常用函数
* c(object, object,...)： 将对象合并入一个向量

```r
c(2, 20)
```

```
## [1]  2 20
```

---
# 常用函数
* cbind(object, object, ...)： 按列合并对象

```r
cbind(students, math_score)
```

```
##      students math_score
## [1,] "A"      "100"     
## [2,] "B"      "80"      
## [3,] "C"      "70"      
## [4,] "D"      "95"
```

---
# 常用函数
* rbind(object, object, ...)： 按行合并对象

```r
rbind(students, math_score)
```

```
##            [,1]  [,2] [,3] [,4]
## students   "A"   "B"  "C"  "D" 
## math_score "100" "80" "70" "95"
```

---
# 常用函数
* head(object)：列出某个对象的开始部分

```r
head(mtcars)
```

```
##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1
```

---
# 常用函数
* tail(object)：列出某个对象的最后部分

```r
tail(mtcars)
```

```
##                 mpg cyl  disp  hp drat    wt qsec vs am gear carb
## Porsche 914-2  26.0   4 120.3  91 4.43 2.140 16.7  0  1    5    2
## Lotus Europa   30.4   4  95.1 113 3.77 1.513 16.9  1  1    5    2
## Ford Pantera L 15.8   8 351.0 264 4.22 3.170 14.5  0  1    5    4
## Ferrari Dino   19.7   6 145.0 175 3.62 2.770 15.5  0  1    5    6
## Maserati Bora  15.0   8 301.0 335 3.54 3.570 14.6  0  1    5    8
## Volvo 142E     21.4   4 121.0 109 4.11 2.780 18.6  1  1    4    2
```

---
# 常用函数
* ls()： 显示当前的对象列表

```r
ls()
```

```
##  [1] "a"               "b"               "c"              
##  [4] "d"               "english_score"   "excellence"     
##  [7] "lucky_numbers"   "math_score"      "my_character"   
## [10] "my_logical"      "my_numeric"      "my_var"         
## [13] "mylist"          "myMatrix"        "sex"            
## [16] "students"        "students_scores" "y"
```

---
# 常用函数
* rm(object, object, ...)： 删除一个或更多个对象。

```r
rm(a, b, c)
ls()
```

```
##  [1] "d"               "english_score"   "excellence"     
##  [4] "lucky_numbers"   "math_score"      "my_character"   
##  [7] "my_logical"      "my_numeric"      "my_var"         
## [10] "mylist"          "myMatrix"        "sex"            
## [13] "students"        "students_scores" "y"
```

---
# 常用函数
* rm(list = ls())：将删除当前工作环境中的几乎所有对象4

---

# 结印

.center[![](https://upload.wikimedia.org/wikipedia/commons/7/7e/Mudra-Naruto-KageBunshin.svg)]

---

class: center, middle

# 蟹蟹