统计一个向量里0的个数 R语言 r语言查看向量类型

转载

mob64ca140a59b0 2024-06-24 10:39:44

文章标签 统计一个向量里0的个数 R语言 r语言数据分析标量数据 文章分类 R语言后端开发

1 变量和数据类型

1.1 变量

1.2 R语言的数据类型

1.3 属性

2 向量

2.1 创建向量

2.2 访问向量内元素

2.3 插入追加删除

2.4 向量的运算

2.4.1 标量与标量的运算

2.4.2 向量的运算

2.5 向量函数

参考

1 变量和数据类型

1.1 变量

R的变量没有固定的类型，赋值实际上是“绑定”，即将一个变量名与一个存储地址联系在一起。同一变量名可在不同时间绑定不同对象，同一个存储地址可以有多个变量名与其联系。

        变量名应由字母，数字、点、下划线字符组成
        变量名应以字母或点开头
        变量名点开头后不能跟数字。

1.2 R语言的数据类型

R语言的基本数据类型（也称原子类型）主要有以下几种：

1. Numeric（数值型）：
表示数值数据，包括整数和浮点数。
如：x <- 3.14 或 y <- 42
在r中浮点数有两个名字叫numeric与double【1】
class表示对象一个抽象的数据类型
mode表示其存储类型
typeof表示对象组成最基本的数据类型，当对象基本类型不统一或无法表示则用对象本身或NULL【2】

> x <- list(c(1,2,1,3,2,1))
> mode(x)
[1] "list"
> typeof(x)
[1] "list"
> x<-c(1,2,3)
> mode(x)
[1] "numeric"
> typeof(x)
[1] "double"
> x<-c(1:3)
> mode(x)
[1] "numeric"
> typeof(x)
[1] "integer"
# c(1:3)与c(1,2,3)内容一样只是类型一个整型一个浮点double

2. Integer（整型）：
表示整数数据，要在R中显式创建整数，通常在数字后面加上L字母。
如：z <- 5L 表示一个整数。
3. Character（字符型）：
表示字符或字符串数据，字符串通常用引号（" 或者 '）括起来。
如：name <- "Alice"
4. Logical（逻辑型）：
表示逻辑数据，只有两个可能的值：TRUE 、T 或 FALSE、F。
如：flag <- TRUE
5. Complex（复数型）：
表示复数数据，包含实部和虚部。
如：comp <- 3 + 2i
6. Raw（原型）：
Raw类型类型是直接使用其二进制内容来进行保存和使用的类型。如：
缺失值：NA 用is.na()、NaN用is.na()或用is.nan()判断
无穷： Inf、-Inf
不存在： NULL
空字符串不算NA
非有限值：NA、NaN、Inf、-Inf

类型转换：

隐式转换：
四则运算中浮点、整型都提升为浮点double
逻辑转数值：TRUE为1，FALSE为0
不同类型通过某个函数组合或不同类型数据进行运算，类型提升为式子中较复杂
复杂度：logical<integer<double<character
强制类型转换：
as.numeric(c(FALSE, TRUE))

此外，R的对象(数据结构)可以划分为以下几种类型

1. 向量（vector）
使用c()将元素组合成一个向量
原子类型的向量中元素都是同一基本类型，不存在嵌套

x <- c('red','green',"yellow")

2. 列表（list）
它可以在其中包含许多不同类型的元素，如向量，函数甚至其中的另一个列表

list1 <- list(c(2,5,3),21.3,"apple",cos)

3. 矩阵（matrix）
二维矩形数据集。它可以使用matrix()创建，向量元素填入矩阵的缺省次序是按列填入，用byrow=TRUE选项可以转换成按行填入

M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)

4. 数组（array）
数组区别于矩阵，可以不只有两个维度，数组函数使用一个dim属性创建所需的维数。

a <- array(c('green','yellow'),dim = c(3,3,2))

5. 因子（factor)

x<-c(1,1,1,2,2,2,2,3,3,3,4)
y<-factor(x)
print(y)
x1<-c("a","a",'a',"b","c",'c')
y1<-factor(x1)
print(y1)

6. 数据框（data.frame)
数据帧是表格数据对象，使用data.frame()函数创建数据帧。

mydatafram <-     data.frame(
  name = c("GGB", "MK","LS"), 
  height = c(180, 175.5, 165), 
  weight = c(81,93, 78),
  Age = c(42,38,26)
)
print(mydatafram)

统计一个向量里0的个数 R语言 r语言查看向量类型_r语言_04

1.3 属性

属性是对象除了数据本身外附带的信息，当然NUL不具有类型和数据也就不具有属性。如

length、mode、names, dim维度，class等。

> a <- array(c('green','yellow'),dim = c(3,3,2))
> a
, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"

> attributes(a) #查看属性，不包括固有属性mode和length
$dim
[1] 3 3 2

> # 可以用attr(x, "属性名")的格式读取已有的 或 定义一个新的x的属性
> x <- c(1,3,5)
> attr(x, "a_neww_atr") <- 3
> print(x)
[1] 1 3 5
attr(,"a_neww_atr")
[1] 3

2 向量

2.1 创建向量

# 向量为同一数据类型数据的集合
x1 <- c(1,2,3)
x2 <-c(T,TRUE,FALSE,F)
x3<-c("a","bb","cc")

# 快速生成向量
# 序列生成
y1 <- c(1:20)
y2<-seq(from=1,to=10)
y3<-seq(from=1,to=10,by=2) # 等差为2
y3<-seq(from=1,to=20,length.out = 8) # 序列长度为8
# 重复序列
z1 <- rep(2,5)
z2 <- rep(x1,5) # x1重复5次
z3 <- rep(x1,each=5) # x1每个元素重复5次
z4 <- rep(x1,times=5) # 整个序列重复5次
z5 <- rep(x1,times=2,each=5) # x1每个元素重复5次的序列重复2次

统计一个向量里0的个数 R语言 r语言查看向量类型_统计一个向量里0的个数 R语言_05

统计一个向量里0的个数 R语言 r语言查看向量类型_标量_06

1:5和seq(5)的结果是整型（integer）的， c(1,3,5)和seq(1, 5, by=2)的结果是浮点型（double）的。

2.2 访问向量内元素

> x1 <- c(1:50) 
> x1[1] # 不同于Python、C等编程语言，R索引从1开始
[1] 1
> x1[50]
[1] 50
> x1[51] #允许越界
[1] NA
> x1[-5] # 选择除第5索引位置处元素外其它元素
 [1]  1  2  3  4  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[25] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
[49] 50
> x1[] # 表示选取x1所有元素作为子集
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
[25] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
[49] 49 50
> x1[T] #逻辑下标，选取数据时要考虑!is.na
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
[25] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
[49] 49 50
> 
> # 选择子集
> # 按照索引向量选取
> # 选取第1到20个索引位置元素
> x1[c(1:20)] 
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
> # 选取第1、1、2、3、4、9、19索引位置元素
> x1[c(1,1,2,3,4,9,19)]
[1]  1  1  2  3  4  9 19
> # 按照逻辑判断选取
> # 比较运算符 <   <=  >  >=  ==  !=  %in%
> # 逻辑运算符 & | ！
> # &&、|| 分别为短路的标量逻辑与和短路的标量逻辑或， 仅对两个标量进行运算，如果有向量也仅使用第一个元素。 一般用在if语句、while语句中，且只要第一个比较已经决定最终结果就不计算第二个比较。
> # 每一个元素被选择情况都是TRUE
> x1[c(T)]
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
[25] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
[49] 49 50
> # 索引按照TF TF TF这样顺序取
> x1[c(T,F)]
 [1]  1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47
[25] 49
> # 索引选取条件为索引在3和7之间的值
> x1<-c(9:1)
> x1[x1>2 & x1<8]
[1] 7 6 5 4 3
> 
> x1<-c("o",'two','t',"f")
> # 字符f是否在x1中
> "f" %in% x1
[1] TRUE
> x1['f' %in% x1] # 相当于x1[c(T)]、x1[T]
[1] "o"   "two" "t"   "f"  
> x1[T]
[1] "o"   "two" "t"   "f"  
> x1 %in% c("o","two","f") # 相当于c(T,T,F,T)
[1]  TRUE  TRUE FALSE  TRUE
> x1[x1 %in% c("o","two","f")]
[1] "o"   "two" "f"  
> 
> # 给向量各元素命名，按名选取
> x<-c(1,2,3)
> names(x)<-c('one',"two","three")
> x["one"]
one 
  1 
> v<-c("one"=1,"two"=2)
> v
one two 
  1   2 
> 
> 
> # 函数match(x, y)起到和x %in% y运算类似的作用，其返回结果不是T、F 
> # 而是对x的每个元素， 找到其在y中首次出现的下标，找不到时取缺失值

2.3 插入追加删除

> # 向量最后一个元素后追加元素
> y<-c(1:3) # 此时最大索引为3
> y[4]<-4
> y
[1] 1 2 3 4
> y[c(5,6,7)]<-c(5,6,7)
> y
[1] 1 2 3 4 5 6 7
> y[10]<-10 # 有两个缺省NA
> y
 [1]  1  2  3  4  5  6  7 NA NA 10
> 
> # 插入
> # 在y向量中第8个元素后插入0
> y<-append(x=y,values=0,after = 8) # append()不改变y ，头部插入after=0
> y
 [1]  1  2  3  4  5  6  7 NA  0 NA 10
> # 删除整个向量
> rm(y)
> # y # 错误: 找不到对象'y'
> # 删除某元素
> y<-c(1:10)
> y<-y[-c(1:5)]# 选取y中除了1到5的元素赋值给y
> y
[1]  6  7  8  9 10
> 
> # 修改某个元素
> y[1]<-7
> y
[1]  7  7  8  9 10
> x['one']<-0
> x
  one   two three 
    0     2     3 
> 
> # 类型自动转换
> v<-c(1,2,3)
> class(v)
[1] "numeric"
> v[1]='1'
> class(v)
[1] "character"

2.4 向量的运算

2.4.1 标量与标量的运算

单个数值称为标量， R没有标量类型，标量就是长度为1的向量。

四则运算：
+ - * / ^ 加、减、乘、除、乘方
遵循四则运算优先级，建议用括号明确顺序
整除：
%/%
求余：

%%
> (3+5)*(6/3)+2^3
[1] 24
> 4/3
[1] 1.333333
> 4%/%3
[1] 1
> 8%%3
[1] 2

2.4.2 向量的运算

向量的运算是向量中每个元素都进行运算

（1）向量与标量

> x<-c(1:10)
> x
 [1]  1  2  3  4  5  6  7  8  9 10
> (((x+1-1)*2)/2)^2
 [1]   1   4   9  16  25  36  49  64  81 100
# 支持缺失值

（2）等长向量运算

# 等长向量
> x<-c(1,2,3)
> y<-c(1,2,3)
> (x+y)-2*x
[1] 0 0 0
> x*y
[1] 1 4 9
> x**y
[1]  1  4 27

（3）不等长向量运算

需要长度短的向量和长度长的向量要是倍数关系，运算时，长的y利用x和自身前n个元素运算，之后从x第1个元素再接着和y自己后面的元素相运算

> x<-c(2,2)
> y<-c(1,2,3,4)
> x*y
[1] 2 4 6 8
>  z<-c(1,2,3)
> x*z
[1] 2 4 6
Warning message:
In x * z : 长的对象长度不是短的对象长度的整倍数

（4）集合运算

> unique(c(1, 5, 2, 5)) #求不同值
[1] 1 5 2
> c(2,3) %in% c(1,2,2,3,3)
[1] TRUE TRUE
> match(c(2,5), c(1,5,2,5)) #第一次出现元素的索引
[1] 3 2
> intersect(c(5, 7), c(1, 5, 2, 5)) #交集
[1] 5
> union(c(5, 7), c(1, 5, 2, 5))# 并集
[1] 5 7 1 2
> setdiff(c(5, 7), c(1, 5, 2, 5)) #差集 c(5,7)中不属于c(1,5,2,5)中元素
[1] 7
> setequal(c(1,5,2), c(2,5,1)) #判断集合相等，次序和重复值不影响
[1] TRUE

2.5 向量函数

舍入 ceiling, floor, round, signif, trunc, zapsmall
        ceiling向上取整、floor向下取整、trunc取整数部分
        round(x)、round(x,2)四舍五入或按给定位数2四舍五入
        signif(x,n)保留n位有效数字
符号函数 sign
绝对值 abs
平方根 sqrt
对数与指数函数 log, exp, log10, log2
        log(6,base=4)以4为底6的对数，缺省base默认自然对数
三角函数 sin, cos, tan
反三角函数 asin, acos, atan, atan2
双曲函数 sinh, cosh, tanh
反双曲函数 asinh, acosh, atanh
求和 sum,
求平均值mean
求样本方差var
求样本标准差sd
求最小值min
求最大值max
求最小值和最大值range
求所有元素的乘积prod
计算累加cumsum
累乘积cumprod
返回向量v特定元素索引which.max(v)、which(v==2)
which(c(FALSE, TRUE, TRUE, FALSE, NA))
which((11:15) > 12)
逻辑判断是否全为真all(v) ，v中允许有缺失值，结果可能为缺失值
逻辑判断是否至少一个为真any(v)，v中允许有缺失值，结果可能为缺失值
比较两个R对象x与y的内容、类型是否相同identical(x,y)
比较数值型时不区分整数型与实数型all.equal(x,y)