R语言-因子和表

2024-07-20 14:54:42 浏览数 (2)

因子和表

因子（factor）是R语言中许多强大运算的基础，因子的设计思想来着统计学中的名义变量（分类变量），因子可以简单的看做一个附加了更多信息的向量。

使用方法：factor（x=character(）,levels,labels=levels,exclude = NA,ordered = is.ordered(x),nmax=NA)

因子的创建

不像向量、矩阵与数据框比较直观，很好理解，因子不太好使用语言描述，但是代码很直观，能很直观的返回对象的水平。

代码语言：r复制
> myvector <-c("T","F","T","T") #向量
> myfactor <- factor(myvector)
> myfactor
[1] T F T T
Levels: F T

注意返回值第二行有一个水平，值得是myvector只有F和T，两个水平。

第一行可以理解诶myvector转换为因子后的结果。

因子的索引

因子的索引与向量操作差不多，但是返回的原因子水平

代码语言：r复制
> myvector <-c("T","F","T","T") #向量
> myfactor <- factor(myvector)
> myfactor
[1] T F T T
Levels: F T
> myfactor[c(1,2)] #取1,2个水平不变
[1] T F
Levels: F T
> myfactor[c(3,4)] #取1,2个水平不变
[1] T T
Levels: F T

因子的修改

与向量也差不多，最简单的方法就是赋值

代码语言：r复制
> myfactor[3] <- "F"
> myfactor
[1] T F F T
Levels: F T

当然还有其他操作，差不多都可以参照向量，特别说明：因子不是向量，他们只是像，因子的类型是因子型，与向量不同

因子常用的函数

  1. tapply()函数 tapply(x,f,g)：x向量，f因子或因子列表，g函数。tapply执行操作，将x分组，每组对应一个因子水平（多音字情况下，对应一组水平的组合，然后向量应用于函数g），注意：f中每个因子需要与x具有相同的长度，返回值是向量或者矩阵，x必须是向量
代码语言：r复制
> data1 <- data.frame(name = c("李小华","张蜜桃","刘大灰","李佳怡"),"性别" = c("女","女","男","男"),age = c(18,19,23,21),hight = c(175,173,167,177))
> #name,性别，age是列名
> data1
    name 性别 age hight
1 李小华   女  18   175
2 张蜜桃   女  19   173
3 刘大灰   男  23   167
4 李佳怡   男  21   177
> class(data1)
[1] "data.frame"
> tapply(data1$hight,data1$性别,mean) #以上是对性别进行分组后，对身高进行求均值，返回男的身高平均值，女的身高平均值
 男  女 
172 174 
> #如果想用分多组，就用因子列表
> tapply(data1$hight,list(data1$性别,data1$name),mean)
   李佳怡 李小华 刘大灰 张蜜桃
男    177     NA    167     NA
女     NA    175     NA    173

2.split()函数

和tapply（）函数不同，split（）只分组，x可为数据框或向量，返回值是列表

代码语言：r复制
> split(data1$name,data1$性别)#对name按照性别进行分组，结果返回列表，标签是分组水平
$男
[1] "刘大灰" "李佳怡"

$女
[1] "李小华" "张蜜桃"
  1. by()函数 by(x,f,function)，X是向量或矩阵，注意by应用与对象，f是因子，function是函数> by(data1$hight,data1$性别,mean) data1$性别: 男 [1] 172 ----------------------------------------------------------- data1$性别: 女 [1] 174

4.aggregate(x,list,f)函数，其中x为向量/数据框/矩阵，第二个参数必须为list，f是函数。该函数可以安装要求打组聚合，然后对聚合以后得数据进行加和，求平均等各种操作

代码语言：r复制
> data1
    name 性别 age hight
1 李小华   女  18   175
2 张蜜桃   女  19   173
3 刘大灰   男  23   167
4 李佳怡   男  21   177
> aggregate(data1[,c(3,4)],list(data1$性别),mean)#按照性别聚合后，对age与hight进行求期望
  Group.1  age hight
1      男 22.0   172
2      女 18.5   174

表

R中表指的是列联表

1，table（）函数

常用与统计向量频数

代码语言：r复制
> a <- c(1,2,2,3,4,5,6,4,1,4,5,6,4,3)
> table(a)
a
1 2 3 4 5 6 
2 2 2 4 2 2

注意表可以如同矩阵一样访问

代码语言：r复制
> table(a)[3]
3 
2 
> list1<-list(c(2,2,2,3,4,5),c(6,6,7,7,8,8))
> table(list1)
       list1.2
list1.1 6 7 8
      2 2 1 0
      3 0 1 0
      4 0 0 1
      5 0 0 1
> table(list1)[3,]
6 7 8 
0 0 1

2.cut()函数

cut(x,b,labels = FALSE)是生成因子的一种常用方法，常用与表操作，这个函数用法很负责

代码语言：r复制
> data1 <- data.frame(name = c("李小华","张蜜桃","刘大灰","李佳怡"),"性别" = c("女","女","男","男"),age = c(18,19,23,21),hight = c(175,173,167,177))
> #name,性别，age是列名
> aa <- cut(data1$hight,breaks = c(-Inf,160,170,175,182,Inf), labels = c("不评价","还行","很好","喜欢","哇！"))
> 
> data1 <- cbind(data1,aa)
> data1
    name 性别 age hight   aa
1 李小华   女  18   175 很好
2 张蜜桃   女  19   173 很好
3 刘大灰   男  23   167 还行
4 李佳怡   男  21   177 喜欢

字符串

字符串比较简单，基本上就是一些函数，字符串在文本挖掘中很重要，使用正则表达式很方便

字符串操作的常见函数

1.字符串长度

使用nchar（）函数求字符串长度

2.字符串合并

使用paste（）函数求字符串长度

3.字符串分割

使用strsplit()函数分割字符串，返回的是列表

4.读取字符串

使用substr（）读取字符串，substr(x,start,stop)

5.字符串替换

使用chartr（）函数替换元素，chartr(old，new，x),把x的old换成new的

6，多个组件合成一个字符串

使用sprintf（）函数

代码语言：r复制
t <- c("hello world")
nchar(t)
#字符串合并
a2 <- "我是坤"
a3 <- "绰号只因"
a4 <- paste(a2,a3,sep = "-坤粉说-")
a4
#字符串分割
a5 <- "你~在~干~什~么？"
strsplit(a5,"~")
代码语言：r复制
> a6 <- "读取字符串"
> substr(a6,3,5)
[1] "字符串"
> chartr("字符","zifu",a6) #长度要相等，不然要出问题
[1] "读取zi串"
代码语言：r复制
> a9 <- 666
> hh <- sprintf("你真%d",a9) #a数据替换了%d
> hh
[1] "你真666"
> a10 <- "哎呦"
> a11 <- 6
> h1 <- sprintf("你干嘛！%s,%d",a10,a11) #%s是接受字符串型的数据
> h1
[1] "你干嘛！哎呦,6"

正则表达式

正则表达式就是找相同，作用范围非常广

  1. grep（）函数 grep（pattern，x，ignore.case = FALSE,perl = FALSE,value = FALSE,fixed = FALSE,useBytes = FALSE ,invert = FALSE）,在向量x中搜索给定的子字符串pattern，返回结果是匹配项的下标

X向量，后面参数比较复杂

代码语言：r复制
> a1 <- c("Aa","english","Chinese")
> grep("Aa",a1)
[1] 1
> grep("[en]",a1) #返回有en的元素位置
[1] 2 3
> grep("l.s",a1) #查找l与s，中间有一个随便的元素，返回2
[1] 2
> grep("e..l",a1) #查找e至l，中间有两个元素
[1] 2
  1. sub（old,new,x）函数，gsub（）函数 sub（old，new，x）,在x将old替换哼new，只对查找的第一个内容进行替换a <- c("a","c","d") sub("c","hh",a) a1 <- c("aac","hhc","sss","cdd") gsub("c","b",a1)gsub(old,new,x)，将所有的old替换为new

3.regexpr(pattern,text)、gregexpr(pattern,text)函数

regexpr(pattern,text,ignore.case = FALSE,perl = FALSE,fixed = FALSE,useBytes =FALSE),返回一个与给出第一个匹配的起始位置的文本长度相同的整数向量，如果没有则返回-1

代码语言：r复制
> a2 <- c("asdasdv","wertsdasv","sdvasd")
> regexpr("sdas",a2)
[1]  2  5 -1
attr(,"match.length")
[1]  4  4 -1
attr(,"index.type")
[1] "chars"
attr(,"useBytes")
[1] TRUE

