R-变量与类型

变量

R语言的变量非常神奇，比较java、python来说
A容器没有标签，可以装任何类型的值------------------R
B容器一开始就有标签，只能装定义类型的值---------java
C容器用了一次就有了标签，只能装一种类型的值—python

这里的标签指的就是变量中’值的类型’

有时候R语言可以做到一个变量通吃一整段的代码，当然，我们并不推荐这么做；如果你突然回过头想找之前用过的值，结果你根本分不清哪个是哪个 --_–``，岂不是很难受，还要重新运行一遍前面的代码，所以说不管是从一个代码规范的角度，还是为了使用的方便，本人希望读者们可以有一个好的写代码的习惯，那就让我们从变量开始。
那么，什么是变量呢？正如前面例子中说的那样，变量是一个容器，它在内存中，并拥有自己独立的空间，用来存储数据（值、对象）。

变量命名规则：

1、由字母，数字，点（.）和下划线（_）组成，不允许有其他字符（例如：%，$，#...）
2、不能以数字，下划线（_）开头
3、以点（.）开头，点后不能直接跟数字（错误案例：.2var_name），为隐藏变量
4、能够见名知意（例如：hotel_price，hotel.price，hotelPrice）
5、R语言严格要求区分大小写（不论是函数，还是变量）

变量的赋值符号：

<-、<<-：左赋值
= ：左赋值
->、->>：右赋值

其中 ‘=’ 是我们熟知的赋值运算符，另外的两个赋值符号，我们可以看作一个小箭头，指向哪里就是给哪里赋值，非常的简单粗暴。

简单案例：给变量x赋值，12

> x <- 12
> x = 12
> 12 -> x

打印输出函数：

print()：比较常用的输出函数，自动换行
cat()：可以将多个变量组合成一个连续的打印输出，不自动换行，可以在最后接一个" , '\n' "

简单案例：输出hello world！

> print('hello world!')
[1] "hello world!"
> print(paste('hello','world!'))     #paste是一个字符串连接函数，中间以空格连接，不要空格可用paste0函数
[1] "hello world!"
> cat('hello','world!')
hello world!

变量查找：

ls()函数：

> ls() #查找所有变量，不包括隐藏变量
[1] "df"         "max"        "num"        "percentage" "x"          "y"  

> ls(pattern = 'm') #查找所有变量名带有m的变量
[1] "max" "num"
> ls(pattern = '\\w{3}') #可以使用正则表达式
[1] "max"        "num"        "percentage"

> ls(all.names = TRUE) #查找所有变量，包括隐藏变量（以点开头）
[1] ".Random.seed" "df"           "max"          "num"          "percentage"   "x"           
[7] "y" 

变量删除：

rm()函数：

> rm('x') #删除名为‘x’的变量
> ls()
[1] "df"         "max"        "num"        "percentage" "y"  

当我们不再需要这个变量的时候，就可以使用rm()函数无情抛弃它了：），当然，我不是在引导你们成为’渣男/女’，只是因为大量变量会占用内存，从而降低程序的运行速度，所以不得不“磨刀霍霍”了。
我们还可以将rm()和ls()结合起来用，提升删除效率。

> rm(list = ls(pattern = 'm')) #删除变量名带‘m’的变量
> ls()
[1] "df"         "percentage" "y"     

> rm(list = ls()) #删除所有变量
> ls()
character(0)

[ 可能我的案例中，大家看不出什么方便的地方，这是我的命名方式问题，我检讨 ]
大家不妨想一下，如果说（打个比方），前面的变量是分类的（都是以hotel_开头的变量名），在删除的时候是否会便利许多呢。

类型

R语言有这样一些较常用的R对象：向量、列表（list）、矩阵（matrix）、数组（array）、因子（factory）、数据框（data.frame）

最为简单的当属向量，其建立在以下6种基本类型（也叫原子向量）之上：

数据类型	实例	代码与结果
逻辑型（布尔值）	TRUE，FALSE	> class(TRUE) - [1] "logical"
数值型	23.2， 5， 99.99	> class(12.5) - [1] "numeric"
整数型	2L， 45L	> class(45L) - [1] "integer"
复数型	4+3i	> class(4+3i) - [1] "complex"
字符型	'1'， 'hello'， "world"	> class('hello') - [1] "character"
序列化字符（原生）	"hello"存储为：48 65 6c 6c 6f	> class(charToRaw('hello')) - [1] "raw"

切记，里面没有string类型，所有字符（串）都是character。

向量

要创建多个元素的向量，我们需要用到c()函数，它可以对多个元素进行组合。

> demo01 <- c('hello',"world",'!')
> demo01 #直接查看demo01的值（在控制台可以不使用print()或cat()）
[1] "hello" "world" "!"   
> class(demo01)
[1] "character"

