Question

我正在学习R（我本周才开始），我一直在努力学习typeof，mode，storage.mode和class的概念。我一直在上下搜索（官方R文档，StackOverflow，谷歌等），我无法找到任何明确的解释这些之间的区别。（一些StackOverflow and CrossValidated答案并没有真正帮助我解决问题。）最后（我希望），我想我明白了，所以我的问题是验证我是否理解是对的。

模式与storage.mode： mode and storage.mode are basically the same thing，但处理“单一”数据类型的方式略有不同。

模式与typeof： Very similar, except for a few differences，最值得注意的是（typeof“integer”和“double”）=（mode“numeric”）;和两者（typeof“special”和“builtin”=（mode“function”）。

class：类基于R的面向对象的类层次结构。我很难找到这个图形布局，但我能找到的最好的是这个图：

（如果有人能指出我更准确的R类层次结构，我会替换它。）

尽管类名与R class（）函数的结果并不完全对应，但我认为层次结构基本上是准确的。我的理解是对象的“类” - 也就是class（）函数的结果 - 是层次结构中的根类。因此，例如，“Vector”是不是根类，因此它永远不会显示为class（）函数的结果。根类可能更像是“StrVector”（“字符”）或“BoolVector”（“逻辑”）。相比之下，“矩阵”本身就是一个根类;因此，它的类是“矩阵”。

显然，R支持多重继承，因此一些对象可以有多个类。

typeof / mode / storage.mode vs class：这是我最难理解的部分。我现在理解的是：typeof / mode / storage.mode（我将其称之为“mode”）基本上是R对象可以作为其值之一保存的最复杂的数据类型 。因此，例如，由于矩阵，数组和向量只能包含一个向量数据类型，因此它们的模式（即它们可以容纳的最复杂的数据类型）通常是数字，字符或逻辑，即使它们的类（它们在类中的位置）等级）是完全不同的东西。

这最有趣的地方（也就是混乱）与列表之类的对象有关。 “列表”模式意味着对象中的每个值本身可以是一个列表（即，可以包含不同数据类型的对象）。因此，无论类本身是否为“列表”，都有多个对象（例如数据帧）可以包含不同的值，因此其模式为“列表”，即使它们的类是其他的。

总而言之，我的理解是：

typeof / mode / storage.mode（几乎相同的东西）基本上是R对象可以作为其值之一保存的最复杂的数据类型;而
class是根据R类层次结构的对象的面向对象分类。

我的理解准确吗？如果没有，有人可以给出更准确的解释吗？

Answer 1

＆＃39;模式＆＃39;是一种互相排斥的对象分类他们的基本结构。原子＆＃39;模式是数字的，复杂的，性格和逻辑。递归对象具有诸如＆＃39; list＆＃39;之类的模式。要么＆＃39;功能＆＃39;或其他一些人。一个对象只有一种模式。

＆＃39;类＆＃39;是分配给对象的属性，用于确定通用的方式功能与它一起运作。它不是互相排斥的分类。如果一个对象没有分配给它的特定类，那么作为一个简单的数字向量，它的类通常与它的模式相同，按惯例。

改变对象的模式通常被称为“胁迫”。的模式一个对象可以改变而不必改变类。 e.g。

> x <- 1:16
> mode(x)
[1] "numeric"
> dim(x) <- c(4,4)
> mode(x)
[1] "numeric"
> class(x)
[1] "matrix"
> is.numeric(x)
[1] TRUE
> mode(x) <- "character"
> mode(x)
[1] "character"
> class(x)
[1] "matrix"

然而：

> x <- factor(x)
> class(x)
[1] "factor"
> mode(x)
[1] "numeric"

在这个阶段，即使x再次具有模式数字，它的新类， factor，禁止将其用于算术运算。

实际上，除了定义一个类之外，模式的使用并不多隐式地没有指定明确的类。

Answer 2

我希望以下示例对您有所帮助。特别是，看看最后两个例子。

x <- 1
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- letters
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- TRUE
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars[1]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- cars[[1]]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- matrix(cars)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- new.env()
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- expression(1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- quote(y <- 1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

x <- ls
print(c(class(x), mode(x), storage.mode(x), typeof(x)))

结果

[1] "numeric" "numeric" "double"  "double" 
[1] "character" "character" "character" "character"
[1] "logical" "logical" "logical" "logical"
[1] "data.frame" "list"       "list"       "list"      
[1] "data.frame" "list"       "list"       "list"      
[1] "numeric" "numeric" "double"  "double" 
[1] "matrix" "list"   "list"   "list"  
[1] "environment" "environment" "environment" "environment"
[1] "expression" "expression" "expression" "expression"
[1] "<-"       "call"     "language" "language"
[1] "function" "function" "function" "closure"

最后一个示例显示了typeof（）！= storage.mode（）。

的情况

Answer 3

简单地说，唯一真正有用的是class()和typeof()

class可描述为对象的“容器”，该属性使该对象具有以该对象的特定“类型”作为参数的函数的外部行为
type是该对象在容器内部的构成，是基础值的“类型”

一个明显的例子：

x <- as.Date('2010-01-01')
class(x) # Date
typeof(x) # double
unclass(x) # 14610

attr(x, 'tz') <- 'CEST'
attributes(x)$class # "Date"
attributes(x)$tz # "CEST"

Answer 4

只是为了提高可读性。

我希望以下示例对您有所帮助。特别要看一下最后两个示例。

x <- 1L
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "integer"      "numeric"      "integer"      "integer"

x <- 1
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "numeric"      "numeric"      "double"       "double" 

x <- letters
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "character"    "character"    "character"    "character"

x <- TRUE
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "logical"      "logical"      "logical"      "logical"

x <- cars
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "data.frame"   "list"         "list"         "list"   

x <- cars[1]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "data.frame"   "list"         "list"         "list"      

x <- cars[[1]]
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "numeric"      "numeric"      "double"       "double" 

x <- matrix(cars)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "matrix"       "list"         "list"         "list"  

x <- new.env()
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "environment"  "environment"  "environment"  "environment"

x <- expression(1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "expression"   "expression"   "expression"   "expression"

x <- quote(y <- 1 + 1)
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "<-"           "call"         "language"     "language"

x <- ls
print(c(class(x), mode(x), storage.mode(x), typeof(x)))
[1] "function"     "function"     "function"     "closure"

积分-@SHUAICHENG WANG

R中模式和类有什么区别？

4 个答案: