zoukankan      html  css  js  c++  java
  • 《学习R》笔记:科学计算器、检查变量和工作区、向量、矩阵和数组、列表和数据框

    一、第二章 科学计算器

    要检查两个数字是否一样,要使用 all.equal() ,不要使用 == ,== 符号仅用于比较两个整型数是否存在相同 。

    > all.equal(sqrt(2)^2,2)
    [1] TRUE
    > all.equal(sqrt(2) ^ 2,3)
    [1] "Mean relative difference: 0.5"
    > isTRUE(all.equal(sqrt(2) ^ 2,2))
    [1] TRUE
    > isTRUE(all.equal(sqrt(2) ^ 2,3))
    [1] FALSE
    

     

    二、第三章 检查变量和工作区

    变量的类:逻辑类(logical)、三个数值的类(numeric、complex、integer)、用于存储文本的字符character、存储类别数据的因子factor,以及较罕见的存储二进制数据的原始值raw

    factor因子,存储类别数据

    > gender = factor(c("male","female","male","female"))
    > gender
    [1] male   female male   female
    Levels: female male
    > levels(gender)
    [1] "female" "male"  
    > nlevels(gender)
    [1] 2

    在底层,因子的值被存储为整数,而非字符。可以通过调用 as.integer() 清楚的看到

    > as.integer(gender)
    [1] 2 1 2 1
    

     事实证明,采用整数而非字符文本的存储方式,令内存的使用非常高效

    > gender_char = sample(c("female","male"),1000,replace = TRUE)
    > gender_char
    ......
    
    > gender_fac = as.factor(gender_char)
    > #把数据的类型转换为因子型
    > object.size(gender_char)#object.size()函数返回对象的内存大小
    8160 bytes
    > object.size(gender_fac)
    4560 bytes
    

     把因子转换为字符串

    > as.character(gender)
    [1] "male"   "female" "male"   "female" 

     改变一个对象的类型(转型casting)

    > x = "123.456"  #使用as*函数改变x的类型
    > as.numeric(x)   #as(x,"numeric")
    [1] 123.456
    > is.numeric(x)
    [1] FALSE
    

     代码  options(digits = n) 设置全局变量确定打印数字的小数点位数。

    > options(digits = 10)
    > (x = runif(5))
    [1] 0.040052175522 0.544388080016 0.506369658280
    [4] 0.144690239336 0.005838404642
    

     runif 函数将生成30个均匀分布于0和1之间的随机数,summary 函数就不同的数据类型提供汇总信息,例如对数值变量:

    > num = runif(30)
    > summary(num)
           Min.     1st Qu.      Median        Mean 
    0.001235794 0.199856233 0.475356185 0.475318138 
        3rd Qu.        Max. 
    0.703412558 0.984893506 
    

     letters、LETTERS 是两个内置的常数

    > letters
     [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"
    [13] "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x"
    [25] "y" "z"
    > LETTERS
     [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L"
    [13] "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X"
    [25] "Y" "Z"
    

     sample 函数为抽样函数,它的格式为:sample( x , size= , replace= ) 第三个参数的缺省值是F ,表示进行的是无放回抽样。

    对a~e重复随机抽样30次:

    > fac = factor(sample(letters[1:5],size = 30,replace = T))
    > summary(fac)
     a  b  c  d  e 
     4  7  2  5 12 
    
    > bool = sample(c(TRUE,FALSE,NA),30,replace = TRUE)
    > summary(bool)
       Mode   FALSE    TRUE    NA's 
    logical      10       8      12 
    

      创建数据框dfr ,这里只显示他的前几行

    > dfr = data.frame(num,fac,bool)
    > head(dfr)                  #默认显示前6行
                num fac bool
    1 0.34019507235   b   NA
    2 0.77415443189   e TRUE
    3 0.02201034524   d TRUE
    4 0.11190012516   e   NA
    5 0.18030911358   a   NA
    6 0.98489350639   d TRUE
    
    > summary(dfr)
          num              fac       bool        
     Min.   :0.001235794   a: 4   Mode :logical  
     1st Qu.:0.199856233   b: 7   FALSE:10       
     Median :0.475356185   c: 2   TRUE :8        
     Mean   :0.475318138   d: 5   NA's :12       
     3rd Qu.:0.703412558   e:12                  
     Max.   :0.984893506     
    

     str 函数能显示对象的结构。对向量来说,它并非很有趣(因为它们太简单了),但 str 对数据框和嵌套列表非常有用:

    > str(num)
     num [1:30] 0.34 0.774 0.022 0.112 0.18 ...
    > str(dfr)
    'data.frame':	30 obs. of  3 variables:
     $ num : num  0.34 0.774 0.022 0.112 0.18 ...
     $ fac : Factor w/ 5 levels "a","b","c","d",..: 2 5 4 5 1 4 1 4 1 5 ...
     $ bool: logi  NA TRUE TRUE NA NA TRUE ...
    

     每个类都有自己的打印(print)方法,以此控制如何显示到控制台。又是,这种打印模糊了其内部结构,或忽略了一些有用的信息。用unclass函数可绕开这一点,显示变量是如何构建的。例如,对因子调用 unclass 函数会显示它仅是一个整数(integer) 向量,拥有一个叫 levels 的属性:

    unclass(fac)
    [1] 2 1 4 3
    attr(,"levels")
    [1] "cat"      "dog"      "goldfish" "hamster" 
    

     attributes 函数能显示当前对象的所有属性列表:

    > attributes(fac)
    $levels
    [1] "cat"      "dog"      "goldfish" "hamster" 
    
    $class
    [1] "factor"

     view 函数会把数据框显示为电子表格。edit 和 fix 与其相似,不过它们允许手动更改数据值。

    View(dfr)           #不允许更改
    new_dfr = edit(dfr) #更改将保存于new_dfr
    fix(dfr)            #更改将保存于dfr
    View(head(dfr,50)) #查看前50行
    

      

     三、第四章 向量、矩阵和数组

     数组能存放多维矩形数据。矩阵是二维数组的特例。

    有很多创建序列的方法,seq创建的优点是可设置步长。

    > (xulie = seq(1,15,2))
    [1]  1  3  5  7  9 11 13 15
    

     length() 函数查询序列的长度:

    > length(xulie)
    [1] 8
    

     向量的命名:

    > c(apple = 1,banana = 2,"kiwi fruit" = 3, 4)
         apple     banana kiwi fruit            
             1          2          3          4 
    > x = 1:4
    > names(x) = c("apple" ,"banana" ,"kiwi fruit","")
    > x
         apple     banana kiwi fruit            
             1          2          3          4 
    

      数组的创建:

    > three_d_array = array(                 #三维数组
    +   1:24,
    +   dim = c(4,3,2),
    +   dimnames = list(
    +     c("one","two","three","four"),
    +     c("ein","zwei","drei"),
    +     c("un","deux")
    +   )
    + )
    > three_d_array
    , , un
    
          ein zwei drei
    one     1    5    9
    two     2    6   10
    three   3    7   11
    four    4    8   12
    
    , , deux
    
          ein zwei drei
    one    13   17   21
    two    14   18   22
    three  15   19   23
    four   16   20   24
    
    > (a_matrix = matrix(                #创建矩阵
    +   1:12,
    +   nrow = 4,byrow = T,
    +   dimnames = list(
    +     c("one","two","three","four"),
    +     c("ein","zwei","drei")
    +   )
    + ))
          ein zwei drei
    one     1    2    3
    two     4    5    6
    three   7    8    9
    four   10   11   12
    

    一些函数:

    > x = (1:5) ^ 2
    > x
    [1]  1  4  9 16 25
    > x[c(1,3,5)]
    [1]  1  9 25
    > x[c(-2,-4)]
    [1]  1  9 25
    > x[c(TRUE,F,T,F,T)]
    [1]  1  9 25
    > names(x) = c("one","four","nine","sixteen","twenty five")
    > x
            one        four        nine     sixteen twenty five 
              1           4           9          16          25 
    > which(x > 10)
        sixteen twenty five 
              4           5 
    > which.min(x)
    one 
      1 
    > which.max(x)
    twenty five 
              5 
    > 
    > rep(1:5 , 3)
     [1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
    > rep(1:5 , each = 3)
     [1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5
    > rep(1:5 , times = 1:5)
     [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
    > rep(1:5 , length.out = 7)
    [1] 1 2 3 4 5 1 2
    
    > rep.int(1:5 , 3)
     [1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
    > rep_len(1:5 , 13)
     [1] 1 2 3 4 5 1 2 3 4 5 1 2 3
    
    > dim(three_d_array)
    [1] 4 3 2
    > dim(a_matrix)
    [1] 4 3
    > nrow(a_matrix)
    [1] 4
    > ncol(a_matrix)
    [1] 3
    

      

     第五章 列表和数据框

    #创建一个列表
    > (main_list = list( + element_in_main_list = log10(1:10), + middle_list = list( + element_in_middle_list = diag(3), + inner_list = list( + element_in_inner_list = pi ^ 1:4, + another_element_in_inner_list = "a" + ) + ) + )) $element_in_main_list [1] 0.0000000 0.3010300 0.4771213 0.6020600 0.6989700 0.7781513 [7] 0.8450980 0.9030900 0.9542425 1.0000000 $middle_list $middle_list$element_in_middle_list [,1] [,2] [,3] [1,] 1 0 0 [2,] 0 1 0 [3,] 0 0 1 $middle_list$inner_list $middle_list$inner_list$element_in_inner_list [1] 3.141593 $middle_list$inner_list$another_element_in_inner_list [1] "a"

     对列表进行查询

    (uk_bank_holidays_2013 <-list(
      Jan = "New Year's Day",
      Feb = NULL,
      Mar = "Good Friday",
      Apr = "Easter Monday",
      May = c("Early May Bank Holiday","Spring Bank Holiday"),
      Jun = NULL,
      Jul = NULL,
      Aug = "Summer Bank Holiday",
      Sep = NULL,
      Oct = NULL,
      Nov = NULL,
      Dec = c("Chrismas Day","Boxing Day")
    ))

    #假如创建列表时并没有给各元素命名,可在最后利用names()对列表命名。names(uk_bank_holidays_2013) = month.abb;
    > uk_bank_holidays_2013["Jan"]  #各种查询方式
    $Jan
    [1] "New Year's Day"
    
    > uk_bank_holidays_2013[["Jan"]]
    [1] "New Year's Day"
    > uk_bank_holidays_2013$Jan
    [1] "New Year's Day"
    > uk_bank_holidays_2013[1]
    $Jan
    [1] "New Year's Day"
    
    > uk_bank_holidays_2013[[1]]
    [1] "New Year's Day"
    > uk_bank_holidays_2013[[c(5,2)]]  #各种查询方式
    [1] "Spring Bank Holiday"
    > uk_bank_holidays_2013[[5]][[2]]
    [1] "Spring Bank Holiday"
    > uk_bank_holidays_2013$May
    [1] "Early May Bank Holiday" "Spring Bank Holiday"   
    > uk_bank_holidays_2013$May[2]
    [1] "Spring Bank Holiday"
    > uk_bank_holidays_2013$Jan = NULL #删去元素操作
    > uk_bank_holidays_2013$Feb = NULL
    > uk_bank_holidays_2013["Aug"] = list(NULL) #将元素设置为NULL值
    > uk_bank_holidays_2013
    $Mar
    [1] "Good Friday"
    
    $Apr
    [1] "Easter Monday"
    
    $May
    [1] "Early May Bank Holiday" "Spring Bank Holiday"   
    
    $Jun
    NULL
    
    $Jul
    NULL
    
    $Aug
    NULL
    
    $Sep
    NULL
    
    $Oct
    NULL
    
    $Nov
    NULL
    
    $Dec
    [1] "Chrismas Day" "Boxing Day"  

     创建数据框:

    > (a_data_frame = data.frame(          #创建一个数据框
    +   x = letters[1:5],
    +   y = rnorm(5),
    +   z = runif(5) > 0.5
    + row.names = NULL #如果输入的任何变量有名称,那么行名称就取自第一 + )) #个向量名称,该语句可将此规则覆盖掉 x y z 1 a 0.3067414 FALSE 2 b -2.4637065 TRUE 3 c 0.8443321 TRUE 4 d -0.0163287 TRUE 5 e 0.8291859 TRUE

       注意,每列的类型可与其他列不同,但在同一列中的元素类型必须相同。还要注意的是,对象的类名是 data.frame ,中间有一个点,而非空字符。

    第五章介绍了列表与数据框,操作数据框是一个很大的话题,13章会讨论。

  • 相关阅读:
    .net core 3.1 使用Redis缓存
    JavaSE 高级 第11节 缓冲输入输出字节流
    JavaSE 高级 第10节 字节数组输出流ByteArrayOutputStream
    JavaSE 高级 第09节 字节数组输入流ByteArrayInputStream
    JavaSE 高级 第08节 文件输出流FileOutputStream
    JavaSE 高级 第07节 文件输入流FileInputStream
    JavaSE 高级 第06节 初识I、O流
    JavaSE 高级 第05节 日期类与格式化
    JavaSE 高级 第04节 StringBuffer类
    JavaSE 高级 第03节 Math类与猜数字游戏
  • 原文地址:https://www.cnblogs.com/jiaxinwei/p/11483133.html
Copyright © 2011-2022 走看看