R语言课上笔记（第1-4天）
1. 第一天笔记
推荐的书籍：
《R数据科学》推荐–《R语言入门与实践》
《R语言与数据分析实战》–韩国人
《R语言数据可视化之美》–绘图
安装注意事项：
- 路径中不要包含中文
- 不要安装在C盘
- 路径当中不要有空格
-万物皆对象 万事皆函数
##1. 基础包：自带
##2. 拓展包：第三方包
ERROR–错误
WARNING–忽略
出现命令提示符说明代码完成
##查看当前环境中的包
(.packages())
##查看所有安装的包
(.packages(all=T))
安装包–一次安装多个包
install.packages()
加载包–一次只能加载一个
library()
##拼接函数
c()
#可以拼接数值型，也可以拼接字符型
##移除加载的包–加载
detach(“package:ggplot2”)
##卸载–安装
remove.packages(“ggplot2”)
##掷骰子
##特征：六面 点数
##对象命名规则：
- R区分大小写
- 不能以数字开头
- 不能有空格
- 不能有特殊符号 $ ￥ @ ^
##标准化的命名：
colSums col_sum
##非标准化命名：
2020年
##赋值符号：
##标准化的赋值符号
<- ->
非标准化的赋值符号
##连续赋值
x<-y<-z<-6
x=y=z=7
##查看当前环境中的对象
ls()
objects()
##提取对象中的值
- 直接执行对象名
- 用函数获取 get(“x”)
##删除对象
rm()–remove
##删除所有对象
rm(list=ls())
##元素方式运算：自循环
##如果两个向量长度不一致的时候
##较短的向量会进行自循环添加添加和较长的向量一样的长度
##矩阵乘法
szsz
##内积
sz%%sz
##外积
sz%o%sz
##转置
t(sz)
##求行列式
det(sz%o%sz)
##常用的统计函数
- 求和
sum() - 求均值
mean() - 方差
var() - 标准差
sd() - 中位数
median() - 长度
length()
##掷骰子
sample(sz,size=2)
##重复执行
replicate(10,sample(sz,size=2))
##可放回抽样、不可放回抽样（默认情况）
replace=T
sample(sz,size=2,replace=T)
##掷一对骰子并求和
sum(sample(sz,size=2,replace=T))
##参数：
- 位置传参：位置要一一匹配
- 名称传参：位置不需要一一匹配，但是需要指定参数名
##函数自定义
zsz<-function(){
- sk<-1:6
- skn<-sample(sk,2,T)
- return(sum(skn))
- }
##调用函数
zsz()
##查看函数内容
zsz
##(): 函数的触发器，定义参数
##{}：功能上是函数的主体，构成上是代码块，应用上是问题的逻辑
##函数返回值：如果没有return返回的是最后一行代码的值，自动调用一次return
##重复执行100次的操作
- 自定义函数
zsz3<-function(sk=1:6,n){
- replicate(100,sum(sample(sk,n,T)))
- }
- 调用函数
replicate(100,zsz())
##修改函数内容：
直接修改函数内容
fix(zsz)产生一个副本，对副本修改，不对母本产生影响
edit()
zsz4<-edit(zsz)
##等差数据
##生成从3到10，步长为0.4的序列
seq(3,10,0.4)
##生成从3到10，长度为10的序列
seq(3,10,length.out=10)
##生成从3到10，长度和sz相同的序列
seq(3,10,along.with=sz)
##生成一个1到5的序列–特例
seq(5)
##乘方
2^3
2**3
##画散点图
##1. 用ggplot2包中的qplot绘图
x<-seq(-3,3,0.2)
y<-x^3
library(ggplot2)
qplot(x,y)
##2. 直接用基础包中的plot绘图
plot(x=x,y=y)
##多次执行得到的点数和查看其分布–直方图
zn<-replicate(100,zsz())
qplot(zn,binwidth=1)
zn<-replicate(1000,zsz())
qplot(zn,binwidth=1)
zn<-replicate(10000,zsz())
qplot(zn,binwidth=1)
##当次数越大的时候，最后产生的直方图越接近正态分布
##入样概率
zsz
function(sk=1:6){
skn<-sample(sk,2,T,prob=c(1/8,1/8,1/8,1/8,1/8,3/8))
return(sum(skn))
}
##归一化处理
zsz
function(sk=1:6){
skn<-sample(sk,2,T,prob=c(1,1,1,1,1,3))##归一化处理
return(sum(skn))
}
##向量的循环
##1 2 3 1 2 3 1 2 3
rep(1:3,times=3)
##1 1 1 2 2 2 3 3 3
rep(1:3,each=3)
##1 2 2 2 3 3
rep(1:3,times=c(1,3,2))
prob=c(1,1,1,1,1,3)
可以修改为：
rep(c(1,3),times=c(5,1))
c(rep(1,times=5),3)
周末30班_名字_R第一天
- 第二天笔记
x1<-9:7
y1<-2:4
##快捷执行control+enter
##计算
c(x1,y1)
x1+y1
sum(x1,y1)
x1y1
rep(x1,y1)+y1##自循环
?rep
help(“rep”)
x1y1##矩阵乘法
x1%o%y1##矩阵外积
#1111122222333334444455555
rep(1:5,each=5)
rep(seq(5),each=5)
#-3.0到3.0，每个间隔0.02
seq(-3,3,by=0.02)
“a 1” “a 2” “a 3” “a 4” “a 5”
c(“a 1”,“a 2”,“a 3”,“a 4”,“a 5”)
paste(“a”,1:5,sep = " ")
paste(“a”,1:5)
#“a1” “a2” “a3” “a4” “a5”
c(“a1”,“a2”,“a3”,“a4”,“a5”)
paste(“a”,1:5,sep = “”)
paste0(“a”,1:5)##等同于paste函数sep参数放空的情况
?paste0
##collapse–压缩–
##压缩到一个元素中，形成长度为1的向量
paste(“a”,1:5,sep = " ",collapse = “+”)
a和c之间，有5个b
#“a”“b” “b” “b” “b” “b” “c”
c(“a”,rep(“b”,5),“c”)
rep(c(“a”,“b”,“c”),times=c(1,5,1))
rep(c(“a”,“b”,“c”),c(1,5,1))
rep(c(“a”,“b”,“c”),each=c(1,5,1))##each只能放一个数值
rep(c(“a”,“b”,“c”),times=c(1,5))##匹配向量长度
##所有的字符都要是英文字符
##区分大小写
##############################
##数据结构：存储和组织数据的方式
##原子型向量：
##1. 只能存储一种数据类型
##2. 一维的向量
sz<-1:6
is.vector(sz)
##原子型向量
##1. 双整型（double）
x2<-c(7.8,11.2)
##查看对象的类型
typeof(x2)
typeof(sz)
##2. 整型（integer）
int<-c(-1L,2L)
typeof(int)
##3. 字符型（character）
##双引号和单引号不要混用
txt<-c(“hello”,“world”)
typeof(txt)
##4. 逻辑型(logical)
TRUE FALSE
3>4
logic<-c(TRUE,F)
typeof(logic)
##5. 原始型
##字符型转化为原始型数据
charToRaw(“你好”)
charToRaw(“h”)
##一个汉字代表两个字节，字母代表一个字节
rawToChar(charToRaw(“你好”))
##6. 复数型 （complex）
comp<-c(1+2i,3+1i)
typeof(comp)
##is.*家族函数
is.double()
is.integer()
is.logical()
is.raw()
is.complex()
is.character()
##练习：生成一个原子型向量，存储一副同花顺的牌面
##（10,J,Q,K,A）
hand<-c(“10”,“J”,“Q”,“K”,“A”)
hand<-c(“ten”,“jack”,“queen”,“king”,“ace”)
##属性
sz
##查看对象的属性
attributes(sz)
##属性：名称、维度和类
##辅助函数：查看、修改
##1. names()
##修改名称：
kl<-c(a=1,b=2)
names(kl)<-c(“c”,“d”)
##对向量进行运算，不会改变名称属性中的内容
kl<-kl+1
kl
##创建名称：
##1.直接创建向量的过程中添加名称：kl<-c(a=1,b=2)
##2.先创建一个向量，再赋值名称属性
k<-c(2,6)
names(k)<-c(“c”,“d”)
names(k)<-“c”##不会自循环，只会赋值给第一个元素
k
##查看名称
k
names(k)
##2. dim():查看和修改
##一维称为向量
##二维称为矩阵
##三维称为数组
##三维以上称为多维数组
##查看维度
dim(sz)
##修改维度
dim(sz)<-c(2,3)
dim(sz)
##维度修改不会改变数值的类型
##改变的是数值的内部组织结构
typeof(sz)
##3. class()
class(sz)
##练习：生成一个长度为24的向量，添加维度属性为4行6列
a<-1:24
a
dim(a)<-c(4,6)
a
##数组：行，列，切片 (array)
##矩阵：行，列 (matrix)
dim(a)<-c(2,3,4)
a
class(a)
##矩阵函数
matrix()
##设置行数为3
a<-matrix(a,nrow=3)
##设置列数为3
matrix(a,ncol=3)
##按照行进行排列
matrix(a,ncol=3,byrow = T)
##数组函数
array()
c<-array(a,dim = c(2,3,4))
class©
##日期时间：
##1. 查看系统的日期和时间
##调用系统日期：
date1<-Sys.Date()
##调用系统时间和日期
time1<-Sys.time()
##2. 查看日期和时间的类
class(date1)
class(time1)
##“POSIXct” “POSIXt”
##时间从1970年1月1日 0小时0分开始计算的
##3. 去掉类
unclass(time1)
unclass(date1)
##练习：1970年1月1日 0小时0分开始之后的100万秒是哪一天
mi<-1000000
class(mi)<-c(“POSIXct”,“POSIXt”)
mi
##因子：存储分类信息的–特殊的类(factor)
##水平：类别
xb<-factor(c(“女”,“男”,“男”,“女”))
class(xb)
##查看因子数值
as.numeric(xb)
unclass(xb)
##查看属性
attributes(xb)
###############################
##强制性转化
##数值和字符型数据，转化为字符型
c(2,“你好”)
##数值型和逻辑型数据，转化为数值型
c(5,T,F)
##逻辑型和字符型数据，转化为字符型
c(T,“你好”)
##字符型>数值型>逻辑型(1,0)
##原因：一个原子型向量中只能存储一种数据类型
##强制性转化的作用：
k<-c(7,2,5,8,3)
k
##计算所有大于均值的个数
sum(k>mean(k))
##逻辑判断：双等号
34
33
##练习：一个原子型向量，计算男生的数量及男生占比
mn<- c(“女”,“男”,“男”)
sum(mn==“男”)
##男生的占比
##mean本身用来求均值
mean(mn==“男”)
?mean
##数据的强制性转化函数
##as.*家族
##数值转化为字符串
as.character(1)
##转化为整型
as.integer(“2”)
##转化为逻辑型
##对数值型转化为逻辑型，只有0返回的是F，其他返回的都是T
as.logical(1)
as.logical(2)
as.logical(-1)
as.logical(0)
as.logical(“你好”)##NA-缺失值
##转化为数值
as.numeric(“1”)
as.numeric(“你好”)
########
##列表：list–广义的向量（一维）
##组织不同的对象
##不限制数据类型，不限制长度
##创建出来的形式有两种
##第一种：不命名，用双括号表示[[1]]…
list(“张三”,160,list(“计算机”,T,1:3))
list(c(“张三”,“李四”),160,list(“计算机”,T,1:3))
##第二种：命名，用$符号来表示
l<-list(姓名=“张三”, 体重=160, list(“计算机”,T,1:3))
class(l)
##数据框–特殊的列表结构–每列长度相同
list(a=1:3,b=c(“a”,“b”,“c”))
data.frame(a=1:3,b=c(“a”,“b”,“c”))
##不自定义创建名字的话会自动生成
df<-data.frame(姓名=c(“张三”,“李四”),成绩=c(89,67))
data.frame(c(“张三”,“李四”),c(89,67))
class(df)
##长度不同会报错
data.frame(姓名=c(“张三”,“李四”),成绩=c(89,67,78))
data.frame(姓名=c(“张三”,“李四”,NA),成绩=c(89,67,78))
##查看数据对象的数据结构
str(df)
##数据框对因子有偏爱
##不转化为因子结构
df<-data.frame(姓名=c(“张三”,“李四”),
成绩=c(89,67),
stringsAsFactors=F)
str(df)
##stringsAsFactors拼错会自动生成新的一个变量
data.frame(姓名=c(“张三”,“李四”),
成绩=c(89,67),
stringAsFactors=F)
##数据类型
##数据类型相同：向量、矩阵、数组
##数据类型可以不相同：列表、数据框
##维度角度
##一维结构：向量、列表
##二维结构：矩阵、数据框
##三维结构：数组
##练习：构建一副扑克牌
##52张牌
##牌面：A 2:10 J Q K
##花色: 红桃 黑桃 方块 梅花
##点数：1-13
pkp<-data.frame(pm=rep(c(“A”,2:10,“J”,“Q”,“K”),times=4),
hs=rep(c(“红桃”,“黑桃”,“方块”,“梅花”),each=13),
ds=rep(1:13,times=4))
##参数传参
##1. 名称传参
##2. 位置传参：对应位置要匹配
##查看数据框的数据结构
str(pkp)
##查看摘要信息，作用在数据框和列表上的
summary(pkp)
##查看数据的前六行
head(pkp)
##查看数据的前十行
head(pkp,n=10)
##查看数据的后六行
tail(pkp)
##查看整个数据
View(pkp)
##不将字符型转换为因子
pkp<-data.frame(pm=rep(c(“A”,2:10,“J”,“Q”,“K”),times=4),
hs=rep(c(“红桃”,“黑桃”,“方块”,“梅花”),each=13),
ds=rep(1:13,times=4),
stringsAsFactors=F)
str(pkp)
summary(pkp)
##数据保存
##查看当前目录
getwd()
##设置工作路径–临时性的
setwd(“C:\Users\Administrator\Desktop”)
setwd(“C:/Users/Administrator/Desktop”)
##设置永久性的工作路径
##新建一个工程
##保存文件
##第一种：保存为R中的数据文件
save(pkp,file = “pkp.RData”)
##第二种：保存为EXCEL文件–CSV
write.csv(pkp,file = “pkp.csv”)
##去掉行名
write.csv(pkp,file = “pkp1.csv”,row.names=F)
##加载数据
##第一种：载入R文件
load(“pkp.RData”)
##第二种：载入EXCEL文件
pkp<-read.csv(“pkp.csv”)
##返回逻辑值向量中真值存在的位置
##which(),which.max() ,which.min()
which(c(T,F,F))
##返回男生所在的位置
mn<-c(“男”,“女”,“女”,“男”)
which(mn==“男”)
##返回最大值坐在位置
which.max()
which.max(c(3,5,9))
##返回最小值坐在位置
which.min(c(3,5,9))
#起始索引从1开始
##排序
##第一种：直接排序
x<-c(7,5,8,9,2)
sort(x)
##默认为升序排序，如果是降序排序加decreasing=T)
sort(x,decreasing = T)
##第二种：间接排序(原先序列的位置排序)
order(x)
##第三种：（头尾）颠倒排序
rev(x)
##统计函数
##求最大值
max()
##求最小值
min()
##求最大值和最小值的范围
rangge()
##后面的值减去前面的值
diff()
##极差
diff(range())
##累计和
cumsum()
##累计乘积
cumprod()
##累计最大/最小值
cummax()/cummin()
##作业1：创建一个函数，用数据框实现数值的计数功能
##计数功能包括：求一倍数、两倍数、1/2倍数，4倍数，1/4倍数
##调用函数（测试）：用1到100进行测试结果
##作业2：创建一个函数，用列表实现求值的功能
##求值功能包括：均值、方差、标准差、中位数、标准化
- 第三天笔记
##作业1：创建一个函数，用数据框实现数值的计数功能
##计数功能包括：求一倍数、两倍数、1/2倍数，4倍数，1/4倍数
##调用函数（测试）：用1到100进行测试结果
jisuan<-function(x){
data.frame(
var1=x,
var2=2x,
var3=1/2x,
var4=4*x,
var5=x/4
)
}
jisuan(1:100)
##作业2：创建一个函数，用列表实现一些求值功能
##求值功能包括：均值、方差、标准差、中位数、标准化
jisuan2<-function(x){
meanv<-mean(x)
varv<-var(x)
sdv<-sd(x)
medianv<-median(x)
zscore<-scale(x)##zscore<-(x-mean(x))/sd(x)
list(js.mean=meanv,js.var=varv,js.sdv=sdv,
js.median=medianv,js.zscore=zscore)
}
jisuan2(1:100)
##循环：一种是显式循环，一种是隐式循环
##显式：for、while、repeat
##隐式：apply、lapply、sapply
m<-matrix(1:12,nrow=3,byrow = T)
m
##apply: 对一个数据集进行行操作或列操作
##对m每一行进行求和操作
apply(m,1,sum)
##对m每一列进行求均值
apply(m,2,mean)
##lapply: 对列表(l)进行操作
d_l<-list(a=1:10,b=exp(-3:3),l=c(T,F,F,T))
d_l
##对d_l的每一个元素求均值
lapply(d_l,mean)
##sapply: 对列表进行操作，会将结果进行简化(s)
##对d_l的每一个元素求均值
sapply(d_l,mean)
##对向量的每一个数进行序列操作
da<-sapply(3:6,seq)
##返回列表结构的原因：列表已经是最简形式
##练习：对da的每一个元素求和
lapply(da,sum)
sapply(da,sum)
#######################################
##R中的记号体系
##data.frame[i,j]
##i–行，j–列
pkp
pkp<-data.frame(pm=rep(c(“A”,2:10,“J”,“Q”,“K”),times=4),
hs=rep(c(“红桃”,“黑桃”,“方块”,“梅花”),each=13),
ds=rep(1:13,times=4),
stringsAsFactors=F)
##1. 正整数索引
##取第四行第二列的值
pkp[4,2]
##取第四行到第六行，第三列的值
pkp[4:6,3]##返回的是向量
##保留原有的数据框的结构
pkp[4:6,3,drop=F]
##取第四行到第六行，重复取第三列的值
pkp[4:6,c(3,3)]##返回的是数据框
##取第四行和第六行，第三列的值
pkp[c(4,6),3]
##取第四行到第六行，第二列到第三列
pkp[4:6,2:3]
##正整数索引可以作用到二维结构：矩阵、数据框
m
##第三行第二列的值
m[3,2]
m[5]##按照列进行索引
##正整数索引也可以作用到一维结构上
sz<-1:6
sz[3:4]
names(sz)<-c(“a”,“b”,“c”,“d”,“e”,“f”)
##简单的方式
pi##圆周率
letters##小写的a-z的字母
LETTERS##大写的A-Z的字母
names(sz)<-letters[1:6]
sz
##索引从1开始，Python里是从0开始
##2. 负整数索引–排除数据
##不要第四行到第六行的数据，第二列到第三列的数据
pkp[-(4:6),2:3]
##可以在不同维度上同时使用正整数和负整数索引
##但是不能在同一维度上使用两个索引
sz[c(-1,2)]
##3. 零索引
pkp[0,0]##返回的是空的对象
##4. 空格索引
##取第二行到第三行，所有列的值
pkp[2:3,]
pkp[2:3, ]
pkp[2:3,1:3]
##取所有行的值，列为第一列和第三列
pkp[,c(1,3)]
##5. 逻辑值索引
x<-c(7,9,2,5,8)
##返回所有大于3的值
x>3
x[x>3]
##找牌面信息为k的牌
pkp[,1]“K”
pkp[pkp[,1]“K”,]
##练习：找出x中符合条件（x的平方大于四倍的x）的值
x[x^2>4*x]
##6. 名称索引
##查看pkp的名称属性
names(pkp)
##索引提取花色的信息
pkp[,“hs”]
##提取花色和点数信息
pkp[,c(“hs”,“ds”)]
##返回一列的时候是向量，两列会保持原来的数据结构
str(pkp[,“hs”])
str(pkp[,c(“hs”,“ds”)])
##找牌面信息为k的牌
pkp[pkp[,“pm”]==“K”,]
##练习：给定一个数据框，包含三个人的姓名和成绩，
##找出成绩最好和成绩最差的同学
ks<-data.frame(name=c(“xh”,“xg”,“xl”),
score=c(90,89,67),
stringsAsFactors=F)
ks
##成绩最好的
ks[which.max(ks[,“score”]),]
##成绩最差的
ks[which.min(ks[,“score”]),]
##隐式循环
as.numeric(unname(apply(ks,2,min))[2])
##7. 符号pkp符号 pkp符号pkppm
pkp$hs
##对于list有名称的时候可以用符号进行索引dldl符号进行索引 d_l d_l符号进行索引dldla
d_l$b
##8. [[]]符号
##对list没有名称用[[]]进行索引
d_l2<-list(1:10,exp(-3:3),c(T,F,F,T))
##提取第一个元素的值
d_l2[[1]]##返回的是一个向量
str(d_l2[[1]])
##提取第一个元素
d_l2[1]##返回的是一个list结构
str(d_l2[1])
##一个中括号具有形式不变性
##特殊例子
ks[1]
ks[[1]]
ks[[1:2]]##不符合正常规则
ks[[“name”]]
##创建命名向量
xx<-c(7,8,9)
xx
##第一种方式：
names(xx)<-c(“a”,“b”,“c”)
xx
##第二种方式：
xx<-c(a=7,b=8,c=9)
xx
##第三种方式：
names(xx)<-letters[1:3]
xx
xx[“a”]
##取出向量的第一个值
xx[[“a”]]
unname(xx[“a”])
##R的记号体系：
##()是函数的触发器
##{}是由若干条程序组成的代码块
##[],[[]],$执行的是索引的操作
##########################
##就地改值
pkp
##查看数据结构
str(pkp)
##创建一个副本
pkpu<-pkp
##生成一个长度为6元素都为0的向量
x<-numeric(6)
x
rep(0,6)
vector(“numeric”,6)
c(0,0,0,0,0,0)
##提取第三个元素
x[3]
##修改第三个数为5
x[3]<-5
x
##修改第四个和第五个值，改成1和2
x[4:5]<-1:2
x
##把所有值都改为100
##第一种方式：
x[]<-100
x
##第二种方式：
x<-x+100
x
##第三种方式：
x[1:length(x)]<-100
x
##超过长度的赋值，会自动将向量延长到和赋值的长度相同
##没有赋值的位置显示为缺失值
x[7]
x[8]<-90
x
##对pkp增加一列IND
names(pkp)
pkpKaTeX parse error: Expected 'EOF', got '#' at position 17: …ndex<-1:52 pkp #̲#删除新增的一列 pkpindex<-NULL
pkp
##将牌面信息为3的扑克牌的点数修改为100
pkp[pkp[,1]==3,3]<-100
pkp
pkp[pkp[,“pm”]3,“ds”]<-100
pkp[pkppm==3,3]<−100pkppm==3,3]<-100 pkppm==3,3]<−100pkpds[pkp$pm3]<-100
##逻辑运算符
7!=8
7!=1:8##自循环
##%in%判断
x<-c(“小明”,“小花”,“小亮”)
y<-c(“小刚”,“小明”)
##判断x中的人是否在y中出现
x%in%y
##在x中但是不在y当中的人,失去的
x[!x%in%y]
##在x和y中都有的人,旧的
x[x%in%y]
y[y%in%x]
##在y中有但是在x中没有的人，新增的
y[!y%in%x]
##is.element与%in%功能相同
is.element(x,y)
x%in%y
is.element(y,x)
##集合函数
##并集：union
union(x,y)
##交集：intersect
intersect(x,y)
x[x%in%y]
y[y%in%x]
##差集：在前面出现，在后者没有出现
setdiff(x,y)
x[!x%in%y]
setdiff(y,x)
y[!y%in%x]
##判断是否相等
setequal(x,y)
##练习：把花色为红桃和黑桃的扑克牌的点数改为100
pkpds[pkpds[pkpds[pkphs %in% c(“红桃”,“黑桃”)]<-100
##布尔运算符
##&–与
(1>2)&(4>3)
(2>1)&(4>3)
##|–或
(1>2)|(4>3)
(2>1)|(4>3)
##&&、||–只执行第一个判断
c(T,F)&c(T,T)
c(T,F)&&c(T,T)
c(T,F)&&c(F,T)
c(T,F)|c(T,T)
c(T,F)||c(T,T)
##xor–异或：只有两个条件中刚好只有一个为真才会返回真
xor(1>2,3>4)
xor(2>1,4>3)
xor(2>1,3>4)
##!–取反
!(2>1)
!FALSE
!TRUE
##any:只要有一个为真，就返回真
any(c(T,F,T,F,F,F))
any(c(F,F,F,F,F,F))
##all:所有条件都为真，就返回为真
all(c(T,F,T,F,F))
all(c(T,T,T))
##修改黑桃3的扑克牌的点数，改为500
pkp[pkpKaTeX parse error: Expected 'EOF', got '&' at position 6: pm==3&̲pkphs==“黑桃”,3]<-500
pkpds[pkpds[pkpds[pkppm3&pkp$hs"黑桃"]<-500
##练习：把黑桃和方块中的J和Q的扑克牌的点数改为10
pkpds[(pkpds[(pkpds[(pkphs==“黑桃”|pkpKaTeX parse error: Expected 'EOF', got '&' at position 10: hs=="方块")&̲(pkppm==“J”|pkppm=="Q")]<−10pkppkppm=="Q")]<-10 pkp pkppm=="Q")]<−10pkppkpds[(pkphshs %in% c("黑桃","方块"))&(pkphspm %in% c(“J”,“Q”))]<-101
pkp
##分布操作：
p1<-pkphsp2<−pkphs %in% c("黑桃","方块") p2<-pkphsp2<−pkppm %in% c(“J”,“Q”)
pkp$ds[p1&p2]<-10
pkp[p1&p2,3]<-10
pkp[p1&p2,“ds”]<-10
##缺失值：NA
x<-c(3,5,NA)
##是否存在缺失值
is.na(x)
##找到非缺失值的数据
x[is.na(x)]
x[!is.na(x)]
##或
x[-which(is.na(x))]
xNA
NANA
##计算缺失值的个数
sum(is.na(x))
##缺失值的影响
##求和
sum(x)
##处理方法：
##第一种：直接移除（忽略）
sum(x,na.rm=T)
##第二种：填补
##填补的方法很多，最常用的是用均值进行填补
##缺失值的均值填补
x[is.na(x)]<-mean(x,na.rm=T)
x
x[which(is.na(x))]<-mean(x,na.rm = T)
##查看数据的摘要统计量
summary(x)
#####################################
##R的环境系统
##存储对象通过层级结构来存储的
install.packages(“pryr”)
library(pryr)
##查看R当前的环境–全局环境
parenvs()
##查看R当前的环境树
parenvs(all=T)
##再加载一个包
##这个包会在R里创建出一个新的环境
##并且这个新的环境会作为全局环境的父环境
library(ggplot2)
parenvs(all=T)
##环境–存储对象的“空间”
##指向某个环境
as.environment(“package:ggplot2”)
##当前的环境
environment()
##指向全局环境
globalenv()
.GlobalEnv
##基环境
baseenv()
##空环境
emptyenv()
##空环境的特点：
##1. 它没有父环境，其他的环境都有父环境
##2. 它没有任何的存储对象
##查看某一个环境的父环境
##查看全局环境的父环境
parent.env(globalenv())
##查看某一个包的父环境
parent.env(as.environment(“package:pryr”))
parent.env(as.environment(“package:ggplot2”))
##查看当前环境中的对象
ls()
##万物皆对象
##查看某个环境中的对象
##查看base环境中的对象
ls(baseenv())
##查看空环境中的对象
ls(emptyenv())
##查看ggplot2包所在环境的对象
ls(as.environment(“package:ggplot2”))
ls(“package:ggplot2”)
##跨环境赋值
assign(“nihao”,3,envir=globalenv())
ls()
nihao
##活动环境–一般情况就是我们的全局环境
##活动环境的规则
##1. 任何情况下，R中的活动环境都只有一个
##2. 所有的新对象都会存储到改活动环境中
environment()
##查看一个对象保持的位置
find(“c”)
##作用域规则–R在搜索对象时的规则
##规则1：R首先会在当前的活动环境中搜索对象
##规则2：在命令行工作时，活动环境就是全局环境
##规则3：在某个环境中没有搜索到对象，
##R会进入当前环境中的父环境中进行搜寻
c(3,4)
##破坏性操作：自定义函数c
c<-function(x,y){
x+y
}
c(3,4)
##查找c函数的位置
find(“c”)
##调用base包环境下的c函数
base::c(3,4)
baseenv()$c(3,4)
##删除c函数
rm©
c(3,4)
##运行时环境
##函数在求值运算的时候回创建一个运行时环境
c1<-function(x,y){
x<-10
x+y
}
x<-5
x
##原环境：创建函数的环境就是他的原环境（父环境）
##c函数的原环境就是base环境
##c1函数的原环境就是全局环境
##原环境就是c1函数的运行时环境的父环境
##作业：PPT2–作业
**
- 第四天笔记
**
pkp<-data.frame(pm=rep(c(“A”,2:10,“J”,“Q”,“K”),times=4),
hs=rep(c(“红桃”,“黑桃”,“方块”,“梅花”),each=13),
ds=rep(1:13,times=4),
stringsAsFactors=F)
pkp
##取出扑克牌中的四个A（形式：4行3列）
pkp[pkp$pm==“A”,]##符号索引
pkp[pkp[,“pm”]“A”,]##名称索引
pkp[pkp[,1]“A”,]##正整数索引
pkp[pkp[1]==“A”,]##符号索引
##多少张牌的牌面为A
sum(pkp$pm==“A”)
##提取扑克牌中所有红桃牌的点数
pkp[pkphs=="红桃","ds"]pkp[pkphs=="红桃","ds"] pkp[pkphs=="红桃","ds"]pkp[pkphs==“红桃”,3,drop=F]##保留原本数据框的格式
##提取扑克牌中的黑桃Q
pkp[pkpKaTeX parse error: Expected 'EOF', got '&' at position 10: hs=="黑桃" &̲ pkppm==“Q”,]
##R的环境系统
##调用环境–调用函数的环境
show_env<-function(){
list(
hj=environment(),
fhj=parent.env(environment()),
dx=ls()
)
}
show_env()
##查看一个函数的原环境
##enironment函数里面加参数–函数，返回该函数的原环境–父环境
environment(show_env)
##environment函数里面不加参数，返回当前的活动环境
environment()
##查看qplot的原环境
library(ggplot2)
environment(qplot)
##当前环境（全局环境）是qplot的调用环境
##单链接：父环境不能搜索子环境中的对象
##但是子环境是可以搜索父环境中的对象
show_env<-function(){
a<-3
b<-4
list(
hj=environment(),
fhj=parent.env(environment()),
dx=ls()
)
}
show_env()
a
b
##参数：当函数里面存在参数时，这个参数会作为
##函数运行时环境中的一个对象
show_env<-function(ui){
a<-3
b<-4
list(
hj=environment(),
fhj=parent.env(environment()),
dx=ls.str()##返回对象所有值
)
}
show_env(ui=4)
##函数传参：
##1. 名称传参：实际值=实参，参数名=形参
##2. 位置传参
##环境系统总结：
##1. 任何时候，R的活动环境都只有一个
##2. R会将所有产生的新对象都会存储到该环境中
并且在搜索对象的时候，以此环境作为初始搜索点
##3. R的活动环境通常是全局环境，但是R在做函数的求值运算时
会临时将活动环境调整为运行时环境，这种方式能够保证安全性的
##################创建发牌和洗牌函数####################
##构建发牌函数
##自定义函数
fapai<-function(){
pkp[1,]
}
fapai()
##修改–增加删除第一张的功能
fapai<-function(){
ca<-pkp[1,]
pkp<-pkp[-1,]
ca
}
fapai()
##返回的是第一张原因：每次运行时会生成一个运行时环境
##在环境下生成的pkp对象只会保留到这个环境中
##但是每次抽取扑克牌的时候用的对象是全局环境中的pkp
##第二次修改：对全局环境中的pkp值进行修改
PKP<-pkp
fapai<-function(){
ca<-pkp[1,]
assign(“pkp”,pkp[-1,],envir=globalenv())
ca
}
fapai()
##洗牌函数
##洗牌–打乱–随机取样
x<-c(3,2,9,7,1,-8)
sample(1:6,6)
x[sample(1:6,6)]
pkp<-PKP
xipai<-function(){
sjs<-sample(1:52,52)
pkp[sjs,]
}
xipai()
fapai()
##修改–发牌发的pkp没有发生变化
xipai<-function(){
sjs<-sample(1:52,52)
assign(“pkp”,PKP[sjs,],envir=globalenv())
##洗牌想要的是一幅完整的pkp，所以PKP是完整52张
}
##调用
xipai()
fapai()
fapai()
fapai()
##问题：
##全局环境是一个活跃的环境，创建的对象都在全局环境中
##对象很容易被篡改，所以不稳定
rm(pkp,PKP)
pkp
PKP
xipai()
fapai()
##闭包结构：在函数里面实现所有功能–函数、对象
##构建自定义函数，实现发牌和洗牌函数
setup<-function(pk){
##创建一个副本
PK<-pk
##构建发牌函数
fp<-function(){
ca<-pk[1,]
assign(“pk”,pk[-1,],envir=parent.env(environment()))
##environment()返回的是当前的活动环境，最后指向的环境是
##当前环境的父环境，也是setup函数运行时的环境
ca
}
##构建洗牌函数
xp<-function(){
sjs<-sample(1:52,52)
assign(“pk”,PK[sjs,],envir=parent.env(environment()))
}
##返回两个函数
list(FP=fp,XP=xp)
}
##重建创建一幅pkp，构建发牌和洗牌函数
pai<-setup(pk=pkp)
##发牌函数
发牌<-paiKaTeX parse error: Expected 'EOF', got '#' at position 4: FP #̲#洗牌函数 洗牌<-paiXP
##调用发牌和洗牌函数
洗牌()
发牌()
发牌()
##删除pkp对象
rm(pkp)
pkp
洗牌()
发牌()
发牌()
##达到稳定性
###############################################
##项目三–老虎机
##杠的任意组合
##BBB BB B
##BB BB B
##BBB BB BB
##B B BBB
##BB BB BB##不会出现
##两个C和一个任意符号
##C C B
##C C 7
##一个C和两个任意符号
##C B BB
##C 7 B
##没有钱
##7 B BB
##钻石DD能实现百搭功能
##钻石DD出现能翻倍
##7 7 DD7 7 7=80*2=160
##B BB DDB BB BB/B BB B=52=10
##C DD DD==C C C=1022=40
##DD DD DD=1002^3=800
##规则：
##1. 特殊符号组合对应特定的金额
##2. 钻石DD可以进行百搭
##3. 出现DD金额进行翻倍，出现几次，翻倍几次
##生成符号组合–自定义函数
get_symbols<-function(){
wheel<-c(“DD”,“7”,“BBB”,“BB”,“B”,“C”,“0”)
sample(wheel,3,replace=T,
prob=c(0.03,0.03,0.06,0.1,0.25,0.01,0.52))
}
get_symbols()
##显示符号组合
print(get_symbols())
##计算中奖金额
score<-function(){
}
##具体玩老虎机实现函数
play<-function(){
symbols<-get_symbols()
print(symbols)
score(symbols)
}
##分支结构
##if/ifelse/switch
##if语句：判断单个条件，不能够处理向量
##构建一个函数：如果输入的数值小于0，取它的绝对值
如果输入的数值大于等于0，不做任何改变
qz<-function(x){
if(x<0){
abs(x)##取绝对值
}else{
x
}
}
qz(9)
qz(-9)
##分支比较多
##if-- else if(多个)–else
##构建一个函数：如果一个数值大于0，返回1；
##如果小于0，返回-1,；如果等于0，返回0
jc<-function(x){
if(x>0){
return(1)
}else if(x<0){
return(-1)
}else{
return(0)
}
}
jc(9)
jc(-9)
jc(0)
##简化
jc1<-function(x){
if(x>0) 1
else if(x<0) -1
else 0
}
jc1(9)
jc1(-9)
jc1(0)
##再简化
jc2<-function(x){
if(x>0) 1 else if(x<0) -1 else 0
}
jc2(9)
jc2(-9)
jc2(0)
##简化：–加{}
##如果if条件后执行的代码超过一行（代码块），需要加{}
##如果if条件后执行的代码只有一行，可以省略掉{}
##而且将各个分支放到一行中进行显示
##jc函数实现的是判断一个数的符号，R有自带的符号函数
sign(9)
sign(-9)
sign(0)
##练习：构建一个函数，输入一个成绩值，判断成绩值所对应的级别
##如果分数大于90，返回A；如果分数是在80-90之间，返回B；
##如果分数在70-80之间，返回C；如果分数在60-70之间，返回D；
##如果分数在60以下，返回F
cj<-function(x){
if(x>90) “A”##return(“A”)
else if(x>80) “B”
else if(x>70) “C”
else if(x>60) “D”
else “F”
}
cj(89)
cj(76)
cj(57)
##除了return返回函数值，还有两种其他输出方式
##第一种：
print()
##第二种：
cat()
##打印函数–区别
##第一：print打印出来的字符串会带有引号，但是cat不会带有
print(“优秀”)
cat(“优秀”)
##第二：print不能够识别转义符号，但是cat能够识别转义符号
print(“优秀\n张三”)
cat(“优秀\n张三”)
##修改之前的成绩函数，用cat进行打印
cj1<-function(x){
if(x>90) cat(“A”)
else if(x>80) cat(“B”)
else if(x>70) cat(“C”)
else if(x>60) cat(“D”)
else cat(“F”)
}
cj1(98)
cj1(76)
cj1(57)
##cat另外一种显示方式–加入文字描述
cj2<-function(x){
gr<-if(x>90) “A”
else if(x>80) “B”
else if(x>70) “C”
else if(x>60) “D”
else “F”
cat(“成绩等级为：”,gr)
}
cj2(89)
cj2(56)
##改变条件的位置顺序后需要重新判断逻辑结构
cj3<-function(x){
if(x>80&x<=90) “B”
else if(x>90) “A”
else if(x>60&x<=70) “D”
else if(x<=60) “F”
else “C”
}
cj3(90)
##if总结：
##1. 如果if语句后面只有一行代码，可以不加{}
##2. 判断的条件是相关的，而不是相互独立的
##3. 不能够随意的改变条件之间相互之间的位置
##4. if语句只能判断长度为1的逻辑向量；如果长度大于1，
##只会判断第一个元素
cj(89)
cj(c(89,56))
##练习：创建一个函数，传入三个参数，分别a,b,method
##如果method是加法，就对a和b执行加法运算
##如果method是减法，就对a和b执行减法运算
##其他所有情况，就对a和b执行乘法运算
##最终返回结果值
test<-function(a,b,method){
if(method==“add”) cat(“加法的运算结果：”,a+b)
else if(method==“minus”) cat(“减法的运算结果：”,a-b)
else cat(“其他情况运算结果：”,a*b)
}
test(3,4,“add”)
test(3,4,“minus”)
test(3,4,"")
##ifelse–对向量的逻辑值进行判断
##第一个参数：判断的逻辑值或条件判断向量
##第二个参数：逻辑判断为真得到的结果
##第三个参数：逻辑判断假得到的结果
ifelse(c(F,T,T),c(5,7,0),c(1,4,8))
##取绝对值
abs()
k<-c(9,-4,5,-7,-8)
abs(k)
##用ifelse来改写实现取绝对值
ifelse(k<0,-k,k)
##改写jc函数–ifelse
jc<-function(x){
if(x>0){
return(1)
}else if(x<0){
return(-1)
}else{
return(0)
}
}
jc4<-function(x){
ifelse(x>0,1,ifelse(x<0,-1,0))
}
jc4(9)
jc4(-9)
jc4(0)
jc4(c(9,-9,0))
##练习：构建一个函数，如果输入的值大于5，返回5；
##如果在-5和5之间，保持本身不变
##如果小于5，就返回-5–ifelse
jc5<-function(x){
ifelse(x>5,5,ifelse(x>=-5,x,-5))
}
jc5(c(6,-1,-8))
##pmax、pmin
##pmax:取向量中对应位置相对比较大的值
pmax(c(3,8,9),c(1,9,7))
##pmin:取向量中对应位置相对比较小的值
pmin(c(3,8,9),c(1,9,7))
##pmax和pmin改写jc5函数
##举实例：3
jc6<-function(x){
pmax(pmin(x,5),-5)
}
jc6(c(6,-1,-8))
##switch：处理的是数值和字符串
##返回第二个参数开始的第几个分支
##处理数值
switch(1,“x”,“y”)
switch(2,“x”,“y”)
switch(3,“x”,“y”)
##处理字符串
switch(“a”,a=1,b=2)
switch(“c”,a=1,b=2)
##不加参数名用来适应其他任何情况
switch(“c”,a=1,b=2,3)
##相对复杂的结构
##构建一个函数，函数里面实现switch分支选择
switchf<-function(x){
switch(x,
a=1:3,
b=list(x=0,y=1),
c={
cat(“你吃饭了吗？\n”)
list(name=“张三”,age=26)
}
)
}
switchf(“a”)
switchf(“b”)
switchf(“c”)
##switch不能处理长度大于1的向量的
switch(c(1,2),“x”,“y”)
##练习：用switch改写test函数
test<-function(a,b,method){
if(method==“add”) cat(“加法的运算结果：”,a+b)
else if(method==“minus”) cat(“减法的运算结果：”,a-b)
else cat(“其他情况运算结果：”,ab)
}
test1<-function(a,b,method){
switch(method,
“add”=a+b,
“minus”=a-b,
ab)
}
test1(3,4,“add”)
test1(3,4,“minus”)
test1(3,4,"")
##if/ifelse/switch
##总结：
##如果你处理的是单个逻辑值，用if
##如果你处理的是一个逻辑向量（长度不为1），用ifelse
##如果你处理的是数值或字符串，用switch(处理长度为1的向量)
##两类循环：显示循环、隐式循环（apply加族）
##显示循环：for/while/repeat
##for循环
##语法结构
for(var in vector){
expr
}
var<-vector[1]
expr
var<-vector[2]
expr
…
var<-vector[n]
expr
##遍历数值
for(i in 1:3){
cat(“当前打印的值为：”,i,"\n")
}
##遍历字符串向量
for(i in c(“你”,“hao”)){
cat(“当前打印的值为：”,i,"\n")
}
##遍历列表
##遍历列表中的每一个元素
nk<-list(a=c(1,2,1),b=letters[1:3])
for(i in nk){
cat(“item:\n length:”,length(i),
“\nclass:”,class(i),"\n")
}
##用for循环求1到100的和
s<-0
for(i in 1:100){
s<-s+i
}
s
##求1到100中偶数的和
##第一种：
s<-0
for(i in seq(2,100,by=2)){
s<-s+i
}
s
##第二种：
s<-0
for(i in 1:100){
if(i%%2==0) s<-s+i
}
s
##控制for循环的控制流：break next
##break：终止–跳出for循环
##从1到5进行遍历，遇到3终止循环
for(i in 1:5){
if(i==3) break
cat(“当前打印的值为：”,i,"\n")
}
##练习：得到1000到1100中间满足数的平方除以11的余数
##和数的三次方除以17的余数相同的值
for(i in 1000:1100){
if(i2%%11==i3%%17) cat(“当前符合条件的值为：”,i,"\n")
}
##返回第一个符合条件的值
for(i in 1000:1100){
if(i2%%11==i3%%17){
cat(“当前符合条件的值为：”,i,"\n")
break
}
}
##在遍历第一个值的时候循环就停止了
for(i in 1000:1100){
if(i2%%11==i3%%17){
cat(“当前符合条件的值为：”,i,"\n")
}
break
}
##返回最后一个符合条件的值
for(i in 1100:1000){
if(i2%%11==i3%%17){
cat(“当前符合条件的值为：”,i,"\n")
break
}
}
##任意位置上的值
m<-numeric()
for(i in 1000:1100){
if(i2%%11==i3%%17) m<-c(m,i)
}
m
m[2]
##next：跳过本次循环，直接进入下一次循环
##从1到5进行遍历，打印除3以外的其他值
for(i in 1:5){
if(i==3) next
cat(i," ")
}
##得到1000到1100中间满足数的平方除以11的余数
##和数的三次方除以17的余数相同的值,除第三个结果以外的其他值
j<-0
for(i in 1000:1100){
if(i2%%11==i3%%17){
j<-j+1
if(j==3) next
cat(“当前符合条件的值为：”,i,"\n")
}
}
##while循环
##当我们知道循环次数的时候，用for循环
##如果不知道循环次数，用while循环
##while循环语法结构
while(condition){
expr
}
##结果有六行
x<-0
while(x<=5){
cat(x,"\n")
x<-x+1
}
x<-0
while(x<=5){
cat(x," “,sep=”")
x<-x+1
}
##repeat循环–死循环–需要加break
##repeat语法结构
repeat{
expr
}
##死循环–可以通过stop停止
x<-0
repeat{
x<-x+1
}
##练习：x从0开始遍历，每次增加1
##如果x是2，执行下一次循环
##如果x是8, 就停止循环
##其他所有情况，返回x的平方值–repeat
x<-0
repeat{
x<-x+1
if(x2) next
else if(x8) break
else cat(x^2,"\n")
}
##作业：PPT4–作业1、作业2
R语言课上笔记（第1-4天）相关推荐
- R语言可视化学习笔记之相关矩阵可视化包ggcorrplot
本文转载自"R语言中文社区",己获授权. 作者简介Introduction taoyan:伪码农,R语言爱好者,爱开源. 个人博客: https://ytlogos.github. ...
- R语言可视化学习笔记之ggridges包绘制山峦图
作者:严涛 浙江大学作物遗传育种在读研究生(生物信息学方向)伪码农,R语言爱好者,爱开源. 严涛老师的绘图教程还有: gganimate |诺奖文章里面的动图绘制教程来了!! ggplot2学习笔记之 ...
- R语言主成分分析法笔记
01.什么是主成分分析法 简要概括主成分分析法的作用:把能反映某种特征的很多指标汇总成一个指标. 举例而言,一家银行的流动性可以体现在它的现金资产占比和定期存款占比上-- 银行A的现金资产占比是0.1 ...
- R语言小白学习笔记3—R语言读取数据
R语言小白学习笔记3-R语言读取数据 笔记链接 想说的话 学习笔记3-R语言读取数据 3.1 读取CSV文件 3.1.1 read_delim函数 3.1.2 fread函数 3.2 读取Excel数 ...
- UA MATH571A QE练习 R语言 非参数回归 上
UA MATH571A QE练习 R语言 非参数回归上 2014年5月第五题 2015年1月第四题 2015年5月第四题 这一篇介绍2014年5月第五题.2015年1月第四题.2015年5月第四题. ...
- R语言小白学习笔记12—概率分布
R语言小白学习笔记12-概率分布 笔记链接 学习笔记12-概率分布 12.1 正态分布 12.2 二项分布 12.3 泊松分布 12.4 其他分布 笔记链接 学习笔记1-R语言基础. 学习笔记2-高级 ...
- R语言小白学习笔记13—基本统计
R语言小白学习笔记13-基本统计 笔记链接 学习笔记13-基本统计 13.1 概括性统计量 13.2 相关系数和协方差 13.3 t-检验 13.3.1 单样本t检验 13.3.2 两样本t检验 13 ...
- R语言可视化学习笔记之ggridges包
作者:严涛 浙江大学作物遗传育种在读研究生(生物信息学方向)伪码农,R语言爱好者,爱开源. 严涛老师的绘图教程还有: gganimate |诺奖文章里面的动图绘制教程来了!! ggplot2学习笔记之 ...
- R语言实战-读书笔记（第1 章 R语言介绍）
*R语言实战所有学习笔记,如涉及侵权,请联系撤稿.* **标题号与书中标题号对应** R语言实战 第1章 R语言介绍 1.2 R的获取与安装 R可以在CRAN(Comprehe ...
最新文章
- 计算机教学与课程论专业,东北师范大学专业介绍：计算机课程与教学论
- 支付产品——收银台设计详解
- 系统性能信息模块篇psutil之获取系统性能信息
- python全栈工程师百科_Python全栈工程师（列表、拷贝）
- visualmap超过范围改变颜色_高动态范围（High-Dynamic Range，简称HDR）
- python中的mul函数_Sympy:“Mul”对象没有分层函数的“cos”属性
- 天国近了(一) -- 揭穿OOP神话
- 驻马店远大计算机阳业学院,电力学院
- Android计算器界面布局
- 2020年净利润腰斩，麦格纳要转型“造车”？
- 最新可用快手极速版自动阅读薅羊毛autojs脚本
- html 数据可视化
- Ps“反转负冲”人像处理一例
- 计算机网络的分类 ppt,《计算机网络》PPT课件.ppt
- 《JS修炼之道》—— 读后总结
- matplotlib对excel数据可视化
- App 抓包利器：Charles 以及 App 爬虫心得
- 扫地机器人噪音响_硬件老兵拆机分析：扫地机器人噪音大小到底与何相关？
- 图文并茂，一文读懂信号源
- k64 datasheet学习笔记26--Oscillator (OSC)