---
title: "L02 统计学导论B-实验课02"
author: "郑盼盼"
date: "2024-09-18"
output:
  pdf_document:
    extra_dependencies:
      ctex: UTF8
      sourcecodepro: scale = 0.85
      sourceserifpro: default
    fig_caption: true
    highlight: default
    latex_engine: xelatex
    toc: true
    toc_depth: 3
  html_document:
    df_print: paged
classoptions: preview
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

## 2.0 变量赋值
- **变量名**：变量名仅包含任何大小写字母,数字 以及下划线`_`（但数字和下划线不能用于变量名开头）；且要注意区分大小写 $\mathrm{a\neq A}$，比如，如下的语句就会报错
  ```{r eval=FALSE}
  a <- 1
  A
  ```
- 三个赋值符号：
  1. `<-` (在RStudio中可以使用快捷键 `alt/option + -` 快速插入)
  2. `=`
  3. `->` 
  
- 以将变量 `a` 赋值为 `1` 为例，以下三种赋值方式等价
  ```{r}
  a <- 1
  a = 1   # 注意：变量名必须在等号的左侧，而值在等号的右侧
  1 -> a
  ```


## 2.1 变量类型
> R语言中变量类型主要包括逻辑型，数值型和字符型三类
>
> 可以使用 `class(变量名)` 的方式查看变量的类型

### 2.1.1 逻辑型 (logical)
- 逻辑型 (logical)：即对于“对(True)”或“错(False)”的表述。仅有 `TRUE` （可简写为 `T`） 和 `FALSE` （可简写为 `F`）两类。
  ```{r}
  # l1,l2,l3, l4 均为逻辑型变量（这里第一个是字母"l"不是数字"1"
  l1 <- TRUE
  l2 <- FALSE
  l3 <- T  # 等价于l1
  l4 <- F  # 等价于l2
  
  paste("l1 = ", l1, ", l1 is ", class(l1))
  paste("l2 = ", l2, ", l2 is ", class(l2))
  paste("l3 = ", l3, ", l3 is ", class(l3))
  paste("l4 = ", l4, ", l4 is ", class(l4))
  ```
- 试试看下面三个语句的结果，并判断结果是什么类型的变量
  1. `1 > 2`
  2. `1 == 0`
  3. `1 != 0`
- 我们可以使用 `is.logical(变量)` 的方式判断一个变量是否为逻辑型
  ```{R}
  x <- 1 > 2
  is.logical(x)
  is.logical(1 > 2)
  ```

### 2.1.2 数值型 (numeric)
- 数值型 (numeric)：例如人的身高，体重，学生的成绩。我们可以用一个数值来表述这些性质。
  ```{r}
  # n1, n2, n3, n4 均为数值型变量。R语言默认存储为浮点型
  n1 <- 3
  n2 <- 1/3
  n3 <- 0.33333
  n4 <- 3.3333e-1   # 科学计数法：3.3333e-1 等同于 3.3333 * (10^-1)
  
  paste("n1 = ", n1,", n1 is the ", class(n1))
  paste("n2 = ", n2,", n2 is the ", class(n2))
  paste("n3 = ", n3,", n3 is the ", class(n3))
  paste("n4 = ", n4,", n4 is the ", class(n4))
  ```
- 试试看：
  1. `TRUE + TRUE`
  2. `TRUE - FALSE`
  3. `3 + FALSE`


### 2.1.3 字符型 (character)
- 字符型 (character)：例如人的性别 (gender)，姓名。一般我们使用一串字符来表示这些性质，字符型变量两边由 `"` 或 `'` 包裹。
  ```{R}
  c1 = "TRUE"
  c2 = "FALSE"
  c3 = "this is 'test'"    # 若希望在字符串中加'可以在外侧用"
  c4 = 'this is \'test\''  # 也可以在'前加\实现字符的转意
  print(c1)
  print(c2)
  print(c3)
  print(c4)
  ```
- 试试看
  1. `'this is "test"'`
  2. `"this is \"test\""`

### 2.1.4 不同类型之间的相互转换
- 转化为数值型 `as.numeric()`
  ```{R}
  a <- "123"
  as.numeric(a)
  
  b <- T
  as.numeric(b)
  ```
- 转化为字符型 `as.character()`
  ```{R}
  a <- T
  as.character(a)
  
  b <- 1e-3
  as.character(b)
  ```
- 转化为逻辑型 `as.logical()` 一切非零的数值都会被转化为 `TRUE`，而零会被转化为 `FALSE`
  ```{R}
  a <- 1
  as.logical(a)
  
  b <- -1
  as.logical(b)
  
  c <- 0
  as.logical(c)
  ```
- 对于无法转换的类型，R会自动转化为 `NA` 即缺失值
  ```{R}
  a <- "0"
  as.logical(a)
  
  b <- "1this is characters"
  as.numeric(b)
  ```

### 2.1.5 特殊常量
| 变量名 | 含义              |
|--------|-------------------|
| `pi`   | 圆周率，3.1415... |
| `Inf`  | 无穷大 `1/0`      |
| `NaN`  | 不定量，`0/0`     |
| `NA`   | 缺失值            |


```{R}
pi
1/0 
0/0 
NA
```

## 2.2 常用数据结构
![](./pics/p1.jpeg)

### 2.2.1 向量 (vector)
$$
\begin{bmatrix}
1 & 2 & 3 & 4
\end{bmatrix}
$$

#### 生成向量
- 通过 `c()` 来生成向量，只用按顺序输入向量的各个分量即可
  ```{r}
  v1 <- c(1,2,3,4) 
  v1
  ```
- 对于 $[1,2,3,4,5,...,n]$ 这样的等差数列，可以使用 `1:n` 来直接生成
  ```{r}
  v2 <- 1:4
  v2
  ```
- 对于有规则的等差数列，可以使用 `seq()` 来生成
  ```{r}
  seq(-2, 3, by=0.5) # 公差为 0.5，首项为-2，尾项最接近3的等差数列
  seq(2, 4, length.out=4) # 生成首项和尾项分别为2和4的4维向量
  seq(2, by=0.5, length=4)  # 生成首项为2，公差为0.5，长度为4的向量
  ```

- **注意**：向量中的数据类型需要保持一致，否则会出现强制转换!优先级为 `字符型 > 数值型 > 逻辑型` （优先级低的类型会被强制转换为优先级高的类型）
  ```{r}
  c(1,2,"3")    # 字符型最优先
  c(1,2,TRUE)   # 其次是数值型
  ```

#### 元素的索引和修改
- 使用 `a[i]` 来索引向量 `a` 中第 `i` 个元素
  ```{R}
  a <- c(1,2,3)
  a[2]
  ```
- `a[i]` 中的 `[i]` 也可以是个列表
  ```{R}
  b <- c(2,2,2,1,3)
  a[b]
  
  c <- a >= 2    # 返回一个由逻辑值组成的向量
  a[c]
  ```
- 通过对第 `i` 个元素进行赋值，来修改向量中第 `i` 个元素的值
  ```{R}
  a <- c(1,2,3)
  a[1] <- 100
  a
  a[2] = 300
  a
  ```

### 2.2.2 矩阵 (matrix)
- 为向量的推广，其元素具有**相同的数据类型**

#### 矩阵的创建
- 通过函数 `matrix(x,m,n)` 的形式来生成矩阵（将向量 `x` 转换为 `m` 行 `n` 列的矩阵）
  - **列优先**
    ```{R}
    a <- 1:6
    m1 <- matrix(a, 3, 2)
    m1
    ```
    ![默认为列优先](./pics/p2.png){width=50%}
  - **行优先**
    ```{R}
    a <- 1:6
    m2 <- matrix(a, 3, 2, byrow=T)
    m2
    ```
    ![通过`byrow=T`改为行优先](./pics/p3.png){width=50%}
- **注意** 和向量一样，当矩阵中元素的类型不同时，也会强制转换元素类型：优先级也是 `字符型 > 数值型 > 逻辑型` （优先级低的类型会被强制转换为优先级高的类型）
  - 尝试如下代码:
    ```{R, eval=FALSE}
    a1 <- c(1,2,3,4,"5",6)
    m3 <- matrix(a1, 3,2)
    m3
    
    
    a2 <- c(T,2,3,4,5,6)
    m4 <- matrix(a2, 3,2)
    m4
    ```
    
#### 矩阵的索引和元素的修改
- 和向量类似我们用 `a[i,j]` 的形式索引矩阵第 `i` 行 (row)，第 `j` 列 (column) 的元素;

  ![](./pics/p4.png){width=50%}


  ```{R}
  x <- 1:9
  m <- matrix(x, 3, 3)
  m
  m[3,2] # 矩阵m第3行第2列的元素
  ```
- 和向量类似，我们也可以用一组向量来索引矩阵
  ```{R}
  i <- c(1,3)
  j <- c(1,2)
  m[i,j] # 挑选出第1行和第1,2列，第3行和第1,2列相交的元素组成新的矩阵
  ```
- 索引某一列或某一行 `a[,n]` `a[m,]`
  ```{R}
  m[3,] # 索引第3行
  m[,2] # 索引第2列
  ```
  
- 我们同样可以用赋值的方式来修改矩阵中元素的值
  ```{R}
  x <- 1:9
  m <- matrix(x, 3, 3)
  m
  i <- c(1,3)
  j <- c(1,2)
  m[i,j] <- 1:4  # 挑选出第1行和第1,2列，第3行和第1,2列相交的元素组成新的矩阵
  m
  ```

### 2.2.3 数据框 (data frame)
- 属于矩阵的一种拓展形式，类似于我们常见的表格：每一行代表每一个 subject 的数据，每一列代表不同的数据（可能拥有不同的数据类型）

  ![](./pics/p5.png)

#### 数据框的创建
- `data.frame()`
  ```{R}
  x <- c(160, 175)
  y <- c(51, 72)
  sex <- c("female", "male")
  df <- data.frame(x,y,sex)                  # 使用列变量名 (x, y, sex)
  df2 <- data.frame(height=x, weight=y, sex) # 设置列变量名分别为(height, weight, sex)
  ```
  
  
#### 数据框的索引
- `names()` 用于显示数据框各列的名称
  ```{R}
  names(df)
  names(df2)
  ```
- **对列进行索引**：使用 `df$列变量` 对于数据框的列进行索引，也可使用 `df[j]` 直接检索第 `j` 列
  ```{R}
  df$sex
  df[3]
  df2$height
  df2[2]
  ```   
- **对行进行索引**：使用 `df[i,]` 索引第 `i` 行 (**注意 `i` 后面有个 `,`**)
  ```{R}
  df[1,]
  df2[2,]
  ```   
- **对于元素进行索引**：使用 `df$x[i]` 索引第 `i` 个 subject 的 `x` 属性，类似于矩阵，我们也可以用行和列的方式进行索引 `df[i,j]` 索引第`i`行第 `j` 列的元素。
  ```{R}
  df$x[1]
  df[1,1]
  ```
  
  
### 2.2.3 列表 (list)
- 列表可以视为向量在另一个方面的拓展，其内部可以存储不同类型的数据，且可根据键值 (key)进行索引

#### 列表的生成
- `list(key1=value1,key2=value2, ...)`
  ```{R}
  list1 <- list(1,"2",3)
  list1
  list2 <- list(x=1, y="2", z=3) # x,y,z 为我们索引使用的键值
  list2
  ```   

#### 列表的索引
- 若我们像向量一样进行索引 `a[i]` 我们得到的还是一个列表而非列表内的值
  ```{R}
  class(list1[1]) # 运行后我们可以发现 list1[1] 返回的还是一个列表
  ```
- 我们需要使用 `a[[i]]` 才能得到具体的数值
  ```{R}
  class(list1[[1]]) # list[[1]] 返回的才是具体的元素值
  ```
- 类似于数据框，当我们定义键值后，可以使用 `list2$key` 来进行索引，这时可直接得到列表内元素的值
  ```{R}
  list2$y     
  class(list2$y) # $key 的方式可以直接返回列表的元素值
  ```

## 2.3 数值的基础运算和常用函数
- 基础运算：`+` `-` `*` `/` `^` `sqrt()`
  ```{R}
  1 + 2 * 10    # 乘除以的优先级高于加减
  (1 + 2) * 10  # () 可以提高计算的优先级
  2 ^ 3     # 2的3次方
  2 ** 3    # 2的3次方, 同上
  sqrt(4)   # 对4开平方
  ```
- 常用函数
  1. **指数函数**：`exp(x)` $e^{x}$ ($e\approx 2.718281828459045$ 称为自然常数)
      ```{R}
      x <- seq(-5,2,by=0.001)
      y = exp(x)
      ```
      ```{R, echo=FALSE}
      # 下面为绘图，不需要了解
      df <- data.frame(x,y)
      library(ggplot2)
      ggplot(df, aes(x, y)) + geom_line()
      ```
  2. **对数函数**：
      - `log(x)` $\ln(x)$ 
      - `log(x, base=n)` $\log_{n} x$
      ```{R}
      x <- seq(exp(-5),exp(2), by=0.001)
      y = log(x)
      ```
      ```{R, echo=FALSE}
      # 下面为绘图，不需要了解
      library(latex2exp)
      df2 <- data.frame(x,y)
      x <- seq(-4.5,7,by=0.001)
      df3 <- data.frame(x=x,y=x)
      
      library(ggplot2)
      fig <- ggplot() +
        geom_line(data=df, aes(x,y, color="Line1")) +
        geom_line(data=df2, aes(x,y, color="Line2")) +
        scale_color_manual(values = c("Line1" = "blue", "Line2" = "red"),
                           labels = unname(TeX(c("$e^{x}$", "$\\ln(x)$")))) +
        coord_fixed(ratio=1)
      fig + geom_line(data=df3, aes(x,y), color="gray", linetype="dashed")
      ```
  3. **三角函数**：`sin(x)` `cos(x)` 其中`x` 采用弧度制
      ```{R}
      x <- seq(-3* pi,3*pi,by=1e-3)
      y_sin = sin(x)
      y_cos = cos(x)
      ```
      ```{R, echo=FALSE}
      df <- data.frame(x, y_sin, y_cos)
      fig <- ggplot(df, aes(x=x)) +
        geom_line(aes(y=y_sin, color="Line1")) +
        geom_line(aes(y=y_cos, color="Line2")) +
        scale_color_manual(values = c("Line1" = "blue", "Line2" = "red"),
                           labels = unname(TeX(c("$\\sin(x)$", "$\\cos(x)$")))) +
        coord_fixed(ratio=1) + ylab("y")
      fig
      ```
  4. `sum(x)` 求和函数：计算数值型向量 `x` 的所有元素的和；对于矩阵我们有 `colSums()` 对矩阵的列求和，`rowSums()` 对矩阵的行求和。
    ```{r}
    exp(1)
    log(exp(1))
    log(2^3, base=2) # 以2为底，8的对数
    sin(pi/6)
    
    x <- 1:9
    sum(x)
    m <- matrix(x,3,3)
    colSums(m)
    rowSums(m)
    ```
      
## Summary
1. 常见的变量类型：
    1. **逻辑型**：逻辑型的定义；逻辑型和数值型之间的转换；
    2. **数值型**：数值型的定义，科学计数法；
    3. **字符型**：字符型的定义；如何在字符串中引入 `'` 或 `"`；（不同的引号，转义字符 `\'` `\"`
    4. **不同类型之间的转换**：逻辑型 $\to$ 字符型，数值型 $\to$ 字符型，字符型（部分） $\to$ 数值型，逻辑型 $\leftrightarrow$ 数值型；
    5. **特殊常量**：`pi` `Inf` `NaN` `NA`
2. 重要数据结构：
    1. **向量**：生成，索引，修改；强制转换
    2. **矩阵**：生成，索引，修改；强制转换
    3. **数据框**：生成，索引；
    4. **列表**：生成，索引；
3. 基本运算和函数
    
  
  