gregexpr(pattern,text,ingore.case =FALSE，perl =FALSE,fixed = FALSE,useBytes =FALSE),返回一个与文本长度相同的列表，每个元素的格式与regexpr的返回值相同，除了给出了每个（不想交）匹配的起始位置

代码语言：r复制
> a2 <- c("asdasdv","wertsdasv","sdvasd")
> gregexpr("sdas",a2)
[[1]]
[1] 2
attr(,"match.length")
[1] 4
attr(,"index.type")
[1] "chars"
attr(,"useBytes")
[1] TRUE

[[2]]
[1] 5
attr(,"match.length")
[1] 4
attr(,"index.type")
[1] "chars"
attr(,"useBytes")
[1] TRUE

[[3]]
[1] -1
attr(,"match.length")
[1] -1
attr(,"index.type")
[1] "chars"
attr(,"useBytes")
[1] TRUE

注意：正则表达式有很多使用场景，多用于处理文本，比较复杂

数学运算与模拟

  1. sum（）函数，求和函数> a <- (1:5) > sum(a) #求和 [1] 15 > prod(a) #求连乘 [1] 120 > factorial(6) #求阶乘6*5*4*3*2*1 [1] 720 > a [1] 1 2 3 4 5 > max(a) [1] 5 > min(a) [1] 1 > range(a) [1] 1 5 > c(max(a),min(a)) [1] 5 1 > which.max(a) [1] 5 > which.min(a) [1] 1 > median(a) [1] 3 > var(a)#计算方差 [1] 2.5 > rev(a) #去逆序列 [1] 5 4 3 2 1 > a [1] 1 2 3 4 5 > sort(a) [1] 1 2 3 4 5 > a [1] 1 2 3 4 5 > a2 <- c(11,50,23,37,44) > order(a2) [1] 1 3 4 5 2 > a3 <-cumsum(a) #累计和，第n个元素是1加到n的和 > a3 [1] 1 3 6 10 15 > pmax(a2,a3) #结果第一个元素是a2[1]与a3[1]两个中的最大值，其他类推 [1] 11 50 23 37 44 > pmin(a2,a3) [1] 1 3 6 10 15 > a2 [1] 11 50 23 37 44 > a3 [1] 1 3 6 10 15 > match(a2,a3) [1] NA NA NA NA NA > choose(5,3) # 5*4*3/3/2/1=10 [1] 10 > a4 <- c(1,2,4,5,6,7,7,7,7,4,4,4,2,2,2) > unique(a4) [1] 1 2 4 5 6 7 > a5 <- c(1,2,3,4,5,6) > a6 <- c(4,5,6,7,8,9) > union(a5,a6) [1] 1 2 3 4 5 6 7 8 9 > intersect(a5,a6) [1] 4 5 6 > setdiff(a5,a6) [1] 1 2 3 > a5 %in% a6 [1] FALSE FALSE FALSE TRUE TRUE TRUE > setequal(a5,a6) [1] FALSE > setequal(c(1,2,3),c(1,2,3)) [1] TRUE
  2. prod（）函数，求连乘
  3. factorial（）函数，求阶乘
  4. max（）函数，求最大值，min（）函数，求最小值，range（）函数，同时返回最小值与最大值
  5. which.max（）函数返回最大元素的位置，which.min（）函数返回最小元素的位置
  6. median（）函数，求中位数
  7. var（）函数，计算方差
  8. rev（）函数，对元素去逆序列
  9. sort（）函数，将元素按升序排列，order（）函数，从小的到大的返回他们各自的位置
  10. cumsum（）函数，累计和，第n个元素是1加到n的和
  11. pmax（a，b）函数返回一个向量，第i个元素是ai与bi中的最大值、pmin（a，b）函数返回一个向量，第i个元素是ai与bi中的最小值
  12. match（x，y）函数，返回一个和x的长度相同的向量，表示x中与y中元素相同的元素在y中的位置（没有则返回NA）
  13. choose（n,k），求组合数，从n个中选出K
  14. unique（x），如果x是一个向量或数据框，则返回一个类似的对象但是去掉所有重复的元素，对于重复的元素只取一个
  15. union（x,y）函数求x,y并集，intersect（x,y）函数求x,y交集，setdiff（x,y）函数相当于先求x,y交集再求差集
  16. x%in%y，判断x,y向量元素是否相同，相同的话返回TRUE，setequal（x,y）函数判断x,y向量是否完全相同，返回逻辑值
r语言

0 人点赞