碼上快樂

相關內容    簡體    繁體

關於R中的mode()和class()的區別

本文轉載自   查看原文   2016-03-20 14:00   5767 


在R中，他並不提供直接訪問存儲在內存中的數據的方法，而是提供特定的數據結構（我們將之稱為對象）

mode：表示對象在內存中的存儲類型
基本數據類型'atomic' mode： 
numeric（Integer/double）, complex, character和logical
遞歸的對象（recursive object）：
'list' 或 'function' 

class：是一種抽象類型，或者理解為一種數據結構
他主要是用來給泛型函數（參考java中泛型的概念）識別參數用。
如下例，你可以看到數據在內存中是列表的形式存儲，卻被包裝成數據框來操作。（數據框其實是一種特殊的列表）
例子1 
    
    
    
            
    
     
     
     
             
  1. d <- data.frame(V1=c(1,2))  
    2. 
     
     
     
             
  2. class(d)    #"data.frame"
    3. 
     
     
     
             
  3. mode(d)     #"list"
    4.
再看一個例子2 
    
    
    
            
    
     
     
     
             
  1. 例子2.1
    2. 
     
     
     
             

    3. 
     
     
     
             
  3. x1<-c(1,2,3)
    4. 
     
     
     
             
  4. x2<-c(2,3,4)
    5. 
     
     
     
             
  5. x3<-c(3,4,5)
    6. 
     
     
     
             
  6. xmerge<-data.frame(x1,x2,x3)
    7. 
     
     
     
             
  7. class(xmerge)   #dataframe
    8. 
     
     
     
             
  8. mode(xmerge)   #list
    9. 
    
    
    
            

    
    
    
            

     
     
     
             
 
              
       
       
       
               
    
        
        
        
                

    2. 
        
        
        
                
  2. 例子2.2
    3. 
        
        
        
                
  3. > class(xmerge[1,])
    4. 
        
        
        
                
  4. [1] "data.frame"
    5. 
        
        
        
                
  5. > mode(xmerge[1,])
    6. 
        
        
        
                
  6. [1] "list"
    7. 
        
        
        
                
  7. > xmerge[1,]
    8. 
        
        
        
                
  8.  x1 x2 x3
    9. 
        
        
        
                
  9. 1 1 2 3
    10. 
       
       
       
               
 
             

     
     
     
             
 
              
       
       
       
               
    
        
        
        
                

    2. 
        
        
        
                
  2. 例子2.3
    3. 
        
        
        
                

    4. 
        
        
        
                
  4. > x1<-c(2,6,3)
    5. 
        
        
        
                
  5. > x2<-c(3,7,4)
    6. 
        
        
        
                
  6. > x3<-c(9,4,5)
    7. 
        
        
        
                
  7. > xmerge<-data.frame(x1,x2,x3)
    8. 
        
        
        
                
  8. > class(xmerge[,1])
    9. 
        
        
        
                
  9. [1] "numeric"
    10. 
        
        
        
                
  10. > mode(xmerge[,1])
    11. 
        
        
        
                
  11. [1] "numeric"
    12. 
        
        
        
                
  12. > xmerge[,1]
    13. 
        
        
        
                
  13. [1] 2 6 3
    14. 
        
        
        
                
  14. > xmerge
    15. 
        
        
        
                
  15.  x1 x2 x3
    16. 
        
        
        
                
  16. 1 2 3 9
    17. 
        
        
        
                
  17. 2 6 7 4
    18. 
        
        
        
                
  18. 3 3 4 5
    19.
從例子1得知，數據框的class是dataframe，而其mode是list，例子2.1加強了這個結論。
例子2.2 說明數據框的每一行class仍然是data.frame,而其mode是list，即每一行仍然是一個數據框。（因為每一行會含有不同的數據類型）
例子2.3說明數據框的每一列的class和mode都是numeric（因為列的數據類型相同，而且我們沒有vector類型的說法）

例子3.1 
    
    
    
            
    
     
     
     
             
  1. x1 = array(rep(1,6),dim=c(2,3))
    2. 
     
     
     
             
  2. class(x1)    #matrix
    3. 
     
     
     
             
  3. mode(x1)     #numeric
    4. 
     
     
     
             
  4.
例子3.2 
    
    
    
            
    
     
     
     
             
  1. x = array(rep("a",6),dim=c(2,3)) #矩陣是數組的二維特殊情形
    2. 
     
     
     
             
  2. class(x) #matrix
    3. 
     
     
     
             
  3. mode(x)  #character
    4.
例子3.3 
    
    
    
            
    
     
     
     
             
  1. x5 = array(rep("a",9),dim=c(3,3,3)) 
    2. 
     
     
     
             
  2. x5      
    3. 
     
     
     
             
  3. , , 1
    4. 
     
     
     
             
  4.      [,1] [,2] [,3]
    5. 
     
     
     
             
  5. [1,] "a"  "a"  "a" 
    6. 
     
     
     
             
  6. [2,] "a"  "a"  "a" 
    7. 
     
     
     
             
  7. [3,] "a"  "a"  "a" 
    8. 
     
     
     
             
  8. , , 2
    9. 
     
     
     
             
  9.      [,1] [,2] [,3]
    10. 
     
     
     
             
  10. [1,] "a"  "a"  "a" 
    11. 
     
     
     
             
  11. [2,] "a"  "a"  "a" 
    12. 
     
     
     
             
  12. [3,] "a"  "a"  "a" 
    13. 
     
     
     
             
  13. , , 3
    14. 
     
     
     
             
  14.      [,1] [,2] [,3]
    15. 
     
     
     
             
  15. [1,] "a"  "a"  "a" 
    16. 
     
     
     
             
  16. [2,] "a"  "a"  "a" 
    17. 
     
     
     
             
  17. [3,] "a"  "a"  "a"        
    18. 
     
     
     
             
  18. class(x5)  #"array"       數據結構是數組
    19. 
     
     
     
             
  19. mode(x5)   #"character"
    20. 
     
     
     
             

    21. 
     
     
     
             
  21. x51<-x5[,,1]
    22. 
     
     
     
             

    23. 
     
     
     
             
  23. class(x51) #"matrix"
    24.
例子3.4 
    
    
    
            
    
     
     
     
             
  1. gl(2,5)            #新建一個因子
    2. 
     
     
     
             
  2. class(gl(2,5))     #"factor"    數據結構是因子
    3. 
     
     
     
             
  3. mode(gl(2,5))      #"numeric"
    4.
而例子3.1-3.4 說明一個問題：
class返回的是matrix，array，factor之類的數據結構類型。（在class中的參數是一個向量或者單個值的時候，返回值和mode相同，不會返回vector，不過可以使用is.vector()返回值是T驗證其確實是向量）
而mode返回的，是每一個元素的類型。
既然你說是每個元素的類型，那么為什么dataframe中mode返回的是list呢？


=============================================
例子4.1 
    
    
    
            
    
     
     
     
             
  1. xl = list(fruit=c("apple","banana","pear"),
    2. 
     
     
     
             
  2.           price=c(1,1,1.5),
    3. 
     
     
     
             
  3.           market=c("newabest"))
    4. 
     
     
     
             
  4. class(xl)    # "list"           數據結構是列表
    5. 
     
     
     
             
  5. mode(xl)     # "list"
    6. 
     
     
     
             

    7. 
     
     
     
             
  7. #也就是說，；列表中的每一項都是列表
    8. 
     
     
     
             
  8. #class(xl$fruit) #"character"
    9.
例子4.1說明，列表中class和mode都是list
但是class(xl$fruit) 得到的是"character"

先說明下
1list[[index]] 得到的是元素（組件）
2list[index]   得到的是子列表 這點請見《R語言經典實例》P119-121 
   
   
   
           
    
    
    
    
            
    2. 
    
    
    
            
  2. > jj<-list(name=c("jos","xuan"),salary=55000,union=T)
    3. 
    
    
    
            
  3. > jj[[1]]
    4. 
    
    
    
            
  4. [1] "jos" "xuan"
    5. 
    
    
    
            

    6. 
    
    
    
            
  6. > class(jj[[1]]) #mode返回值也是character
    7. 
    
    
    
            
  7. [1] "character"
    8. 
    
    
    
            

    9. 
    
    
    
            
  9. > jj[1]
    10. 
    
    
    
            
  10. $name
    11. 
    
    
    
            
  11. [1] "jos" "xuan"
    12. 
    
    
    
            
    13. 
    
    
    
            
  13. > class(jj[1]) #mode返回值也是list
    14. 
    
    
    
            
  14. [1] "list"
    15. 
    
    
    
            

    16. 
    
    
    
            

    17. 
    
    
    
            

    18. 
    
    
    
            
  18. > jj[[2]]
    19. 
    
    
    
            

    20. 
    
    
    
            
  20. [1] 55000
    21. 
    
    
    
            

    22. 
    
    
    
            
  22. > class(jj[[2]])
    23. 
    
    
    
            
  23. [1] "numeric"
    24. 
    
    
    
            

    25. 
    
    
    
            
  25. > jj[2]
    26. 
    
    
    
            

    27. 
    
    
    
            
  27. $salary
    28. 
    
    
    
            
  28. [1] 55000
    29. 
    
    
    
            
    30. 
    
    
    
            
  30. > class(jj[2])
    31. 
    
    
    
            

    32. 
    
    
    
            
  32. [1] "list"
    33. 
    
    
    
            

    34. 
    
    
    
            
  34. > jj[[1]][1]
    35. 
    
    
    
            

    36. 
    
    
    
            
  36. [1] "jos"
    37. 
    
    
    
            
    38. 
    
    
    
            
  38. > class(jj[[1]][1])
    39. 
    
    
    
            

    40. 
    
    
    
            
  40. [1] "character"
    41. 
    
    
    
            

    42. 
    
    
    
            
  42. > mode(jj[[1]][1])
    43. 
    
    
    
            
  43. [1] "character"
    44. 
    
    
    
            
    45. 
    
    
    
            

    46. 
    
    
    
            
  46. > jj[[3]
    47. 
    
    
    
            

    48. 
    
    
    
            
  48. [1] TRUE
    49. 
    
    
    
            

    50. 
    
    
    
            
  50. > jj[3]
    51. 
    
    
    
            

    52. 
    
    
    
            
  52. $union
    53. 
    
    
    
            
  53. [1] TRUE
    54. 
    
    
    
            
    55. 
    
    
    
            
  55. > is.vector(jj[[1]])
    56. 
    
    
    
            
  56. [1] TRUE
    57. 
    
    
    
            
  57. > is.vector(jj[[2]])
    58. 
    
    
    
            
  58. [1] TRUE
    59. 
    
    
    
            

    60. 
    
    
    
            
  60. > is.numeric(jj[[1]])
    61. 
    
    
    
            
  61. [1] FALSE
    62. 
    
    
    
            
  62. > is.numeric(jj[[2]])
    63. 
    
    
    
            
  63. [1] TRUE
    64. 
    
    
    
            

    65. 
    
    
    
            

    66. 
    
    
    
            
  66. > is.vector(jj[[3]])
    67. 
    
    
    
            
  67. [1] TRUE
    68. 
    
    
    
            
  68. > is.list(jj[1])
    69. 
    
    
    
            
  69. [1] TRUE
    70. 
    
    
    
            

    71. 
    
    
    
            
  71. > is.vector(jj[1])
    72. 
    
    
    
            
  72. [1] TRUE
    73. 
    
    
    
            

    74.
因為s.vector(jj[1])返回值都是T，這個結果似乎，不是很令人信服
於是， 搜索?is.vector()


查看幫助說明之后，我們知道了，原來默認的情況下是any，對於任意的原生類型和list以及表達式，都會返回T
例子5 
   
   
   
           
    
    
    
    
            

    2. 
    
    
    
            
  2. 例子5.1
    3. 
    
    
    
            
  3. > x <- c(a = 1, b = 2)
    4. 
    
    
    
            
  4. > x
    5. 
    
    
    
            
  5. a b 
    6. 
    
    
    
            
  6. 1 2 
    7. 
    
    
    
            
  7. > class(x)
    8. 
    
    
    
            
  8. [1] "numeric"
    9. 
    
    
    
            
  9. > is.vector(x)
    10. 
    
    
    
            
  10. [1] TRUE
    11. 
    
    
    
            
  11. > is.vector(x,"double")  
    12. 
    
    
    
            
  12.  #默認是雙精度的，要是整型，要加L
    13. 
    
    
    
            
  13. [1] TRUE
    14. 
    
    
    
            
  14. > is.vector(x,"Integer")
    15. 
    
    
    
            
  15. [1] FALSE
    16. 
    
    
    
            
    17. 
    
    
    
            

    18. 
    
    
    
            

    19. 
    
    
    
            
  19. 例子5.2
    20. 
    
    
    
            
  20. > is.vector(jj[[1]],"list")
    21. 
    
    
    
            
  21. [1] FALSE
    22. 
    
    
    
            
  22. > is.vector(jj[1],"list")
    23. 
    
    
    
            
  23. [1] TRUE
    24.
說明，jj[1]實質上是一種list，而非向量


再看?mode()這一句中幫助文檔的寫法
Description
Get or set the type or storage mode of an object.
value   
a character string giving the desired mode or ‘storage mode’ (type) of the object.
mode(x) <- "newmode"（修改x的數據類型為新的類型newmode）
changes the mode of object x to newmode. This is only supported if there is an appropriate as.newmode function, for example "logical", "integer", "double", "complex", "raw", "character", "list", "expression", "name", "symbol" and "function". Attributes are preserved (but see below).


###############################################
總結：
mode：表示對象在內存中的存儲類型
基本數據類型'atomic' mode：
numeric（Integer/double）, complex, character和logical
遞歸的對象（recursive object）：
'list' 或 'function'
 
class：是一種抽象類型，或者理解為一種數據結構（數據框，因子，列表）
他主要是用來給泛型函數（參考java中泛型的概念）識別參數用。
所以當給函數傳參數的時候如果發生錯誤，就查看class屬性
class返回的是matrix，array，factor(還在Date)之類的數據結構類型
class(x)
  （一） 基本類型情況（參考java中的基本數據類型理解）
（1）當x是單個值，或者向量的時候，
返回的結果和mode一致，如numeric，character
  （二）Object類型情況（參考java中引用數據類型情況理解）
（2）其他情況（矩陣，數組，日期，因子），
         class返回（matrix，array，Date，factor）
         mode返回（x中元素的類型——在內存中的存儲類型）
（3）當x是數據框的時候，class返回dataframe，mode返回list
         當x是列表的時候， class和mode都返回list
  （4）當x是列表的時候，class和mode都返回list
為何數據框和列表不再適用於第二條mode返回x中元素的類型了呢？
1 因為數據框其實是列表的一種特殊情況
2list和dataframe中的數據類型可以不一致，所以沒法返回一個類型代表多種元素類型









免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 R語言學習筆記（一）：mode, class, typeof的區別 vue中mode hash 和 history的區別 ts中interface與class的區別 java中的.java和.class的區別 ts 中 interface 與 class 的區別 Scala中class和object的區別 Swift中 Class和Struct的區別 iOS中的#import和class區別 Scala 中object和class的區別 css中id和class的區別
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM