精华内容
下载资源
问答
  • 对数据框列命名函数是
    千次阅读
    2021-03-22 23:52:29

    前言:近段时间学习R语言用到最多的数据格式就是data.frame,现对data.frame常用操作进行总结,其中函数大部分来自dplyr包,该包由Hadley Wickham所作,主要用于数据的清洗和整理。

    一、创建

    data.frame创建较为容易,调用data.frame函数即可。本文创建一个关于学生成绩的数据框,接下来大部分操作都对该数据框进行,其中学生成绩随机产生

     1 > library(dplyr)       #导入dplyr包
     2 > options(digits = 0)  #保留整数
     3 > set.seed(1)          #设置种子函数
     4 > df <- data.frame(ID = 1:12,                                 #ID
     5 +                  Class = rep(c(1,2,3),4),                   #班级
     6 +                  Chinese = runif(12,min = 0,max = 100),     #语文
     7 +                  Math = runif(12,min = 0,max = 100),        #数学
     8 +                  English = runif(12,min = 0,max = 100))     #英语
     9 > for (i in 1:ncol(df)) {
    10 +   df[,i] <- as.integer(df[,i])  #将每列类型变为integer型
    11 + }

    df结果如下

     1 > df
     2    ID Class Chinese Math English
     3 1   1     1      26   68      26
     4 2   2     2      37   38      38
     5 3   3     3      57   76       1
     6 4   4     1      90   49      38
     7 5   5     2      20   71      86
     8 6   6     3      89   99      34
     9 7   7     1      94   38      48
    10 8   8     2      66   77      59
    11 9   9     3      62   93      49
    12 10 10     1       6   21      18
    13 11 11     2      20   65      82
    14 12 12     3      17   12      66

    二、 查询

    1、查询某一行或某一列

    可通过 data.frame[行号,] 或者 data.frame[,列号] 操作完成

    其中 data.frame[行号,] 得到的类型是数据框

    而 data.frame[,列号] 得到的类型是该列的类型

    > df[2,]
      ID Class Chinese Math English
    2 2 2 37 38 38 > df[,4] [1] 68 38 76 49 71 99 38 77 93 21 65 12

    查询某一列还可以通过 data.frame$列名 操作完成

    > df$Chinese
     [1] 26 37 57 90 20 89 94 66 62  6 20 17

    data.frame[列号] 得到一个仅包含该列内容的数据框

     1 > df[3]
     2    Chinese
     3 1       26
     4 2       37
     5 3       57
     6 4       90
     7 5       20
     8 6       89
     9 7       94
    10 8       66
    11 9       62
    12 10       6
    13 11      20
    14 12      17

    若要查找符合条件的行,可采用 which() 函数,得到的类型是数据框

    > df[which(df$ID == 4),]
      ID Class Chinese Math English
    4  4     1      90   49      38

    2、查询某一个值

    可通过 data.frame[行号,列号] 或 data.frame[行号,‘列名’] 操作完成

    > df[3,4]
    [1] 76
    > df[3,'Math']
    [1] 76

    若查找符合条件的值,可采用 which() 函数

    > df[which(df$Chinese == 57),'Math'] #查询语文成绩为57的同学的数学成绩
    [1] 76
    > df[which(df$Class == 2),'English'] #查询班级号为2的同学的英语成绩
    [1] 38 86 59 82

    三、修改

    1、修改某一行或列

    > df[1,] <- c(1,2,65,59,73)  #修改第一行
    #修改英语成绩
    > df[,'English'] <- c(23,45,67,87,34,46,87,95,43,76,23,94) 

    修改后结果为(1号同学英语成绩先由26修改为73,再修改为23)

     1 > df
     2    ID Class Chinese Math English
     3 1   1     2      65   59      23
     4 2   2     2      37   38      45
     5 3   3     3      57   76      67
     6 4   4     1      90   49      87
     7 5   5     2      20   71      34
     8 6   6     3      89   99      46
     9 7   7     1      94   38      87
    10 8   8     2      66   77      95
    11 9   9     3      62   93      43
    12 10 10     1       6   21      76
    13 11 11     2      20   65      23
    14 12 12     3      17   12      94

    2、修改某一个值

    直接将需要修改后的值赋给上述查询某一个值的操作即可

     1 > df[3,'Chinese'] <- 65 #将3号同学的语文成绩修改为65
     2 #将语文成绩低于20的同学的语文成绩修改为20
     3 > df[which(df$Chinese < 20),'Chinese'] <- 20
     4 > df
     5        ID Class Chinese Math English
     6 1   1     2      65   59      23
     7 2   2     2      37   38      45
     8 3   3     3      65   76      67
     9 4   4     1      90   49      87
    10 5   5     2      20   71      34
    11 6   6     3      89   99      46
    12 7   7     1      94   38      87
    13 8   8     2      66   77      95
    14 9   9     3      62   93      43
    15 10 10     1      20   21      76
    16 11 11     2      20   65      23
    17 12 12     3      20   12      94

    3、修改行列名

    可用rownames()及colnames()得到数据框的行列名,rownames(data.frame)[行号] 或 colnames(data.frame)[列号] 可得到指定位置的行名或者列名,若修改直接赋值给该变量即可

    1 > colnames(df)               #查询列名
    2 [1] "ID"      "Class"   "Chinese" "Math"    "English"
    3 > colnames(df)[4]            #查询第4列列名
    4 [1] "Math"
    5 > colnames(df)[4] <- "math"  #修改第4列列名为math
    6 #修改列名
    7 > colnames(df) <- c("ID","Class","Chinese","Math","English")

    四、删除

    删除行或列,仅需要选出该数据框的部分行或列,然后将其赋给该变量即可,其中在列号或行号前添加-表示不选该行或该列,在这里,为了方便接下来的操作,我们将选出后的数据框赋给其他变量,要实现删除操作应当将选出后的数据框赋给自己

     1 #选出df第1、3、5列  ( df <- df[,c(1,3,5)] )
     2 > df.tmp <- df[,c(1,3,5)]  
     3 > df.tmp
     4    ID Chinese English
     5 1   1      65      23
     6 2   2      37      45
     7 3   3      65      67
     8 4   4      90      87
     9 5   5      20      34
    10 6   6      89      46
    11 7   7      94      87
    12 8   8      66      95
    13 9   9      62      43
    14 10 10      20      76
    15 11 11      20      23
    16 12 12      20      94
    17 #删除df第3行 ( df <- df[-3,] )
    18 > df.tmp <- df[-3,]
    19 > df.tmp
    20    ID Class Chinese Math English
    21 1   1     2      65   59      23
    22 2   2     2      37   38      45
    23 4   4     1      90   49      87
    24 5   5     2      20   71      34
    25 6   6     3      89   99      46
    26 7   7     1      94   38      87
    27 8   8     2      66   77      95
    28 9   9     3      62   93      43
    29 10 10     1      20   21      76
    30 11 11     2      20   65      23
    31 12 12     3      20   12      94

    五、添加

    1、添加行

    data.frame[新行号,] <- 行值

     1 > df[13,] <- c(13,2,62,19,38) #新增13行数据
     2 > df
     3    ID Class Chinese Math English
     4 1   1     2      65   59      23
     5 2   2     2      37   38      45
     6 3   3     3      65   76      67
     7 4   4     1      90   49      87
     8 5   5     2      20   71      34
     9 6   6     3      89   99      46
    10 7   7     1      94   38      87
    11 8   8     2      66   77      95
    12 9   9     3      62   93      43
    13 10 10     1      20   21      76
    14 11 11     2      20   65      23
    15 12 12     3      20   12      94
    16 13 13     2      62   19      38

    若想对行进行复制,可以采用重复行号的方法

     1 > df <- df[c(1,1:12),]      #复制第1行1次
     2 > df
     3     ID Class Chinese Math English
     4 1    1     2      65   59      23
     5 1.1  1     2      65   59      23
     6 2    2     2      37   38      45
     7 3    3     3      65   76      67
     8 4    4     1      90   49      87
     9 5    5     2      20   71      34
    10 6    6     3      89   99      46
    11 7    7     1      94   38      87
    12 8    8     2      66   77      95
    13 9    9     3      62   93      43
    14 10  10     1      20   21      76
    15 11  11     2      20   65      23
    16 12  12     3      20   12      94

    可使用rep()函数方便进行多行的复制

     1 > df <- df[rep(1:12,each = 2),]     #对每行数据复制1次
     2 > df
     3      ID Class Chinese Math English
     4 1     1     2      65   59      23
     5 1.1   1     2      65   59      23
     6 2     2     2      37   38      45
     7 2.1   2     2      37   38      45
     8 3     3     3      65   76      67
     9 3.1   3     3      65   76      67
    10 4     4     1      90   49      87
    11 4.1   4     1      90   49      87
    12 5     5     2      20   71      34
    13 5.1   5     2      20   71      34
    14 6     6     3      89   99      46
    15 6.1   6     3      89   99      46
    16 7     7     1      94   38      87
    17 7.1   7     1      94   38      87
    18 8     8     2      66   77      95
    19 8.1   8     2      66   77      95
    20 9     9     3      62   93      43
    21 9.1   9     3      62   93      43
    22 10   10     1      20   21      76
    23 10.1 10     1      20   21      76
    24 11   11     2      20   65      23
    25 11.1 11     2      20   65      23
    26 12   12     3      20   12      94
    27 12.1 12     3      20   12      94

    还可采用rbind()函数,后续会有示例

    2、添加列

    data.frame$新列名 <- 列值

     1 > df$Physics <- c(23,34,67,23,56,67,78,23,54,56,67,34)
     2 > df
     3    ID Class Chinese Math English Physics
     4 1   1     2      65   59      23      23
     5 2   2     2      37   38      45      34
     6 3   3     3      65   76      67      67
     7 4   4     1      90   49      87      23
     8 5   5     2      20   71      34      56
     9 6   6     3      89   99      46      67
    10 7   7     1      94   38      87      78
    11 8   8     2      66   77      95      23
    12 9   9     3      62   93      43      54
    13 10 10     1      20   21      76      56
    14 11 11     2      20   65      23      67
    15 12 12     3      20   12      94      34

    data.frame[,新列号] <- 列值

     1 > df[,7] <- c(1:12)
     2 > df
     3    ID Class Chinese Math English Physics V7
     4 1   1     2      65   59      23      23     1
     5 2   2     2      37   38      45      34     2
     6 3   3     3      65   76      67      67     3
     7 4   4     1      90   49      87      23     4
     8 5   5     2      20   71      34      56     5
     9 6   6     3      89   99      46      67     6
    10 7   7     1      94   38      87      78     7
    11 8   8     2      66   77      95      23     8
    12 9   9     3      62   93      43      54     9
    13 10 10     1      20   21      76      56    10
    14 11 11     2      20   65      23      67    11
    15 12 12     3      20   12      94      34    12

    还可用dplyr包中的mutate()函数

     1 > mutate(df,Chemistry = Chinese + Math + English + Physics)
     2    ID Class Chinese Math English Physics V7 Chemistry
     3 1   1     2      65   59      23      23      1       170
     4 2   2     2      37   38      45      34      2       154
     5 3   3     3      65   76      67      67      3       275
     6 4   4     1      90   49      87      23      4       249
     7 5   5     2      20   71      34      56      5       181
     8 6   6     3      89   99      46      67      6       301
     9 7   7     1      94   38      87      78      7       297
    10 8   8     2      66   77      95      23      8       261
    11 9   9     3      62   93      43      54      9       252
    12 10 10     1      20   21      76      56     10       173
    13 11 11     2      20   65      23      67     11       175
    14 12 12     3      20   12      94      34     12       160

    还可采用cbind()函数,后续会有示例

    六、dplyr包常用函数

     1 > df  #原数据
     2    ID Class Chinese Math English
     3 1   1     2      65   59      23
     4 2   2     2      37   38      45
     5 3   3     3      65   76      67
     6 4   4     1      90   49      87
     7 5   5     2      20   71      34
     8 6   6     3      89   99      46
     9 7   7     1      94   38      87
    10 8   8     2      66   77      95
    11 9   9     3      62   93      43
    12 10 10     1      20   21      76
    13 11 11     2      20   65      23
    14 12 12     3      20   12      94

    1、arrange() 排序

    arrange(.data, ...)

    arrange(.data, ..., .by_group = FALSE)

     1 > arrange(df,Chinese)  #按语文成绩由小到大排序
     2    ID Class Chinese Math English
     3 1   5     2      20   71      34
     4 2  10     1      20   21      76
     5 3  11     2      20   65      23
     6 4  12     3      20   12      94
     7 5   2     2      37   38      45
     8 6   9     3      62   93      43
     9 7   1     2      65   59      23
    10 8   3     3      65   76      67
    11 9   8     2      66   77      95
    12 10  6     3      89   99      46
    13 11  4     1      90   49      87
    14 12  7     1      94   38      87

    函数中第一个是待排序的数据框,之后依次是变量,且变量优先级逐渐降低,如语文、数学成绩进行排序

     1 > arrange(df,Chinese,Math)  #依次按语文、数学成绩由小到大排序
     2    ID Class Chinese Math English
     3 1  12     3      20   12      94
     4 2  10     1      20   21      76
     5 3  11     2      20   65      23
     6 4   5     2      20   71      34
     7 5   2     2      37   38      45
     8 6   9     3      62   93      43
     9 7   1     2      65   59      23
    10 8   3     3      65   76      67
    11 9   8     2      66   77      95
    12 10  6     3      89   99      46
    13 11  4     1      90   49      87
    14 12  7     1      94   38      87

    若想由大到小排序,使用desc()函数

     1 > arrange(df,desc(Chinese))  #按语文成绩由大到小排序
     2    ID Class Chinese Math English
     3 1   7     1      94   38      87
     4 2   4     1      90   49      87
     5 3   6     3      89   99      46
     6 4   8     2      66   77      95
     7 5   1     2      65   59      23
     8 6   3     3      65   76      67
     9 7   9     3      62   93      43
    10 8   2     2      37   38      45
    11 9   5     2      20   71      34
    12 10 10     1      20   21      76
    13 11 11     2      20   65      23
    14 12 12     3      20   12      94

    2、distinct()函数 去重

    distinct(.data, ..., .keep_all = FALSE)

     1 > df1 <- df[rep(1:nrow(df),each = 2),] #将df每行复制1次
     2 > df1
     3      ID Class Chinese Math English
     4 1     1     2      65   59      23
     5 1.1   1     2      65   59      23
     6 2     2     2      37   38      45
     7 2.1   2     2      37   38      45
     8 3     3     3      65   76      67
     9 3.1   3     3      65   76      67
    10 4     4     1      90   49      87
    11 4.1   4     1      90   49      87
    12 5     5     2      20   71      34
    13 5.1   5     2      20   71      34
    14 6     6     3      89   99      46
    15 6.1   6     3      89   99      46
    16 7     7     1      94   38      87
    17 7.1   7     1      94   38      87
    18 8     8     2      66   77      95
    19 8.1   8     2      66   77      95
    20 9     9     3      62   93      43
    21 9.1   9     3      62   93      43
    22 10   10     1      20   21      76
    23 10.1 10     1      20   21      76
    24 11   11     2      20   65      23
    25 11.1 11     2      20   65      23
    26 12   12     3      20   12      94
    27 12.1 12     3      20   12      94
    28 > df1 <- distinct(df1)  #去除重复的行
    29 > df1
    30    ID Class Chinese Math English
    31 1   1     2      65   59      23
    32 2   2     2      37   38      45
    33 3   3     3      65   76      67
    34 4   4     1      90   49      87
    35 5   5     2      20   71      34
    36 6   6     3      89   99      46
    37 7   7     1      94   38      87
    38 8   8     2      66   77      95
    39 9   9     3      62   93      43
    40 10 10     1      20   21      76
    41 11 11     2      20   65      23
    42 12 12     3      20   12      94

    3、group_by()函数 分组 summarise()函数 概括

    group_by(.data, ..., add = FALSE, .drop = FALSE)

    ungroup(x, ...)

    summarise(.data, ...)

    group_by()与summarise()函数常连用,用于对不同的分组进行操作,在这里再介绍一个管道函数“%>%”,其作用是把左件的值发送给右件的表达式,并作为右件表达式函数的第一个参数

    1 > df %>%
    2 +   group_by(Class) %>%
    3 +   summarise(max = max(Chinese)) #求出按Class分组每组中语文成绩最高分
    4 # A tibble: 3 x 2
    5   Class   max
    6   <dbl> <dbl>
    7 1     1    94
    8 2     2    66
    9 3     3    89

    4、filter()函数 筛选

    filter(.data, ..., .preserve = FALSE)

    选出符合条件的行(返回数据框格式)

     1 > df %>%
     2 +   group_by(Class) %>%
     3 +   filter(Chinese == max(Chinese))  #选出每个班语文成绩最高的学生的信息
     4 # A tibble: 3 x 5
     5 # Groups:   Class [3]
     6      ID Class Chinese  Math English
     7   <dbl> <dbl>   <dbl> <dbl>   <dbl>
     8 1     6     3      89    99      46
     9 2     7     1      94    38      87
    10 3     8     2      66    77      95

    5、select()函数 选择

    select(.data, ...)

     1 > select(df,ID,Chinese,Math,English) #选出df中ID、语文、数学、英语数据
     2    ID Chinese Math English
     3 1   1      65   59      23
     4 2   2      37   38      45
     5 3   3      65   76      67
     6 4   4      90   49      87
     7 5   5      20   71      34
     8 6   6      89   99      46
     9 7   7      94   38      87
    10 8   8      66   77      95
    11 9   9      62   93      43
    12 10 10      20   21      76
    13 11 11      20   65      23
    14 12 12      20   12      94

    6、rbind()函数与cbind()函数 合并

    rbind()函数根据行进行合并,cbind()根据列进行合并

     1 #新建数据框df1
     2 > df1 <- data.frame(ID = 13,Class = 2,
     3 Chinese = 65,Math = 26,English = 84)
     4 > df1
     5   ID Class Chinese Math English
     6 1 13     2      65   26      84
     7 > rbind(df,df1)  #合并df与df1
     8    ID Class Chinese Math English
     9 1   1     2      65   59      23
    10 2   2     2      37   38      45
    11 3   3     3      65   76      67
    12 4   4     1      90   49      87
    13 5   5     2      20   71      34
    14 6   6     3      89   99      46
    15 7   7     1      94   38      87
    16 8   8     2      66   77      95
    17 9   9     3      62   93      43
    18 10 10     1      20   21      76
    19 11 11     2      20   65      23
    20 12 12     3      20   12      94
    21 13 13     2      65   26      84
    22 > df2 #新建数据框df2
    23    Biological
    24 1          65
    25 2          15
    26 3          35
    27 4          59
    28 5          64
    29 6          34
    30 7          29
    31 8          46
    32 9          32
    33 10         95
    34 11         46
    35 12         23
    36 > cbind(df,df2)  #合并df与df2
    37    ID Class Chinese Math English Biological
    38 1   1     2      65   59      23         65
    39 2   2     2      37   38      45         15
    40 3   3     3      65   76      67         35
    41 4   4     1      90   49      87         59
    42 5   5     2      20   71      34         64
    43 6   6     3      89   99      46         34
    44 7   7     1      94   38      87         29
    45 8   8     2      66   77      95         46
    46 9   9     3      62   93      43         32
    47 10 10     1      20   21      76         95
    48 11 11     2      20   65      23         46
    49 12 12     3      20   12      94         23

    7、join函数 连接

    inner_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"),...)

    left_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)

    right_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"),...)

    full_join(x, y, by = NULL, copy = FALSE, suffix = c(".x", ".y"), ...)

    semi_join(x, y, by = NULL, copy = FALSE, ...)

    nest_join(x, y, by = NULL, copy = FALSE, keep = FALSE, name = NULL,...)

    anti_join(x, y, by = NULL, copy = FALSE, ...)

    join函数类型比较多,这里仅以left_join()函数举例

     1 #新建数据框Class
     2 > Class <- data.frame(Class = c(1,2,3),class = c('一班','二班','三班'))
     3 > Class
     4   Class class
     5 1     1  一班
     6 2     2  二班
     7 3     3  三班
     8 > left_join(df,Class,by = 'Class') #基于Class变量左连接df与Class数据框
     9    ID Class Chinese Math English class
    10 1   1     2      65   59      23    二班
    11 2   2     2      37   38      45    二班
    12 3   3     3      65   76      67    三班
    13 4   4     1      90   49      87    一班
    14 5   5     2      20   71      34    二班
    15 6   6     3      89   99      46    三班
    16 7   7     1      94   38      87    一班
    17 8   8     2      66   77      95    二班
    18 9   9     3      62   93      43    三班
    19 10 10     1      20   21      76    一班
    20 11 11     2      20   65      23    二班
    21 12 12     3      20   12      94    三班

    left_join()函数仅保留df对应的Class值的数据

    Data Frame的概念

      Data Frame一般被翻译为数据框,感觉就像是R中的表,由行和列组成,与Matrix不同的是,每个列可以是不同的数据类型,而Matrix是必须相同的。

      Data Frame每一列有列名,每一行也可以指定行名。如果不指定行名,那么就是从1开始自增的Sequence来标识每一行。

      初始化

      使用data.frame函数就可以初始化一个Data Frame。比如我们要初始化一个student的Data Frame其中包含ID和Name还有Gender以及Birthdate,那么代码为:

      student<-data.frame(ID=c(11,12,13),Name=c(“Devin”,”Edward”,”Wenli”),Gender=c(“M”,”M”,”F”),Birthdate=c(“1984-12-29″,”1983-5-6”,”1986-8-8”))

      另外也可以使用read.table() read.csv()读取一个文本文件,返回的也是一个Data Frame对象。读取数据库也是返回Data Frame对象。

      查看student的内容为:

      ID Name Gender Birthdate

      1 11 Devin M 1984-12-29

      2 12 Edward M 1983-5-6

      3 13 Wenli F 1986-8-8

      这里只指定了列名为ID,Name,Gender和Birthdate,使用names函数可以查看列名,如果要查看行名,需要用到row.names函数。这里我们希望将ID作为行名,那么可以这样写:

      row.names(student)<-student$ID

      更简单的办法是在初始化date.frame的时候,有参数row.names可以设置行名的向量。

      访问元素

      与Matrix一样,使用[行Index,列Index]的格式可以访问具体的元素。

      比如访问第一行:

      student[1,]

      访问第二列:

      student[,2]

      使用列的Index或者列名可以选取要访问的哪些列。比如要ID和Name,那么代码为:

      idname<-student[1:2]

      或者是

      idname<-student[c(“ID”,”Name”)]

      如果是只访问某一列,返回的是Vector类型的,那么可以使用[[或者$来访问。比如我们要所有student的Name,代码为:

      name<-student[[2]] 或者name<-student[[“Name”]] 或者name<-student$Name

      使用attach和detach函数可以使得访问列时不需要总是跟着变量名在前面。

      比如要打印所有Name,那么可以写成:

      attach(student)

      print(Name)

      detach(student)

      还可以换一种简洁一点的写法就是用with函数:

      with(student,{

      n<-Name

      print(n)

      })

      这里的n作用域只在大括号内,如果想在with函数中对全局的变量进行赋值,那么需要使用<<-这样一个运算符。

      修改列数据类型

      接下来我们查看该对象每列的类型,使用str(student)可以得到如下结果:

      ‘data.frame’:3 obs. of 4 variables:

      $ ID : num 1 2 3

      $ Name : Factor w/ 3 levels “Devin”,”Edward”,..: 1 2 3

      $ Gender : Factor w/ 2 levels “F”,”M”: 2 2 1

      $ Birthdate: Factor w/ 3 levels “1983-5-6″,”1984-12-29”,..: 2 1 3

      默认情况下,字符串向量都会被自动识别成Factor,也就是说,ID是数字类型,其他的3个列都被定义为Factor类型了。显然这里Name应该是字符串类型,Birthdate应该是Date类型,我们需要对列的数据类型进行更改:

      student$Name<-as.character(student$Name)

      student$Birthdate<-as.Date(student$Birthdate)

      下面我们再运行str(student)看看修改后的结果:

      ‘data.frame’:3 obs. of 4 variables:

      $ ID : num 11 12 13

      $ Name : chr “Devin” “Edward” “Wenli”

      $ Gender : Factor w/ 2 levels “F”,”M”: 2 2 1

      $ Birthdate: Date, format: “1984-12-29” “1983-05-06” “1986-08-08”

      添加新列

      对于以及存在的student对象,我们希望增加Age列,该列是根据Birthdate算出来的。首先需要知道怎么算年龄。我们可以使用日期函数Sys.Date()获得当前的日期,然后使用format函数获得年份,然后用两个年份相减就是年龄。好像R并没有提供几个能用的日期函数,我们只能使用format函数取出年份部分,然后转换为int类型相减。

      student$Age<-as.integer(format(Sys.Date(),”%Y”))-as.integer(format(student$Birthdate,”%Y”))

      这样写似乎太长了,我们可以用within函数,这个函数和之前提到过的with函数类似,可以省略变量名,不同的地方是within函数可以在其中修改变量,也就是我们这里增加Age列:

      student<-within(student,{

      Age<-as.integer(format(Sys.Date(),”%Y”))-as.integer(format(Birthdate,”%Y”))

      })

      查询/子集

      查询一个Date Frame,返回一个满足条件的子集,这相当于数据库中的表查询,是非常常见的操作。使用行和列的Index来获取子集是最简单的方法,前面已经提到过。如果我们使用布尔向量,配合which函数,可以实现对行的过滤。比如我们要查询所有Gender为F的数据,那么我们首先对student$Gender==“F”,得到一个布尔向量:FALSE FALSE TRUE,然后使用which函数可以将布尔向量中TRUE的Index返回,所以我们的完整查询语句就是:

      student[which(student$Gender==”F”),]

      注意这里列Index并没有输入,如果我们只想知道所有女生的年龄,那么可以改为:

      student[which(student$Gender==”F”),”Age”]

      这样的查询写法还是复杂了点,可以直接使用subset函数,那么查询会简单些,比如我们把查询条件改为年龄<30的女性,查姓名和年龄,那么查询语句为:

      subset(student,Gender==”F” & Age<30 ,select=c(“Name”,”Age”))

      使用SQL查询Data Frame

      对于我这种使用了多年SQL的人来说,如果能够直接写SQL语句对Data Frame进行查询操作,那是多么方便美妙的啊,结果还真有这么一个包:sqldf。

      同样是前面的需求,对应的语句就是:

      library(sqldf)

      result<-sqldf(“select Name,Age from student where Gender=’F’ and Age<30”)

      连接/合并

      对于数据库来说,对多表进行join查询是一个很正常的事情,那么在R中也可以对多个Data Frame进行连接,这就需要使用merge函数。

      比如除了前面申明的student对象外,我们再申明一个score变量,记录了每个学生的科目和成绩:

      score<-data.frame(SID=c(11,11,12,12,13),Course=c(“Math”,”English”,”Math”,”Chinese”,”Math”),Score=c(90,80,80,95,96))

      我们看看该表的内容:

      SID Course Score

      1 11 Math 90

      2 11 English 80

      3 12 Math 80

      4 12 Chinese 95

      5 13 Math 96

      这里的SID就是Student里面的ID,相当于一个外键,现在要用这个ID进行inner join操作,那么对应的R语句就是:

      result<-merge(student,score,by.x=”ID”,by.y=”SID”)

      我们看看merge以后的结果:

      ID Name Gender Birthdate Age Course Score

      1 11 Devin M 1984-12-29 31 Math 90

      2 11 Devin M 1984-12-29 31 English 80

      3 12 Edward M 1983-05-06 32 Math 80

      4 12 Edward M 1983-05-06 32 Chinese 95

      5 13 Wenli F 1986-08-08 29 Math 96

      正如我们期望的一样join在了一起。

      除了join,另外一个操作就是union,这也是数据库常用操作,那么在R中如何将两个列一样的Data Frame Union联接在一起呢?虽然R语言中有union函数,但是不是SQL的Union的意思,我们要实现Union功能,需要用到rbind函数。

      rbind的两个Data Frame必须有相同的列,比如我们再申明一个student2,将两个变量rbind起来:

      student2<-data.frame(ID=c(21,22),Name=c(“Yan”,”Peng”),Gender=c(“F”,”M”),Birthdate=c(“1982-2-9″,”1983-1-16”),Age=c(32,31))

      rbind(student,student2)

    更多相关内容
  • 1 设置路径 2 读取数据 3 查看数据的类型 4给每列都命名 5添加列名成功

    1 设置路径

    2 读取数据 

     

    3 查看数据的类型,,不读取数据第一行为列名

     

    4 给每列都命名

    5  添加列名成功

    展开全文
  • 数据类型中的矩阵、数组和数据框

        了解一门语言,首先要了解它的数据结构。该文主要介绍矩阵、数组和数据框。文章仅供学习使用,欢迎留言交流哦!

    一、矩阵(matrix)

    1.1矩阵的创建:

        矩阵由指定的行(row)和列(column)构成,与高数中的矩阵相同。与之前提到的向量一样,矩阵只能储存同种类型的数据。

        matrix(  ):创建矩阵

    matrix(
      data  #要创建矩阵的数据,一般为向量
      nrow  #行数
      ncol  #列数
      byrow = TRUE  #若为TRUE,按行填充矩阵,若为FALSE,按列填充矩阵
      dimnames  #为矩阵个维度命名
    )

        接下来使用该函数来创建一个3*3的矩阵:

                  

         如图所示,这个由1~9组成的3*3矩阵,左边指定了行数未指定列数,右边指定了列数未指定行数,但所得矩阵相同,所以系统会自动识别并填充。上面两个矩阵都是按列填充矩阵,由于未设置byrow,所以采用默认值FALSE。下面来看一下当byrow为TRUE时,有何不同:

        可以看出,byrow为TRUE时,矩阵对数据进行了按行填充。

        接下来介绍dimnames函数,为矩阵的行与列命令,第一个向量为行名,第二个向量为列名。

    matrix(1:9,ncol = 3,byrow = TRUE,dimnames = list(c("x1","x2","x3"),c("y1","y2","y3")))

        得到下图所示矩阵,与上述矩阵相比,[1,]等变成了x1,y1。

        对于已经创建好的向量,可以使用dimnames(),rownames(),colnames()为矩阵进行命名:

        创建名为train1,train2的矩阵,train1用dimnames()进行命名,train2分别用rownames(),colnames()对行与列进行命名。

    train1 <- matrix(1:9,ncol = 3)
    train2 <- matrix(10:18,ncol = 3)
    dimnames(train1) <- list(c("x1","x2","x3"),c("y1","y2","y3"))
    (rownames(train2) <- c("迪迦","塞罗","特斯拉"))
    (colnames(train2) <- c("天王","地虎","二百五"))

                         

         所得结果如上图。同时dimnames(),rownames(),colnames()还能获取矩阵的名称,使用dimnames获取train2的名称(其他两个大家可以自己尝试一下昂),结果如下图:

     1.2访问矩阵的数据:

    matrixname[ridx,cidx]:访问matrixname矩阵中ridx行cidx列的数据:

        例如访问train1中的第二行第二列数据,为5。

         也可以使用负数,效果与向量中使用负数相同,即输出除某列或某行的其他所有数据。例如输出train2中除第二行的所有数据。

     1.3矩阵的运算:

    四则运算符
    运算符含义
    X + a矩阵X中所有值与标量a相加,还可以使用"-","*","/"运算符
    X + Y对矩阵X与矩阵Y求和,还能使用"-"求矩阵间的差
    X %*% Y求矩阵X与矩阵Y的积

    矩阵运算相关的函数
    函数名函数作用
    solve()从式子Y%*%X=Z中求解X,Y、Z为矩阵
    nrow()求行数
    ncol()求列数
    dim求维度
    dim <-设置对象的维度
    t()求矩阵的转置矩阵

        这里就不演示了,大家可以自己尝试,如果有疑问可以评论交流(一般中午、晚上会看的,欢迎评论哦)。

    二、数组(array)

    2.1数组的创建:

        数组与矩阵、向量不同,它可以存储不同数据类型的数据。而且数组是多维的,可以是2*3*4维的。创建数组使用array()函数:

    array(
      data #数据
      dim = length(data) #数组维数,若不设置,则为一维数组
      dimnames #维度的名称
    )

        接下来创建一个3*4的数组和一个2*3*2的数组作为示例:

    x <- array(1:12,dim = c(3,4))
    y <- array(1:12,dim = c(2,3,2))

               

         所得结果如上图,左图很容易看懂,不做过多解释。右图根据 y <- array(1:12,dim = c(2,3,2))所得,其中c(2,3,2)的最后一个数字是指右图中,,1和,,2,可以将其理解为层数,第一层由1,2,3,4,5,6构成,两行三列。

     2.2访问数组的数据:

        与向量相同,使用X[xidx,yidx,zidx...nidx]访问数组数据:

        访问y第二层中第二行第二列的数据,结果如下:

     三、数据框

    3.1数据框的创建:

        数据框类似于表格,例如上面矩阵运算中所展示的表格。可以使用data.frame()创建数据框

    data.frame(
      #以value或name = value的形式展现的数据值
    )

        可能有点看不懂,没有关系,我们来看几个例子就可以了。创建一个名为名人的数据框:

    名人 <-data.frame(美女 = c("西施","王昭君","貂蝉"),名将 = c("荆轲","要离","岳飞"))

                                  

    x <- 1:5
    y <- 6:10
    z <- 11:15
    d <- data.frame(x,y,z)

        运行结果如上图,数据框会将你输入的数据按列排布,做出一个类似表格的形式。在数据框中也可以使用rownames(),colnames()等函数,下面以rownames做一个示例: 

     rownames(d) <- c("three","four","two","five","one")

         数据框的数据访问于上述差不多,大家可以自己尝试一下。如果遇到疑问或者报错,可以评论交流哦!看完记得点赞~

    展开全文
  • 数据框--R语言

    千次阅读 2021-03-23 09:34:28
    1.数据框的创建 数据框是仅次于向量的最重要的数据类型对象,是R语言中最常处理的数据结构。如图所示的数据,由于数据有多种数据类型,无法将此数据集放入一个矩阵,在这种情况下,数据框是最佳选择。 1.1 data....

    1.数据框的创建

    数据框是仅次于向量的最重要的数据类型对象,是R语言中最常处理的数据结构。如图所示的数据,由于数据有多种数据类型,无法将此数据集放入一个矩阵,在这种情况下,数据框是最佳选择。
    在这里插入图片描述
    1)数据框组织数据的结构与矩阵类似。
    2)各列的数据类型可以不相同
    3)数据框的每一列是一个变量,每行是一个观测样本
    4)每列的长度必须相同

    1.1 data.frame函数

    函数功能:

    The function data.frame() creates data frames, tightly coupled collections of variables 
    which share many of the properties of matrices and of lists,
     used as the fundamental data structure by most of R's modeling software.
    

    函数data.frame()创建数据框,这些变量共享矩阵和列表的许多属性,被大多数R的建模软件用作基本数据结构。

    函数语法:

    data.frame(..., row.names = NULL, check.rows = FALSE,
               check.names = TRUE, fix.empty.names = TRUE,
               stringsAsFactors = default.stringsAsFactors())
    

    函数参数:

    ...	
    these arguments are of either the form value or tag = value. 
    Component names are created based on the tag (if present) or the deparsed argument itself.
    

    这些参数的形式为value或tag = value。 组件名称是基于标签(如果存在)或已解析的参数本身创建的。

    row.names	
    NULL or a single integer or character string specifying a column to be used as row names,
     or a character or integer vector giving the row names for the data frame.
    

    行名称:
    取值为空或者单个数字或者字符串向量

    check.rows	
    if TRUE then the rows are checked for consistency of length and names.
    

    行名称校验:
    逻辑值,取值为TRUE,则校验行名称与行的长度是否一致

    check.names	
    logical. If TRUE then the names of the variables in the data frame are checked to ensure 
    that they are syntactically valid variable names and are not duplicated. 
    If necessary they are adjusted (by make.names) so that they are.
    

    逻辑值,取值为TRUE,则检查数据框中的变量名称确保变量命名语法有效且变量名无重复。若有必要可以通过make.names参数进行调整

    fix.empty.names	
    logical indicating if arguments which are “unnamed” get an automatically constructed name or rather name "". 
    Needs to be set to FALSE even when check.names is false if "" names should be kept.
    

    逻辑值,表明未命名的参数是否自动命名还是命名为空。

    stringsAsFactors	
    logical: should character vectors be converted to factors? The ‘factory-fresh’ default is TRUE。
    

    字符串是否转为因子
    逻辑值:是否将字符串向量转化为因子,默认转化

    > # 1. 创建数据框
    > # 1.1 给出数据框中包含的向量
    > patientID <- seq(1,4)
    > age <- c(25,34,28,52)
    > diabetes <- c('Type1','Type2','Type1','Type1')
    > status <- c('Poor','Improved','Excellent','Poor')
    > # 1.2 创建数据框
    > patientdata <- data.frame(patientID,age,diabetes,status)
    > patientdata
      patientID age diabetes    status
    1         1  25    Type1      Poor
    2         2  34    Type2  Improved
    3         3  28    Type1 Excellent
    4         4  52    Type1      Poor
    

    增加行名称row.names

    > patientdata <- data.frame(patientID,age,diabetes,status,
    +                           row.names=c('病号1','病号2','病号3','病号4'))
    > patientdata
          patientID age diabetes    status
    病号1         1  25    Type1      Poor
    病号2         2  34    Type2  Improved
    病号3         3  28    Type1 Excellent
    病号4         4  52    Type1      Poor
    

    2. 数据框索引

    数据框的索引和矩阵类似,主要有下标索引、行或列索引、元素索引。此外,对于数据框,还可以使用$符号按名称索引列数据.

    2.1 行/列索引

    > # 2. 数据框索引
    > # 2.1  仅指定一个参数:返回指定列,返回值为数据框
    > # 数据框[索引];数据框['列名']
    > ww <- patientdata[3]
    > rr <- patientdata['diabetes']
    > ww
      diabetes
    1    Type1
    2    Type2
    3    Type1
    4    Type1
    > rr
      diabetes
    1    Type1
    2    Type2
    3    Type1
    4    Type1
    > class(ww)
    [1] "data.frame"
    > class(rr)
    [1] "data.frame"
    > #  2.2 指定两个参数,两个参数分别表示行、列索引
    > 
    > # 2.2.1 数据框[,列索引]:返回指定列,返回值为因子或者数值
    > 
    > qq <- patientdata[,1]   #索引第1列
    > ss <- patientdata[,'status']  #按列名索引
    > ff <- patientdata$diabetes   #按列名索引
    > qq
    [1] 1 2 3 4
    > ss
    [1] Poor      Improved  Excellent Poor     
    Levels: Excellent Improved Poor
    > ff
    [1] Type1 Type2 Type1 Type1
    Levels: Type1 Type2
    > class(qq)
    [1] "integer"
    > class(ss)
    [1] "factor"
    > class(ff)
    [1] "factor"
    > 
    > # 2.2.2 数据框[行索引,]:返回指定行,返回值为数据框
    > 
    > gg <- patientdata[1,]  #索引第1行
    > gg
      patientID age diabetes status
    1         1  25    Type1   Poor
    > class(gg)
    [1] "data.frame"
    > 
    > # 2.3 多行索引
    > jj <- patientdata[c(2,4),]  #索引第2,4行
    > jj
      patientID age diabetes   status
    2         2  34    Type2 Improved
    4         4  52    Type1     Poor
    > class(jj)
    [1] "data.frame"
    > 
    > # 2.4 多列索引
    > ll <- patientdata[,c(2,4)]
    > bb <- patientdata[,c('age','status')]
    > ll
      age    status
    1  25      Poor
    2  34  Improved
    3  28 Excellent
    4  52      Poor
    > bb
      age    status
    1  25      Poor
    2  34  Improved
    3  28 Excellent
    4  52      Poor
    > class(ll)
    [1] "data.frame"
    > class(bb)
    [1] "data.frame"
    > tt <- patientdata[c(1,3)]
    > tt
      patientID diabetes
    1         1    Type1
    2         2    Type2
    3         3    Type1
    4         4    Type1
    > class(tt)
    [1] "data.frame"
    
    

    2.2 元素索引

    > # 2.5 单个元素索引
    > aa <- patientdata[2,4]  #索引第2行第4列的元素
    > aa
    [1] Improved
    Levels: Excellent Improved Poor
    > class(aa)
    [1] "factor"
    > 
    > # 2.6 多个元素索引
    > mm <- patientdata[c(2,4),c(2,4)]
    > nn <- patientdata[c(2,4),c('age','status')]
    > mm
      age   status
    2  34 Improved
    4  52     Poor
    > nn
      age   status
    2  34 Improved
    4  52     Poor
    > class(mm)
    [1] "data.frame"
    > class(nn)
    [1] "data.frame"
    
    

    2.3 函数索引

    2.3.1 subset()函数

    函数功能:

    Return subsets of vectors, matrices or data frames 
    which meet conditions.
    

    返回满足条件的向量,矩阵或者数据框的子集

    函数语法:

    subset(x, subset, select, drop = FALSE, ...)
    

    函数参数:

    x	
    object to be subsetted.
    

    x: 要选取子集的对象

    默认选取全集

    > subset(patientdata)
      patientID age diabetes    status
    1         1  25    Type1      Poor
    2         2  34    Type2  Improved
    3         3  28    Type1 Excellent
    4         4  52    Type1      Poor
    
    subset	
    logical expression indicating elements or rows to keep: 
    missing values are taken as false.
    

    逻辑型,要选取元素或者行的表达式。缺失值默认为FALSE

    For data frames, the subset argument works on the rows.
    Note that subset will be evaluated in the data frame, 
    so columns can be referred to (by name) as variables 
    in the expression 
    

    对于数据框,参数 s u b s e t subset subset在行上起作用,可以使用列名称作为表达式中的变量

    > subset(patientdata,status=='Poor')
      patientID age diabetes status
    1         1  25    Type1   Poor
    4         4  52    Type1   Poor
    
    select	
    expression, indicating columns to select from a data frame.
    

    表达式,表明要从数据框中选取的列

    > subset(patientdata,status=='Poor',select=c('age','diabetes'))
      age diabetes
    1  25    Type1
    4  52    Type1
    
    drop	
    passed on to [ indexing operator.
    
    > # 2.7 subset函数索引
    > # 2.7.1  x: 数据框
    > subset(patientdata)  #默认选取全集
      patientID age diabetes    status
    1         1  25    Type1      Poor
    2         2  34    Type2  Improved
    3         3  28    Type1 Excellent
    4         4  52    Type1      Poor
    > # 2.7.2  subset:逻辑型,要选取元素或者行的表达式,缺失默认为FALSE
    > subset(patientdata,status=='Poor')  
      patientID age diabetes status
    1         1  25    Type1   Poor
    4         4  52    Type1   Poor
    > # 2.7.3 select :表达式,表明要从数据框中选取的列
    > subset(patientdata,status=='Poor',select=c('age','diabetes')) 
      age diabetes
    1  25    Type1
    4  52    Type1
    

    drop: 当前理解为是否删除原来的数据结构,默认不删除,保持原数据结构

    > a <- subset(patientdata,status=='Improved') 
    > a
      patientID age diabetes   status
    2         2  34    Type2 Improved
    > class(a)
    [1] "data.frame"
    > a <- subset(patientdata,status=='Improved',drop=T) 
    > a
    $patientID
    [1] 2
    
    $age
    [1] 34
    
    $diabetes
    [1] Type2
    Levels: Type1 Type2
    
    $status
    [1] Improved
    Levels: Excellent Improved Poor
    
    > class(a)
    [1] "list"
    
    
    
    

    3.数据框编辑

    数据框可以通过edit函数和fix函数手动修改,也可以通过rbind函数和cbind函数分别增加新的样本数据和新属性变量。需要注意点额是,rbind函数的自变量的宽度(列数)应该与源数据框的宽度相等,而cbind函数的自变量的高度(行数)应该与原数据框的高度相等,否则程序会报错。此外,names函数可以读取数据框的列名以进行修改操作

    3.1 edit()函数手动修改

    函数功能:

    Invoke a text editor on an R object.
    

    在R对象上调用文本编辑器

    函数语法:

    edit(name = NULL, file = "", title = NULL,
         editor = getOption("editor"), ...)
    

    函数参数:

    name	
    a named object that you want to edit. 
    If name is missing then the file specified by file is opened for editing.
    

    要编辑的R对象。

    file	
    a string naming the file to write the edited version to.
    

    编辑后的R对象要写入的文件名称

    title	
    a display name for the object being edited.
    

    标题: 被剪辑对象的显示名称

    在这里插入图片描述

    3.2 增加行/列

    3.2.1 增加行

    > # 3. 数据框的编辑
    > # 3.1 增加行
    > name <- c('zhangsan','wangwu','liuer')
    > age <- c(23,45,56)
    > birth_place <- c('tianjin','wuhan','hefei')
    > df <- data.frame(name,age,birth_place)
    > df
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    > df <- rbind(df,c('zhaosi',64,'liaoning'))
    Warning messages:
    1: In `[<-.factor`(`*tmp*`, ri, value = "zhaosi") : 因子层次有错,产生了NA
    2: In `[<-.factor`(`*tmp*`, ri, value = "liaoning") :
      因子层次有错,产生了NA
    > df
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    4     <NA>  64        <NA>
    > df <- rbind(df,c('zhangsan',64,'wuhan'))
    > df
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    4     <NA>  64        <NA>
    5 zhangsan  64       wuhan
    

    报错是因为: 数据框创建的过程中会自动将字符型向量转化为因子,转化为因子之后,若想要增加行的话,默认职能增加已有的层次,层次就是指向量已有的不重复取值。如:出生地birth_place的取值为:tianjin,wuhan,hefei;增加的也需要是这三个取值中的一个。若想要增加新的到原来的数据框中,在新建数据框的时候,需要指定属性:stringsAsFactors=FALSE(不转化为因子,默认为TRUE)
    在这里插入图片描述

    > name <- c('zhangsan','wangwu','liuer')
    > age <- c(23,45,56)
    > birth_place <- c('tianjin','wuhan','hefei')
    > df <- data.frame(name,age,birth_place,stringsAsFactors = F)
    > df
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    > df <- rbind(df,c('zhaosi',64,'liaoning'))
    > df
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    4   zhaosi  64    liaoning
    

    3.2.2 增加列

    > # 3.2 增加列
    > # 3.2.1 cbind()函数
    > data <- cbind(df,gender=c('male','female','female','male'))
    > data
          name age birth_place gender gender
    1 zhangsan  23     tianjin   male   male
    2   wangwu  45       wuhan female female
    3    liuer  56       hefei female female
    4   zhaosi  64    liaoning   male   male
    > # 3.2.2 data.frame
    > data <- data.frame(df,Occupation=c('worker','cooker','artist','teacher'))
    > data
          name age birth_place gender Occupation
    1 zhangsan  23     tianjin   male     worker
    2   wangwu  45       wuhan female     cooker
    3    liuer  56       hefei female     artist
    4   zhaosi  64    liaoning   male    teacher
    > # 3.2.3 直接新增
    > data['income'] <- c(12,16,50,10)
    > data
          name age birth_place gender Occupation income
    1 zhangsan  23     tianjin   male     worker     12
    2   wangwu  45       wuhan female     cooker     16
    3    liuer  56       hefei female     artist     50
    4   zhaosi  64    liaoning   male    teacher     10
    

    3.3 修改元素

    3.3.1 修改某一行元素

    新增的列默认依然会转化为因子,在进行修改操作时会报错。如下图所示,职业为后增加的属性,没有设置stringsAsFactors =F,当修改的变量职业(occupation)的取值在原水平中时,可以正常运行,但是当取值为男演员(actor)时会报错

    在这里插入图片描述

    需要在新增属性时设置stringsAsFactors =F,不转换成因子

    > # 3.2 增加列
    > # 3.2.1 cbind()函数
    > data <- cbind(df,gender=c('male','female','female','male'),stringsAsFactors =F)
    > data
          name age birth_place gender gender
    1 zhangsan  23     tianjin   male   male
    2   wangwu  45       wuhan female female
    3    liuer  56       hefei female female
    4   zhaosi  64    liaoning   male   male
    > # 3.2.2 data.frame
    > data <- data.frame(df,Occupation=c('worker','cooker','artist','teacher'),
    +                    stringsAsFactors =F )
    > data
          name age birth_place gender Occupation
    1 zhangsan  23     tianjin   male     worker
    2   wangwu  45       wuhan female     cooker
    3    liuer  56       hefei female     artist
    4   zhaosi  64    liaoning   male    teacher
    > # 3.2.3 直接新增
    > data['income'] <- c(12,16,50,10)
    > data
          name age birth_place gender Occupation income
    1 zhangsan  23     tianjin   male     worker     12
    2   wangwu  45       wuhan female     cooker     16
    3    liuer  56       hefei female     artist     50
    4   zhaosi  64    liaoning   male    teacher     10
    

    此时再进行修改某一行元素,则正常

    > data[2,] <- c('wanglaoqi',58,'shenyang','female','actor',100)
    > data
           name age birth_place gender Occupation income
    1  zhangsan  23     tianjin   male     worker     12
    2 wanglaoqi  58    shenyang female      actor    100
    3     liuer  56       hefei female     artist     50
    4    zhaosi  64    liaoning   male    teacher     10
    

    3.3.2 修改某一列元素

    > # 4.3 修改某一列元素
    > data[,'income'] <- c(6,50,100,10)
    > data
           name age birth_place gender Occupation income
    1  zhangsan  23     tianjin   male     worker      6
    2 wanglaoqi  58    shenyang female      actor     50
    3     liuer  56       hefei female     artist    100
    4    zhaosi  64    liaoning   male    teacher     10
    

    3.3.3 修改某个元素

    > data[2,3] <- 'jilin'
    > data
           name age birth_place gender Occupation income
    1  zhangsan  23     tianjin   male     worker      6
    2 wanglaoqi  58       jilin female      actor     50
    3     liuer  56       hefei female     artist    100
    4    zhaosi  64    liaoning   male    teacher     10
    

    3.4 删除元素

    3.4.1 删除单行元素

    > # 5.删除行/列
    > # 5.1 删除单行
    > data
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    > data[-2,]  #删除第2行
          name age birth_place
    1 zhangsan  23     tianjin
    3    liuer  56       hefei
    

    3.4.2 删除单列元素

    > # 5.2 删除单列
    > # 方式一: 
    > data[-2]
          name birth_place
    1 zhangsan     tianjin
    2   wangwu       wuhan
    3    liuer       hefei
    > 
    > # 方式二:
    > data[,-2]
          name birth_place
    1 zhangsan     tianjin
    2   wangwu       wuhan
    3    liuer       hefei
    

    3.4.3 删除多行元素

    > # 5.3 删除多行
    > data
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    > a <- data[-c(2,3),]  #删除第2,3行
    > a
          name age birth_place
    1 zhangsan  23     tianjin
    > class(a)
    [1] "data.frame"
    > b <- data[c(-2,-3),]    #删除第2,3行
    > b
          name age birth_place
    1 zhangsan  23     tianjin
    > class(b)
    [1] "data.frame"
    

    3.4.4 删除多列元素

    > # 5.4 删除多列
    > data
          name age birth_place
    1 zhangsan  23     tianjin
    2   wangwu  45       wuhan
    3    liuer  56       hefei
    > # 方式一
    > c <- data[,-c(2,3)]  #删除第2,3列
    > c
    [1] "zhangsan" "wangwu"   "liuer"   
    > class(c)
    [1] "character"
    > # 方式二:
    > d <- data[,c(-2,-3)]  #删除第2,3列
    > d
    [1] "zhangsan" "wangwu"   "liuer"   
    > class(d)
    [1] "character"
    > # 方式三:
    > f <- data[c(-2,-3)]   #删除第2,3列
    > f
          name
    1 zhangsan
    2   wangwu
    3    liuer
    > class(f)
    [1] "data.frame"
    

    在删除完元素只剩下一列时,使用前两种方式的数据结构最终会发生改变,此时可以增加参数drop=FALSE,即:不丢失原有数据结构

    > # 方式一
    > c <- data[,-c(2,3),drop=F]  #删除第2,3列
    > c
          name
    1 zhangsan
    2   wangwu
    3    liuer
    > class(c)
    [1] "data.frame"
    > # 方式二:
    > d <- data[,c(-2,-3),drop=F]  #删除第2,3列
    > d
          name
    1 zhangsan
    2   wangwu
    3    liuer
    > class(d)
    [1] "data.frame"
    
    展开全文
  • python函数命名规则

    千次阅读 2021-04-27 01:25:48
    Python 编码规范遵循良好的编码风格,可以有效的提高代码的可读性,降低出错几......命名约定 Python 库的命名约定有点混乱,所以我们将永远不能使之变得完全一致,不过还是有 公认的命名规范的.新的模块和包(包...
  • R语言修改dataframe数据列的名称:使用dplyr包的rename函数修改列名、使用colnmaes函数修改列名、在数据筛选的时候重命名列名
  • 介绍一下R中数据框的定义与一些基本操作,有误欢迎指正
  • (2)df第3、第4进行切片,切片后得到一个新的数据框记为df1,并df1利用自身的方法转换为Numpy数组Nt。(3)基于df第2,构造一个逻辑数组TF,即满足交易日期小于等于2017-01-16且大于等于2017-01-05为真...
  • 文章目录创建矩阵按行、按填充矩阵命名矩阵下标使用转换数据框为矩阵 创建矩阵 代码: cells <- c(1, 26, 24, 68) rnames <- c("R1", "R2") cnames <- c("C1", "C2") mymatrix <- matrix(data = ...
  • JavaScript常见变量和函数命名示例

    万次阅读 2020-07-21 15:16:17
    JavaScript作为前端开发从业人员必须...通过按JavaScript的数据类型分类着手、细到一个函数的参数命名,并提供众多可选方案,并尽量给出其适用范围和利弊。 JavaScript常见变量和函数命名示例思维导图 需要注意的是由
  • R中数据框的创建

    万次阅读 2017-06-27 09:13:21
    在R语言中,很多数据分析算法函数的输入都是数据框对象。而且,在使用读取excel/txt等格式数据集的函数时,也是以数据框对象输出的。类似于list,数据框也可以由不同的向量作为来合成,并且不同间的元素可以是...
  • R语言中数据框变量的重命名

    千次阅读 2020-06-03 02:30:18
    以编程的方式,reshape包中有一个rename()函数 > install.packages("reshape") > library(reshape) > mydata<-rename(mydata,c(x1="x3")) > mydata x3 x2 sum mean 1 1 5 6 3 2 2 6 8 4 3 3 7 10 5...
  • Python数据框排序

    千次阅读 2018-11-26 10:20:19
    使用Pandas对数据进行筛选和排序   转自:http://bluewhale.cc/2016-08-06/use-pandas-filter-and-sort.html   筛选和排序是Excel中使用频率最多的功能,通过这个功能可以很方便的对数据表中的数据使用指定的...
  • R数据框基本操作

    千次阅读 2019-02-27 20:11:28
    数据框(data.frame)是最常用的数据结构,用于存储二维表(即关系表)的数据,每一存储的数据类型必须相同,不同数据的数据类型可以相同,也可以不同,但是每的行数(长度)必须相同。数据框的每列都有唯一的...
  • R语言不能给数据框重命名

    千次阅读 2016-09-21 19:17:09
    R语言不能给数据框重命名
  • python 欢迎使用Markdown编辑器 ...我们Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客: 全新的界面设计 ,将会带...
  • 数据类型简介 数值型numeric 例:1.4 2 3 字符型character 例:"a" 'n' '1' 'TRUE' 'FALSE' 只要带有引号(单双均可) 逻辑型logical(必须大写) TRUE T FALSE F NA #比较运算的结果是逻辑值 >,<,...
  • R语言提取数据框data.frame的行名和列名

    万次阅读 多人点赞 2019-05-03 11:23:12
    R语言中很多数据是data.frame的形式,在数据矩阵的基础上,上边加一行表示各的列名,左侧加一行代表各行的行名,如果想要获取行名和列名的内容,只需用如下两个函数,假设数据变量为data,则 rownames(data) # ...
  • R语言编写列表与数据框

    千次阅读 2019-12-08 21:31:58
    @[R语言构造列表与数据库) 列表 一、列表 列表的构造 列表“list”是一种比较的特别的对象集合,不同的序号对于不同的元素,当然元素的也可以是不同类型的,那么我们用R语言先简单来构造一个列表。 eg: “约翰的...
  • 在PySpark数据框中添加新的5种方法

    千次阅读 2020-04-28 16:44:28
    每天都在生成太多数据。 尽管有时我们可以使用Rapids或Parallelization等工具来管理大数据,但如果您使用的是TB级数据,Spark是一个很好的工具。 尽管这篇文章解释了如何使用RDD和基本的Dataframe操作,但是我在使用...
  • R语言入门——数据框和列表

    千次阅读 2017-05-07 21:25:10
    由于不同的可以包含不同模式(数值型、字符型等)的数据,数据框的概念较矩阵来说更 为一般。它与你通常在SAS、SPSS和Stata中看到的数据集类似。数据框将是你在R中最常处理的 数据结构。 表2-1所示的病例数据集...
  • 用于存储数值型、字符型、逻辑型数据的一维数组。 建立向量 枚举 A<-c(1,2,3,4,5) 数值序列 A<-seq(from=1,to=10,by=2) # 以2为步长,从1起始到10结束 同值重复 A<-rep("HUAWEI",times=5) # "HUAWEI"重复5...
  • R语言Data Frame数据框常用操作

    千次阅读 2020-12-19 18:52:39
    Data Frame一般被翻译为数据框,感觉就像是R中的表,由行和组成,与Matrix不同的是,每个可以是不同的数据类型,而Matrix是必须相同的。Data Frame每一有列名,每一行也可以指定行名。如果不指定行名,那么...
  • R语言笔记三:矩阵、数组、列表和数据框

    千次阅读 多人点赞 2020-07-09 21:27:44
    矩阵是二维的,需要有行和。向量是一维的。        在R软件中,矩阵是有维数的向量,这里的矩阵元素可以是数值型、字符型或者逻辑型,但是每个元素必须拥有相同的模式,这个和...
  • 一、 数据框的构成 数据框是一种矩阵形式的数据,但是数据框中的各可以是不同类型的数据。 数据框每一是一个变量,每一行是一...(2)给数据框列命名 Y = data.frame('身高' = x1,'体重' = x2) print(Y) 二、数
  • wps表格函数函数简单使用

    千次阅读 2020-12-28 23:28:49
    什么是函数WPS表格 函数即是预先定义,执行计算、分析等处理数据任务的特殊公式。以常用的求和函数SUM 为例,它的语法是“SUM( 数值 1, 数值 2,......)”。其中“SUM”称为函数名称,一个函数只有唯一的一个名称,它...
  • R语言基础——数据框

    千次阅读 2020-03-14 09:06:37
    R语言基础——数据框 数据框是一种表格式的数据结构。数据框旨在模拟数据集,...列表中的元素是向量,这些向量构成数据框,每一必须具有相同的长度,所以数据框是矩形结构,而且数据框必须命名。 矩阵与数...
  • 进行数据分析的第一步是先拿到数据,本文就简单描述一下R语言的各种数据集——向量、矩阵、数组、数据框和列表的创建及使用。向量向量是用于存储数值型、字符型或逻辑型数据的一维数组。执行组合功能的函数c
  • R语言—定义数据框的列名

    万次阅读 多人点赞 2017-12-15 16:47:37
    1.在定义数据框时,定义列名: ...2.修改数据框的名字  如果希望修改数据框中的列名,可以使用name函数进行修改  例如:names(df)   3.修改数据框中行名修改  数据框中的行也是可以定义修
  • #以数字索引取数据框中的连续多个变量 > df[1:2] name age 1 Amy 10 2 Lily 20 3 Tom 30 4 Sam 40 5 David 10 6 Anna 20 #获取数据框中的联列表 #其中的数值相当于select age,money,count(1)...group by age,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,970
精华内容 79,588
热门标签
关键字:

对数据框列命名函数是