R语言多字节字符串有错 r语言字符型数据

R 语言中的最基本数据类型主要有三种：数字，逻辑，文本

逻辑类型在许多其他编程语言中常称为布尔型(Boolean),常量值只有 TRUE 和 FALSE(注意：R 语言区分大小写，true 或 True 不能代表 TRUE)。

最直观的数据类型就是文本类型。文本就是其它语言中常出现的字符串（String），常量用双引号包含。在 R 语言中，文本常量既可以用单引号包含，也可以用双引号包含，例如：

> 'hello'=="hello"
[1] TRUE

向量
向量（Vector）在 Java、Rust、C# 这些专门编程的的语言的标准库里往往会提供，这是因为向量在数学运算中是不可或缺的工具——我们最常见的向量是二维向量，这种向量在平面坐标系中必然会用到。
向量从数据结构上看就是一个线性表，可以看成一个数组。

> a<-c(1,2,3,4)
> a
[1] 1 2 3 4

> a[1:4] # 取出第 1 到 4 项，包含第 1 和第 4 项
[1] 1 2 3 4
> a[c(1,3)] # 取出第 1, 3 项
[1] 1 3
> a[c(-1)]  # 去掉第 1 项
[1] 2 3 4

"向量"作为线性表结构，应该具备一些常用的线性表处理函数，R 确实具备这些函数：

向量排序：

> a = c(1, 3, 5, 2, 4, 6)
> sort(a)
[1] 1 2 3 4 5 6
> rev(a)
[1] 6 4 2 5 3 1
> order(a)
[1] 1 4 2 5 3 6
> a[order(a)]
[1] 1 2 3 4 5 6

order()函数返回的是一组向量排序后的下标向量。

向量统计：

R 中有十分完整的统计学函数：

示例：

> sum(1:8)
[1] 36
> sd(1:5)
[1] 1.581139
> range(1:5)
[1] 1 5

向量生成：
向量的生成可以用 c() 函数生成，也可以用 min:max 运算符生成连续的序列。
1.如果想生成有间隙的等差数列，可以用 seq 函数：

> seq(1,9,2)
[1] 1 3 5 7 9

seq 还可以生成从 m 到 n 的等差数列，只需要指定 m, n 以及数列的长度：

> seq(1,5,length.out=3)
[1] 1 3 5

2.rep 是 repeat（重复）的意思，可以用于产生重复出现的数字序列：

> rep(0,4)
[1] 0 0 0 0

NA和NULL：
向量中常会用到 NA 和 NULL ，这里介绍一下这两个词语与区别：
a.NA 代表的是"缺失"，NULL 代表的是"不存在"。
b.NA 缺失就想占位符，代表这里没有一个值，但位置存在。
c.NULL 代表的就是数据不存在。

逻辑型：
实例：

> c(1,2,3)>2
[1] FALSE FALSE  TRUE

which 函数是十分常见的逻辑型向量处理函数，可以用于筛选我们需要的数据的下标:

> a=c(1,2,3)
> b=a>2
> print(b)
[1] FALSE FALSE  TRUE
> which(b)
[1] 3

例如我们需要从一个线性表中筛选大于等于 60 且小于 70 的数据：

> vector = c(10,40,78,64,53,62,69,70)
> print(vector[which(vector >=40 & vector <=65)])
[1] 40 64 53 62
> print(which(vector >=40 & vector <=65))#打印下标
[1] 2 4 5 6
#分开实现
> a <- which(vector >=40 & vector <=65)
> print(a)
[1] 2 4 5 6
> print(vector[a])
[1] 40 64 53 62

类似的函数还有 all 和 any：

> all(c(TRUE,TRUE,TRUE))
[1] TRUE
> all(c(TRUE,TRUE,FALSE))
[1] FALSE
> any(c(TRUE,FALSE,FALSE))
[1] TRUE
> any(c(FALSE,FALSE,FALSE))
[1] FALSE

all() 用于检查逻辑向量是否全部为 TRUE，any() 用于检查逻辑向量是否含有 TRUE。

字符串：

> toupper("Runoob") # 转换为大写
[1] "RUNOOB"
> tolower("Runoob") # 转换为小写
[1] "runoob"
> nchar("中文", type="bytes") # 统计字节长度
[1] 4
> nchar("中文", type="char") # 总计字符数量
[1] 2
> substr("123456789", 1, 5) # 截取字符串，从 1 到 5
[1] "12345"
> substring("1234567890", 5) # 截取字符串，从 5 到结束
[1] "567890"
> as.numeric("12") # 将字符串转换为数字
[1] 12
> as.character(12.34) # 将数字转换为字符串
[1] "12.34"
> strsplit("2019;10;1", ";") # 分隔符拆分字符串
[[1]]
[1] "2019" "10"   "1"
> gsub("/", "-", "2019/10/1") # 替换字符串
[1] "2019-10-1"

在 Windows 计算机上实现，使用的是 GBK 编码标准，所以一个中文字符是两个字节，如果在 UTF-8 编码的计算机上运行，单个中文字符的字节长度应该是 3。

矩阵
R 语言为线性代数的研究提供了矩阵类型，这种数据结构很类似于其它语言中的二维数组，但 R 提供了语言级的矩阵运算支持。
首先看看矩阵的生成：

> matrix(c(1,2,3,4,5,6),2,3)
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
> matrix(c(1,2,3,4,5,6),2,3,byrow=TRUE)#byrow指定按行填充
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

R 中的矩阵的每一个列和每一行都可以设定名称，这个过程通过字符串向量批量完成：

> a<-matrix(c(1,2,3,4,5,6),2,3,byrow=TRUE)
> print(a)
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
> colnames(a)=c("a","b","c")
> rownames(a)=c("x","y")
> print(a)
  a b c
x 1 2 3
y 4 5 6
> print(a["x",])
a b c 
1 2 3

矩阵的四则运算与向量基本一致，既可以与标量做运算，也可以与同规模的矩阵做对应位置的运算。

矩阵乘法运算：

> m1=matrix(c(1,2),1,2)
> m2=matrix(c(3,4),2,1)
> m1 %*% m2
     [,1]
[1,]   11

逆矩阵：

> A= matrix(c(1,3,2,4),2,2)
> solve(A)
     [,1] [,2]
[1,] -2.0  1.0
[2,]  1.5 -0.5
> print(A)
     [,1] [,2]
[1,]    1    2
[2,]    3    4
> apply(A,1,sum) #第二个参数为 1 按行操作，用 sum() 函数
[1] 3 7
> apply(A,2,sum) #第二个参数为 2 按列操作
[1] 4 6

apply() 函数可以将矩阵的每一行或每一列当作向量来进行操作.