当不同类型的元素组合在一起时，就会发生非常有趣的变化

#1、logical和raw的组合
> demo01 <- c(TRUE,charToRaw('hello'))
> demo01
[1] TRUE TRUE TRUE TRUE TRUE TRUE
#非0的数值变为logical都是TRUE，0为FALSE
> class(demo01)
[1] "logical"

#2、logical和integer的组合
> demo01 <- c(TRUE,12L)
> demo01
[1]  1 12
#TRUE转为数值为1，FALSE为0
> class(demo01)
[1] "integer"

#3、integer和numeric的组合
> demo01 <- c(12L,13.5)
> demo01
[1] 12.0 13.5
> class(demo01)
[1] "numeric"

#4、numeric和complex的组合
> demo01 <- c(13.5, 3+2i)
> demo01
[1] 13.5+0i  3.0+2i
> class(demo01)
[1] "complex"

#5、complex和character的组合
> demo01 <- c(3+2i,'hello')
> demo01
[1] "3+2i"  "hello"
> class(demo01)
[1] "character"

c()函数能将多个元素组合成一个向量，但一个向量只能是一个类型，从上面的实践来看，存在类型间的自动转换，依次为：raw->logical->integer->numeric->complex->character，既然有自动转换，那么也少不了强制转换了，charToRaw()已经见过面了，其余的还有：as.numeric()，as.complex()，as.character()，as.logical()，as.integer()， rawToChar()，toString()。。。等。

列表

列表这个R对象，可以包含许多不同类型的元素，向量、函数、也可以是另一个列表。

#定义一个列表
> list1 <- list(c('as','R'),'hello',mean, list('you','be'))
> list1
[[1]]
[1] "as" "R" 

[[2]]
[1] "hello"

[[3]]
function (x, ...) 
UseMethod("mean")



[[4]]
[[4]][[1]]
[1] "you"

[[4]][[2]]
[1] "be"

#取出list1的第一个元素
> list1[[1]]
[1] "as" "R" 

切记：R语言的下标是从1开始计数的

矩阵

矩阵可以理解为一个二维数组，通过向量的形式输入

#定义一个矩阵
> x<-matrix(c(1,2,3,4,5,6),nrow = 2,ncol = 3)
> x
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

#byrow参数默认为F（FALSE），可以设置成TRUE，改变元素排列
> x<-matrix(c(1,2,3,4,5,6),nrow = 2,ncol = 3,byrow = T)
> x
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

> y<-t(x) #t()函数是矩阵的转置
> y
     [,1] [,2]
[1,]    1    4
[2,]    2    5
[3,]    3    6

> 2*x #数值*矩阵，相当于数值*矩阵内每个元素
     [,1] [,2] [,3]
[1,]    2    4    6
[2,]    8   10   12

> x%*%y #矩阵相乘符号%*%
     [,1] [,2]
[1,]   14   32
[2,]   32   77

#我们还可以通过dim()函数来获取矩阵的每个维度
> dim(x)
[1] 2 3

#也可以用来改变其维度
> dim(x) <- c(1,6)
> x
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    2    3    4    5    6

数组

数组的维度数是任意的，在创建的时候，由dim这一属性控制

#创建数组
> x<-array(c(1,2,3,4,5,6,7,8,9,10,11,12),dim = c(2,3,2))
> x
, , 1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

#取值
> x[1,1,1]
[1] 1
> x[1,2,2]
[1] 9

因子

因子是一种向量形式的R对象。因子将向量中的元素的不同值作为标签，标签始终是字符，无论它原来是数字、字符还是逻辑（布尔）等，它在统计建模时非常有用。

#将上述数组x，转为factor（因子），并查看
> x<-factor(x)
> x
 [1] 1  2  3  4  5  6  7  8  9  10 11 12
Levels: 1 2 3 4 5 6 7 8 9 10 11 12

#转为factor后，会将原来的结构打散，重新变为向量的形式，只是形式

#级别统计
> nlevels(x)
[1] 12

数据框

数据框是表格类型的R对象。与矩阵不同之处在于：矩阵的类型是唯一的，元素只能是同一种类型；数据框则是列与列的类型可以不同。数据框的每一列都可以作为一个组合向量，且长度相同。
使用data.frame()函数创建。

> df<-data.frame(id = c(1, 2, 3, 4, 5), color = c('red', 'yellow', 'green', 'red', 'green'))
> df
  id  color
1  1    red
2  2 yellow
3  3  green
4  4    red
5  5  green

#取值
> df[1,2]
[1] red
Levels: green red yellow
> df[1,'color']
[1] red
Levels: green red yellow

总结

这些类型都是在R语言中相当常用的，具体的使用，以及其他的方法，我会再单独补充，若其中有什么错误或是遗漏，欢迎指出，谢谢品鉴！！