chapter_5.html

<!DOCTYPE html>
<html lang="" xml:lang="">
  <head>
    <title>Lecture 5</title>
    <meta charset="utf-8" />
    <meta name="author" content="Hu Chuan-Peng (PhD)" />
    <meta name="date" content="2024-03-27" />
    <script src="libs/header-attrs-2.20/header-attrs.js"></script>
    <link href="libs/remark-css-0.0.1/default.css" rel="stylesheet" />
    <link rel="stylesheet" href="css/zh-CN.css" type="text/css" />
    <link rel="stylesheet" href="css/Custumed_Style.css" type="text/css" />
  </head>
  <body>
    <textarea id="source">
class: center, middle, inverse, title-slide

.title[
# Lecture 5
]
.subtitle[
## Objects &amp; Function
]
.author[
### Hu Chuan-Peng (PhD)
]
.institute[
### Nanjing Normal University
]
.date[
### 2024-03-27
]

---

class: center, middle
&lt;span style="font-size: 60px;"&gt;第五讲&lt;/span&gt; &lt;br&gt;
&lt;span style="font-size: 60px;"&gt;R语言中的对象2: 函数&lt;/span&gt; &lt;br&gt;
&lt;br&gt;
&lt;span style="font-size: 30px;"&gt;胡传鹏&lt;/span&gt; &lt;br&gt;
&lt;span style="font-size: 30px;"&gt;2024-04-19&lt;/span&gt; &lt;br&gt;

---
&lt;br&gt;
&lt;br&gt;
# &lt;h1 lang="zh-CN"&gt;回顾&lt;/h1&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.1 数据导入&lt;/h2&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.2 赋值&lt;/h2&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.3 数据类型&lt;/h2&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.4 数据结构&lt;/h2&gt;
&lt;br&gt;
&lt;br&gt;
# &lt;h1 lang="zh-CN"&gt;本节课内容&lt;/h1&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.5 对数据的操纵&lt;/h2&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.6 数据类型的判断与转换&lt;/h2&gt;
# &lt;h2 lang="zh-CN"&gt;&amp;emsp;5.7 函数&lt;/h2&gt;

---
# &lt;h1 lang="zh-CN"&gt;5.1 数据导入&lt;/h1&gt;
# &lt;font size = 5.5&gt; 问卷数据：Human Penguin Project &lt;/font&gt; 
- # &lt;font size = 5.5&gt; 绝对路径:对文件或目录位置的完整描述，从根目录开始 &lt;/font&gt;

```r
paste(getwd(),"/data/penguin/penguin_rawdata.csv",sep = "")
```

```
## [1] "D:/Study/NNU/YAN2/2/R4Psy1/data/penguin/penguin_rawdata.csv"
```
- # &lt;font size = 5.5&gt; 相对路径:对文件或目录位置的部分描述，从当前工作目录开始。 &lt;/font&gt;
"data/penguin/penguin_rawdata.csv"
- # &lt;font size = 5.5&gt; 工作目录 &lt;/font&gt;

```r
getwd()#获取工作目录
```

```
## [1] "D:/Study/NNU/YAN2/2/R4Psy1"
```
--
- # &lt;font size = 5.5&gt;绝对路径=工作目录+相对路径&lt;/font&gt;
- # &lt;font size = 5.5&gt;推荐使用相对路径&lt;/font&gt;
---

```r
#下载、导入所需R包
if (!requireNamespace('pacman', quietly = TRUE)) {
    install.packages('pacman')
}
pacman::p_load(bruceR,tidyverse)
```


```r
#读取数据
penguin_data = bruceR::import(here::here('data', 'penguin', 'penguin_rawdata.csv'))#当前工作目录为R4Psy,依次打开'data''penguin'文件夹获取'penguin_rawdata.csv'数据
```
--
&lt;br&gt;&lt;img src="./picture/chp5/env.png" width="100%" style="display: block; margin-left: auto; margin-right: auto;"&gt;
---
# &lt;h1 lang="zh-CN"&gt;5.2 赋值与变量&lt;/h1&gt;

在R中，我们可以使用赋值操作符“&lt;-”或“=”给对象赋值。&lt;br&gt;
比如：

```r
object &lt;- 10
object
```

```
## [1] 10
```
我们给对象“object”赋值为10。&lt;br&gt;
赋值后可以对“object”进行操作，比如：&lt;br&gt;

```r
object + 2
```

```
## [1] 12
```
但注意此时的“object”本身并未发生改变。

```r
object
```

```
## [1] 10
```
---
# &lt;h1 lang="zh-CN"&gt;5.2 赋值与变量&lt;/h1&gt;
![error1](picture/chp5/error1.png)
&lt;font size=5&gt; 为什么会报错？&lt;br&gt;
&lt;br&gt;
--
&lt;font size=5&gt; R中变量名是区分大小写的&lt;br&gt;
--
&lt;br&gt;
![error2](picture/chp5/error2.png)
&lt;br&gt;
&lt;br&gt;
&lt;font size=5&gt;  变量名可以由字母、数字、_和.组成。并且变量名的第一个字符不能为数字或者特殊符号，比如 +, -, *, /, ^, !, @, &amp;。&lt;/font&gt; &lt;br&gt;  
&lt;br&gt;
---
# &lt;h1 lang="zh-CN"&gt;5.2 赋值与变量&lt;/h1&gt;
&lt;font size="5"&gt;
&lt;br&gt;
&lt;br&gt;
tips：&lt;br&gt;
&lt;br&gt;
&amp;emsp;&amp;emsp;变量名可以使用中文，但不推荐，可能出现这样的乱码：&lt;br&gt;
&amp;emsp;&amp;emsp;鍙︿竴涓▼搴忔鍦ㄤ娇鐢ㄦ鏂囦欢锛岃繘绋嬫棤娉曡闂��。&lt;br&gt;
&lt;br&gt;
&amp;emsp;&amp;emsp;命名对象最好有不错的可读性，比如“age”就要比“x”更易读。
&lt;/font&gt;

---
# &lt;h1 lang="zh-CN"&gt;5.3 基本数据类型&lt;/h1&gt;
&lt;font size=5&gt; 
- numeric（数值型），又分为 integer（整数型）和 double（浮点型）&lt;/h3&gt;
- logical（逻辑型），只有 TRUE 和 FALSE，或 T 和 F&lt;/h3&gt;
- character（字符型），引号括起来的若干字符&lt;/h3&gt;
- complex（复数类型），复数&lt;/h3&gt;
- raw（原始型），用于存储原始字节数据&lt;/h3&gt;


```r
object &lt;- 10
class(object)#查看数据类型
```

```
## [1] "numeric"
```

```r
a &lt;- 3.14
class(a)
```

```
## [1] "numeric"
```

---
# &lt;h1 lang="zh-CN"&gt;5.3 基本数据类型&lt;/h1&gt;

```r
b &lt;- T
class(b)
```

```
## [1] "logical"
```

```r
c &lt;- 'R4Psy'
class(c)
```

```
## [1] "character"
```

```r
d &lt;- 3+4i
class(d)
```

```
## [1] "complex"
```

```r
e &lt;- charToRaw('hello')
class(e)
```

```
## [1] "raw"
```

---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;
数据结构是为了便于存储相同或不同类型的数据而设计的数据容器。&lt;br&gt;
常用数据结构&lt;br&gt;
&amp;emsp;存放同类型数据：向量(Vector),矩阵(Matrix),多维数组(Array)&lt;br&gt;
&amp;emsp;存放不同类型数据：列表(List)、数据框(Data Frame)&lt;br&gt;
&amp;emsp;因子(Factor)&lt;br&gt;
![data structure](https://devopedia.org/images/article/46/9213.1526125966.png)
---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;


```r
#创建向量
v1 &lt;- c(1,2,3,4,5)#数值型向量
v1
```

```
## [1] 1 2 3 4 5
```

```r
v2 &lt;- c('apple','pear','banana','strawberry','lemon')#字符型向量
v2
```

```
## [1] "apple"      "pear"       "banana"     "strawberry" "lemon"
```

```r
v3 &lt;- c(T,F,F,T,T)#逻辑型向量
v3
```

```
## [1]  TRUE FALSE FALSE  TRUE  TRUE
```

```r
v4 &lt;- c(1:3)#数值型向量
v4
```

```
## [1] 1 2 3
```

---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;


```r
#创建数据框(每个成分都是一个向量)
d1 &lt;- data.frame(v1,v2,v3)
d1
```

```
##   v1         v2    v3
## 1  1      apple  TRUE
## 2  2       pear FALSE
## 3  3     banana FALSE
## 4  4 strawberry  TRUE
## 5  5      lemon  TRUE
```

--
![error3](picture/chp5/error3.png)
--
&lt;font size = 5&gt; 
数据框每一列的元素数目要相同 &lt;br&gt;
---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;


```r
#创建矩阵
m1 &lt;- matrix(c(1:9),nrow=3)
m1
```

```
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
```

```r
#创建三维数组
a1 &lt;- array(1:24,dim=c(3,4,2))
a1
```

```
## , , 1
## 
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4]
## [1,]   13   16   19   22
## [2,]   14   17   20   23
## [3,]   15   18   21   24
```
---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;

&lt;/br&gt;
## 创建空的dataframe，但有列名。


```r
df &lt;- data.frame(matrix(ncol = 3, nrow = 0))
x &lt;- c("name", "age", "gender")
colnames(df) &lt;- x
```

---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;

```r
#创建列表
l1 &lt;- list(1,c('a','b'),c(T,F))
l1
```

```
## [[1]]
## [1] 1
## 
## [[2]]
## [1] "a" "b"
## 
## [[3]]
## [1]  TRUE FALSE
```

```r
l2 &lt;- list(d1,m1)
l2
```

```
## [[1]]
##   v1         v2    v3
## 1  1      apple  TRUE
## 2  2       pear FALSE
## 3  3     banana FALSE
## 4  4 strawberry  TRUE
## 5  5      lemon  TRUE
## 
## [[2]]
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
```

---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;
数据可分为：定量数据（数值型）、定性数据（分类型）；定性数据又可分为名义型（无好坏顺序之分，如性别）、有序型（有好坏顺序之分，如疗效）。&lt;br&gt;
&lt;br&gt;
R 提供了因子这一数据结构（容器），专门用来存放名义型和有序型的分类变量。&lt;br&gt;
&lt;br&gt;
直接用字符向量也可以表示分类变量，但它只有字母顺序，不能规定想要的顺序，也不能表达有序分类变量。&lt;br&gt;
--


```r
x &lt;- c('good','better','best','bad','worse','worst')
sort(x)#排序
```

```
## [1] "bad"    "best"   "better" "good"   "worse"  "worst"
```
只会按照字母顺序排序
-


```r
x1 &lt;- factor(x,levels = c('best','better','good','bad','worse','worst'))
sort(x1)#排序
```

```
## [1] best   better good   bad    worse  worst 
## Levels: best better good bad worse worst
```

转化为因子之后可按照设置的方式排序
---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;
## 索引&lt;br&gt;
--
&lt;font size = 5&gt;
-   数字索引&lt;/font&gt;  


```r
# 选取前 2 行以及前 3 列数据
penguin_data[1:2,1:3]
```

```
##       Site  age sex
## 1 Tsinghua 1922   2
## 2   Oxford 1940   1
```

```r
# 也可以使用减号
penguin_data[1:2,-c(4:ncol(penguin_data))]
```

```
##       Site  age sex
## 1 Tsinghua 1922   2
## 2   Oxford 1940   1
```

&lt;font size = 5&gt;
-   名称索引&lt;/font&gt;  


```r
# 同样选取前 2 行以及前 4 列数据
penguin_data[1:2,c('age','ALEX1','ALEX2')]
```

```
##    age ALEX1 ALEX2
## 1 1922     2     2
## 2 1940     1     1
```

---
# &lt;h1 lang="zh-CN"&gt;5.4 数据结构&lt;/h1&gt;
## 小练习
&lt;font size = 5&gt;
尝试把以下表格中的内容创建为数据框，并把第一列改为因子
![dataframe](picture/chp5/dataframe.png)


```r
# gender &lt;- c(***)
# gender1 &lt;- ***
# score &lt;- c(***)
# letter &lt;- c(***)
# logic &lt;- c(***)
# data &lt;- ***(***)

#将“***”部分替换为适合的代码，并删去行首的“#”,即可运行
```


---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
&lt;br&gt;
&lt;br&gt;
&lt;font size = 5&gt;
数学运算 &lt;br&gt;
&amp;emsp;+ - * / ^(加、减、乘、除、求幂)等 &lt;br&gt;
&lt;br&gt;
比较运算 &lt;br&gt;
&amp;emsp;&gt;、&lt;、&gt;=、&lt;=、==、!= &lt;br&gt;
&amp;emsp;identical(x,y) —— 判断两个对象是否严格相等 &lt;br&gt;
&lt;br&gt;
逻辑运算 &lt;br&gt;
&amp;emsp;| &amp; ! (或、与、非)等 &lt;br&gt;
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 数学运算:+ - * / ^(加、减、乘、除、求幂)等


```r
3.14 + 2
```

```
## [1] 5.14
```

数值型可以进行数学运算
--


```r
TRUE * 3
```

```
## [1] 3
```

```r
F ^ 2
```

```
## [1] 0
```

逻辑型可以进行数学运算
--


```r
(3+1i)^2
```

```
## [1] 8+6i
```

复数型可以进行数学运算
--

![error5](picture/chp5/error5.png)
---

# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 数学运算:+ - * / ^(加、减、乘、除、求幂)等


```r
c(1:5) ^ 2
```

```
## [1]  1  4  9 16 25
```

```r
c(1:5) * c(6:10)
```

```
## [1]  6 14 24 36 50
```

```r
c(T,F) / c(T,T)
```

```
## [1] 1 0
```

```r
c(8+6i,7+4i) + c(3+2i,4+4i)
```

```
## [1] 11+8i 11+8i
```

![error6](picture/chp5/error6.png)
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!= 
![bijiao](./picture/chp5/bijiao.png)
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!= 


```r
3 &lt; 5
```

```
## [1] TRUE
```

```r
7.00 == 7
```

```
## [1] TRUE
```

```r
T == TRUE
```

```
## [1] TRUE
```

```r
T &gt; F
```

```
## [1] TRUE
```
数值型和逻辑型可以进行比较运算
---

# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!=


```r
(3+4i) != (3-4i)
```

```
## [1] TRUE
```

```r
(1+1i) == (1+3i) 
```

```
## [1] FALSE
```

![errorCom](./picture/chp5/errorCom.png)
复数型仅可以进行“==、!=”的比较运算
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!=


```r
'a' == 'A'
```

```
## [1] FALSE
```

```r
'a' &lt;= 'b'
```

```
## [1] TRUE
```

```r
'abc'&gt;'a'
```

```
## [1] TRUE
```

字符型可以进行比较运算
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!= 


```r
3 &lt; c(1:5)
```

```
## [1] FALSE FALSE FALSE  TRUE  TRUE
```

```r
c(1:3) &lt; c(4:6)
```

```
## [1] TRUE TRUE TRUE
```

```r
3 %in% c(1:5)
```

```
## [1] TRUE
```

```r
c(1:3) %in% c(3:5)
```

```
## [1] FALSE FALSE  TRUE
```

```r
c(T,F,T) != c(F,T,T)
```

```
## [1]  TRUE  TRUE FALSE
```

数值型和逻辑型向量可以进行比较运算。

---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!=


```r
'apple' %in% c('apple','pear','banana','strawberry','lemon')
```

```
## [1] TRUE
```

```r
c('apple', 'watermelon') %in% c('apple','pear','banana','strawberry','lemon')
```

```
## [1]  TRUE FALSE
```

字符型向量可以进行比较运算
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!=
字符是否匹配的问题还可以具体为是否完全匹配、是否部分匹配&lt;br&gt;


```r
#完全匹配
'c' %in% c('abc','cd','c')
```

```
## [1] TRUE
```

```r
#部分匹配
base::grepl('c',c('abc','cd','c'))
```

```
## [1] TRUE TRUE TRUE
```

```r
#部分匹配之开头匹配
base::startsWith(c('abc','cd','c'),'c')
```

```
## [1] FALSE  TRUE  TRUE
```

```r
#部分匹配之结尾匹配
base::endsWith(c('abc','cd','c'),'c')
```

```
## [1]  TRUE FALSE  TRUE
```

---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 比较运算:&gt;、&lt;、&gt;=、&lt;=、==、!=

&lt;font size=5&gt;
什么是通配符？&lt;br&gt;
--
&amp;emsp;&amp;emsp;通配符是一种特殊字符，它可以在匹配文件名或其他文本字符串时代替其他字符。&lt;br&gt;
&lt;br&gt;
--
R中常使用的通配符包括"*""?"和"[]"。&lt;br&gt;
--
&amp;emsp;&amp;emsp;*：代表任意数量的字符，例如*.csv将匹配所有以.csv结尾的文件。&lt;br&gt;
&amp;emsp;&amp;emsp;?：代表单个字符，例如file?.txt将匹配file1.txt，file2.txt等文件，但不会匹配file10.txt。&lt;br&gt;
&amp;emsp;&amp;emsp;[]：用于匹配指定的一组字符。例如，file[123].txt将匹配file1.txt，file2.txt和file3.txt。
&lt;/font&gt;

---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
![table](picture/chp5/table.png)
---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 逻辑运算：| &amp; ! (或、与、非)等


```r
!1
```

```
## [1] FALSE
```

```r
!0
```

```
## [1] TRUE
```

```r
1 &amp; 0
```

```
## [1] FALSE
```

```r
11 | 0
```

```
## [1] TRUE
```

```r
T &amp; F
```

```
## [1] FALSE
```

```r
!T
```

```
## [1] FALSE
```

---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 逻辑运算：| &amp; ! (或、与、非)等


```r
c(T,F,F) | T
```

```
## [1] TRUE TRUE TRUE
```

```r
c(T,F,F) | F
```

```
## [1]  TRUE FALSE FALSE
```

```r
c(T,F,F) &amp; c(T,T,F)
```

```
## [1]  TRUE FALSE FALSE
```

```r
c(1,2) &amp; c(0,1)
```

```
## [1] FALSE  TRUE
```

---
# &lt;h1 lang="zh-CN"&gt;5.5 对数据的操纵&lt;/h1&gt;
## 小练习
&lt;font size = 5&gt;
创建一个向量，包含数字1到20的三次方&lt;br&gt;
（首先创建一个包含数字1到20的向量，然后进行数学运算）&lt;br&gt;


```r
#a &lt;- ***
#a3 &lt;- ***

#将“***”部分替换为适合的代码，并删去行首的“#”,即可运行
```

---
# &lt;h1 lang="zh-CN"&gt;5.6 数据类型的判断与转换&lt;/h1&gt;
## 数据类型的判断:is族函数


```r
is.numeric(1.0)#判断是否为数值型
```

```
## [1] TRUE
```

```r
is.numeric('a')
```

```
## [1] FALSE
```

```r
is.character(c('a','b'))#判断是否为字符型
```

```
## [1] TRUE
```

```r
is.complex(1+1i)#判断是否为复数型
```

```
## [1] TRUE
```

```r
is.null(NULL)#判断是否为null值
```

```
## [1] TRUE
```

```r
is.na(c(1,NA))#判断是否为NA值
```

```
## [1] FALSE  TRUE
```

---
# &lt;h1 lang="zh-CN"&gt;5.6 数据类型的判断与转换&lt;/h1&gt;
## 数据类型的转化:as族函数
&lt;font size = 5&gt; 转化为数值：as.numeric


```r
as.numeric(c('1','2','3'))
```

```
## [1] 1 2 3
```

```r
as.numeric(c('1','2','a'))
```

```
## Warning: 强制改变过程中产生了NA
```

```
## [1]  1  2 NA
```

```r
as.numeric(c(T,F))
```

```
## [1] 1 0
```

---
# &lt;h1 lang="zh-CN"&gt;5.6 数据类型的判断与转换&lt;/h1&gt;
## 数据类型的转化
&lt;font size = 5&gt; 转化为字符串：as.character


```r
as.character(c(1,2,3))
```

```
## [1] "1" "2" "3"
```

```r
as.character(c(T,F))
```

```
## [1] "TRUE"  "FALSE"
```

```r
as.character(as.numeric(c('1','2','3')))
```

```
## [1] "1" "2" "3"
```

---
# &lt;h1 lang="zh-CN"&gt;5.6 数据类型的判断与转换&lt;/h1&gt;
## 数据类型的转化
&lt;font size = 5&gt; 转化为因子(factor)：factor&lt;br&gt;
R中用因子代表数据中分类变量, 如性别、省份、职业。


```r
class(penguin_data$sex)
```

```
## [1] "integer"
```

```r
unique(penguin_data$sex)
```

```
## [1]  2  1 NA  3
```

```r
sex1 &lt;- factor(penguin_data$sex,levels = c(1,2),labels = c('male','female'))
unique(sex1)
```

```
## [1] female male   &lt;NA&gt;  
## Levels: male female
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 什么是函数
&lt;font size=5&gt;
&amp;emsp;&amp;emsp;sqrt()、getwd()、here()等都是R中的函数。
&lt;br&gt;
&amp;emsp;&amp;emsp;在R中，函数是一种用于执行特定任务或计算的代码块。函数接受输入参数，执行特定的操作，并返回结果。
&lt;/font&gt;
&lt;br&gt;
--
## 函数求助
&lt;font size=5&gt;
&amp;emsp;&amp;emsp;如果我们不知道一个函数是什么，有什么用处。在R中，我们可以在Console中使用“?函数名”来打开帮助文档。
--
&lt;/font&gt;&lt;br&gt;
![help](./picture/chp5/help.png)
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数示例
![help](./picture/chp5/help2.png)
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数示例
![help](./picture/chp5/help3.png)
&lt;font size = 5&gt;
参数可以分为形式参数和实际参数。这里给出的是形式参数，实际运行中输入的值为实际参数。（举例：求函数y(x)在x=2时的值，x为形式参数，2为实际参数。）
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数示例
![help](./picture/chp5/help4.png)
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数调用
&lt;font size=5&gt;
-首先需要下载函数所在的R包（部分R包在下载R时已经自动下载）&lt;br&gt;
&amp;emsp;&amp;emsp;install.pcakages("R包名称")&lt;br&gt;
-然后需要加载R包&lt;br&gt;
&amp;emsp;&amp;emsp;library(R包名称)&lt;br&gt;
-已下载的R包，也可以直接 R包::函数名称 来调用函数&lt;br&gt;

-不同的R包中可能会有相同的函数名，为了避免调用错误，推荐使用：R包::函数名称&lt;br&gt;
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数调用
![error4](./picture/chp5/error4.png)
&lt;font size = 5&gt;
未加载时不能直接调用函数
--


```r
here::here()#::左边的here指名为here的R包，::右边的here指这个包中名为here的函数
```

```
## [1] "D:/Study/NNU/YAN2/2/R4Psy1"
```

```r
library(here)
```

```
## here() starts at D:/Study/NNU/YAN2/2/R4Psy1
```

```r
here()
```

```
## [1] "D:/Study/NNU/YAN2/2/R4Psy1"
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数调用


```r
df.pg.raw &lt;- utils::read.csv(file = './data/penguin/penguin_rawdata.csv',
                       header = T, 
                       sep=",",
                       stringsAsFactors = FALSE) 
```

&amp;emsp;&amp;emsp;df.pg.raw 变量名 &lt;br&gt;
&amp;emsp;&amp;emsp;utils 函数所在的R包 &lt;br&gt;
&amp;emsp;&amp;emsp;read.csv 函数名 &lt;br&gt;
&amp;emsp;&amp;emsp;file 参数：文件路径 &lt;br&gt;
&amp;emsp;&amp;emsp;header 参数：是否将第一行作为列名 &lt;br&gt;
&amp;emsp;&amp;emsp;sep 参数：指定分隔符 &lt;br&gt;
&amp;emsp;&amp;emsp;stringsAsFactors 参数：是否将字符型数据转化为因子 &lt;br&gt;
--
&lt;br&gt;
&lt;br&gt;
&lt;font size = 5&gt;
参数可分为形式参数（简称形参）和实际参数（简称实参）&lt;br&gt;
file = './data/penguin/penguin_rawdata.csv':&lt;br&gt;
&amp;emsp;&amp;emsp;file为形参&lt;br&gt;
&amp;emsp;&amp;emsp;'./data/penguin/penguin_rawdata.csv'为实参&lt;br&gt;


---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 函数分类
&lt;font size=5&gt;
已有函数&lt;br&gt;
&amp;emsp;&amp;emsp;R base; &lt;br&gt;
&amp;emsp;&amp;emsp;R packages; &lt;br&gt;
&amp;emsp;&amp;emsp;functions from other sources&lt;br&gt;
--
&lt;font size=5&gt;
自定义函数&lt;br&gt;
&amp;emsp;&amp;emsp;自己命名和创建函数

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数
&lt;font size = 5&gt;
函数定义通常由以下几个部分组成：&lt;br&gt;
&amp;emsp;-函数名: 为函数指定一个唯一的名称，以便在调用时使用。&lt;br&gt;
&amp;emsp;-参数: 定义函数接受的输入值。参数是可选的，可以有多个。&lt;br&gt;
&amp;emsp;-函数体: 包含实际执行的代码块，用大括号 {} 括起来。&lt;br&gt;
&amp;emsp;-返回值: 指定函数的输出结果，使用关键字return。&lt;br&gt;
--


```r
#定义一个函数：输入x和y，返回3倍x和5倍y的和
mysum &lt;- function(x,y){
  result = 3*x+5*y
  return(result)
}
#mysum:自定义的函数名
#x,y:形式参数
#result = 3*x+5*y:函数体
#return(result):返回值

#调用函数,x=1,y=2
mysum(1,2)
```

```
## [1] 13
```

```r
mysum(y=1,x=2)
```

```
## [1] 11
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数（小练习）
&lt;font size = 5&gt;
小练习：定义一个函数,输入值a,b,c,返回(a+b)/c;并计算abc分别为123时得到的值&lt;br&gt;


```r
#myabc &lt;- function(***){
#  result = ***
#  return(***)
#}

#用合理的代码替换以上“***”,删除每行前的“#”,即可运行
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数
&lt;font size = 5&gt;
&lt;br&gt;我们定义的函数mysum需要输入x和y两个值，如果只输入一个会怎么样。
--
![error7](./picture/chp5/error7.png)
--
&lt;font size = 5&gt;
&lt;br&gt;在使用bruceR::import时，我们并没有输入所有参数，它依然可以运行，是因为它有默认值。


```r
mysum2 &lt;- function(x = 6,y = 7){
  result = 3*x+5*y
  return(result)
}
mysum2()
```

```
## [1] 53
```

```r
mysum2(5)
```

```
## [1] 50
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数(小练习)
&lt;font size = 5&gt;
小练习：&lt;br&gt;
&amp;emsp;定义一个函数,输入值a,b,c,返回(a+b)/c;&lt;br&gt;
**&amp;emsp;设置a、b、c的默认值为3、2、1&lt;br&gt;**



```r
#myabc &lt;- function(a = ***, b = ***, c = ***){
#  result = ***
#  return(***)
#}
#myabc(***)

#用合理的代码替换以上“***”,删除每行前的“#”,即可运行
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数
&lt;font size = 5&gt;
在学习数据类型时，我们提到字符型不能进行加减乘除等数学运算&lt;br&gt;
--
![error8](./picture/chp5/error8.png)
--
&lt;font size = 5&gt;
自定义函数时可以手动添加报错信息。&lt;br&gt;
只有在输入的内容符合要求时才可以正常运行，否则报错。&lt;br&gt;
此处判断是否符合要求本质上是一种逻辑判断。&lt;br&gt;
--
![if-else](./picture/chp5/if-else.png)
---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数


```r
mysum3 &lt;- function(x = 6,y = 7){
  if(is.numeric(x) == T &amp; is.numeric(y) == T){
    result = 3*x+5*y
    return(result)}
  else{print("x and y must be number")}
}
#print：输出指定的内容
#is.numeric:判断是否为数值型。是则返回T，否则返回F
# &amp; : 表示“且”
mysum3(5,6)
```

```
## [1] 45
```

```r
mysum3('a','b')
```

```
## [1] "x and y must be number"
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数(小练习)
&lt;font size = 5&gt;
小练习：&lt;br&gt;
&amp;emsp;定义一个函数,输入值a,b,c,返回(a+b)/c;&lt;br&gt;
&amp;emsp;设置a、b、c的默认值为3、2、1;&lt;br&gt;
**&amp;emsp;当c为0时报错“c should not be 0”**


```r
#myabc &lt;- function(***){
#  if(***){
#    result = ***
#    return(***)
#  }
#  else{print(***)}
#}

#用合理的代码替换以上“***”,删除每行前的“#”,即可运行
```

---
# &lt;h1 lang="zh-CN"&gt;5.7 函数&lt;/h1&gt;
## 自定义函数(小练习)

```r
#示例
myabc &lt;- function(a = 3, b = 2, c = 1){
  if(c!=0){
    result = (a+b)/c
    return(result)
  }
  else{print('c should not be 0')}
}
```


    </textarea>
<style data-target="print-only">@media screen {.remark-slide-container{display:block;}.remark-slide-scaler{box-shadow:none;}}</style>
<script src="https://remarkjs.com/downloads/remark-latest.min.js"></script>
<script>var slideshow = remark.create({
"highlightStyle": "github",
"highlightLines": true,
"countIncrementalSlides": false
});
if (window.HTMLWidgets) slideshow.on('afterShowSlide', function (slide) {
  window.dispatchEvent(new Event('resize'));
});
(function(d) {
  var s = d.createElement("style"), r = d.querySelector(".remark-slide-scaler");
  if (!r) return;
  s.type = "text/css"; s.innerHTML = "@page {size: " + r.style.width + " " + r.style.height +"; }";
  d.head.appendChild(s);
})(document);

(function(d) {
  var el = d.getElementsByClassName("remark-slides-area");
  if (!el) return;
  var slide, slides = slideshow.getSlides(), els = el[0].children;
  for (var i = 1; i < slides.length; i++) {
    slide = slides[i];
    if (slide.properties.continued === "true" || slide.properties.count === "false") {
      els[i - 1].className += ' has-continuation';
    }
  }
  var s = d.createElement("style");
  s.type = "text/css"; s.innerHTML = "@media print { .has-continuation { display: none; } }";
  d.head.appendChild(s);
})(document);
// delete the temporary CSS (for displaying all slides initially) when the user
// starts to view slides
(function() {
  var deleted = false;
  slideshow.on('beforeShowSlide', function(slide) {
    if (deleted) return;
    var sheets = document.styleSheets, node;
    for (var i = 0; i < sheets.length; i++) {
      node = sheets[i].ownerNode;
      if (node.dataset["target"] !== "print-only") continue;
      node.parentNode.removeChild(node);
    }
    deleted = true;
  });
})();
// add `data-at-shortcutkeys` attribute to <body> to resolve conflicts with JAWS
// screen reader (see PR #262)
(function(d) {
  let res = {};
  d.querySelectorAll('.remark-help-content table tr').forEach(tr => {
    const t = tr.querySelector('td:nth-child(2)').innerText;
    tr.querySelectorAll('td:first-child .key').forEach(key => {
      const k = key.innerText;
      if (/^[a-z]$/.test(k)) res[k] = t;  // must be a single letter (key)
    });
  });
  d.body.setAttribute('data-at-shortcutkeys', JSON.stringify(res));
})(document);
(function() {
  "use strict"
  // Replace <script> tags in slides area to make them executable
  var scripts = document.querySelectorAll(
    '.remark-slides-area .remark-slide-container script'
  );
  if (!scripts.length) return;
  for (var i = 0; i < scripts.length; i++) {
    var s = document.createElement('script');
    var code = document.createTextNode(scripts[i].textContent);
    s.appendChild(code);
    var scriptAttrs = scripts[i].attributes;
    for (var j = 0; j < scriptAttrs.length; j++) {
      s.setAttribute(scriptAttrs[j].name, scriptAttrs[j].value);
    }
    scripts[i].parentElement.replaceChild(s, scripts[i]);
  }
})();
(function() {
  var links = document.getElementsByTagName('a');
  for (var i = 0; i < links.length; i++) {
    if (/^(https?:)?\/\//.test(links[i].getAttribute('href'))) {
      links[i].target = '_blank';
    }
  }
})();
// adds .remark-code-has-line-highlighted class to <pre> parent elements
// of code chunks containing highlighted lines with class .remark-code-line-highlighted
(function(d) {
  const hlines = d.querySelectorAll('.remark-code-line-highlighted');
  const preParents = [];
  const findPreParent = function(line, p = 0) {
    if (p > 1) return null; // traverse up no further than grandparent
    const el = line.parentElement;
    return el.tagName === "PRE" ? el : findPreParent(el, ++p);
  };

  for (let line of hlines) {
    let pre = findPreParent(line);
    if (pre && !preParents.includes(pre)) preParents.push(pre);
  }
  preParents.forEach(p => p.classList.add("remark-code-has-line-highlighted"));
})(document);</script>

<script>
slideshow._releaseMath = function(el) {
  var i, text, code, codes = el.getElementsByTagName('code');
  for (i = 0; i < codes.length;) {
    code = codes[i];
    if (code.parentNode.tagName !== 'PRE' && code.childElementCount === 0) {
      text = code.textContent;
      if (/^\\\((.|\s)+\\\)$/.test(text) || /^\\\[(.|\s)+\\\]$/.test(text) ||
          /^\$\$(.|\s)+\$\$$/.test(text) ||
          /^\\begin\{([^}]+)\}(.|\s)+\\end\{[^}]+\}$/.test(text)) {
        code.outerHTML = code.innerHTML;  // remove <code></code>
        continue;
      }
    }
    i++;
  }
};
slideshow._releaseMath(document);
</script>
<!-- dynamically load mathjax for compatibility with self-contained -->
<script>
(function () {
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.src  = 'https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-MML-AM_CHTML';
  if (location.protocol !== 'file:' && /^https?:/.test(script.src))
    script.src  = script.src.replace(/^https?:/, '');
  document.getElementsByTagName('head')[0].appendChild(script);
})();
</script>
  </body>
</html>