R Language
data.table

소개

통사론

• DT[i, j, by]
  # DT [where, select | update | do, by]
• DT[...][...]
  # 연쇄
• ################# Shortcuts, special functions and special symbols inside DT[...]
• . ()
  list ()를 대체하는 몇개의 인수로 #
• J ()
  #에서 i, list ()를 대체합니다.
• : =
  # in j, 열을 추가하거나 수정하는 데 사용되는 함수
• .엔
  # in i, 전체 행 수
  # in j, 그룹의 행 수
• .나는
  # in j, 테이블의 행 번호 벡터 (i로 필터링 됨)
• .SD
  # in j, 데이터의 현재 하위 집합
  .SDcols 인수로 # 선택됨
• .GRP
  # in j, 데이터의 하위 집합의 현재 색인
• .으로
  # in j, 데이터의 현재 하위 집합에 대한 값 목록
• V1, V2, ...
  # j에서 생성 된 이름이없는 열의 기본 이름
• ################# Joins inside DT[...]
• DT1 [DT2, on, j]
  # 두 테이블 조인
• 나는.*
  join 후에 DT2의 컬럼에 특별한 접두사가 붙는다.
• by = .EACHI
  # 특별 옵션은 조인과 함께 사용할 수 있습니다.
• DT1 [! DT2, on, j]
  # 두 개의 테이블에 대한 앤티 - 조인
• DT1 [DT2, on, roll, j]
  # 두 테이블 조인, on =
• ################# Reshaping, stacking and splitting
• 용융 (DT, id.vars, measure.vars)
  # 긴 형식으로 변환
  # 여러 열에 대해서는 measure.vars = patterns (...)를 사용하십시오.
• dcast (DT, 공식)
  # 와이드 형식으로 변환
• rbind (DT1, DT2, ...)
  # stack 열거 된 data.tables
• rbindlist (DT_list, idcol)
  # 데이터 테이블 목록을 쌓아 라.
• 스플릿 (DT, by)
  # data.table을 목록으로 나눕니다.
• ################# Some other functions specialized for data.tables
• 포랩
  # 중복 조인
• 병합하다
  # 두 테이블을 결합하는 또 다른 방법
• 세트
  # 열을 추가하거나 수정하는 다른 방법
• fintersect, fsetdiff, funion, fsetequal, 고유, 중복, anyDuplicated
  # 행을 요소로 한 set-theory 연산
• 고유 N
  # 고유 한 행의 수
• rowidv (DT, cols)
  # cols에 의해 결정된 각 그룹 내의 행 ID (1 ~ N)
• rleidv (DT, cols)
  # cols의 실행으로 결정된 각 그룹 내의 그룹 ID (1에서 .GRP)
• shift (DT, n, type = c ( "lag", "lead"))
  # 모든 열에 시프트 연산자를 적용합니다.
• setorder, setcolorder, setnames, setkey, setindex, setattr
  # 참조로 속성 및 순서 수정

비고

# install from CRAN
install.packages("data.table")       

# or install development version 
install.packages("data.table", type = "source", repos = "http://Rdatatable.github.io/data.table")

# and to revert from devel to CRAN, the current version must first be removed
remove.packages("data.table")
install.packages("data.table")

data.table 만들기

data.table은 base R의 data.frame 클래스의 향상된 버전입니다. 따라서 class() 속성의 vector는 "data.table" "data.frame" 에서 작동하는 함수도 data.table로 작업하십시오. data.table을 생성,로드 또는 강요하는 많은 방법이 있습니다.

짓다

data.table 패키지를 설치하고 활성화하는 것을 잊지 마십시오.

library(data.table)

같은 이름의 생성자가 있습니다.

DT <- data.table(
  x = letters[1:5], 
  y = 1:5, 
  z = (1:5) > 3
)
#    x y     z
# 1: a 1 FALSE
# 2: b 2 FALSE
# 3: c 3 FALSE
# 4: d 4  TRUE
# 5: e 5  TRUE

달리 data.frame , data.table 문자열을 요인으로 강요하지 않습니다

sapply(DT, class)
#               x           y           z 
#     "character"   "integer"   "logical" 

읽기

우리는 텍스트 파일에서 읽을 수 있습니다 :

dt <- fread("my_file.csv")

read.csv 와 달리 fread 는 문자열을 인수가 아닌 문자열로 읽습니다.

data.frame 수정

효율성을 위해 data.table은 data.frame 또는 list를 변경하여 (사본을 만들거나 메모리 위치를 변경하지 않고) 내부에 data.table을 만들 수 있습니다.

# example data.frame
DF <- data.frame(x = letters[1:5], y = 1:5, z = (1:5) > 3)
# modification
setDT(DF)

객체 DF 가 제자리에서 수정되었으므로 결과를 <- 할당하지 않습니다. data.frame의 클래스 속성은 유지됩니다.

sapply(DF, class)
#         x         y         z 
#  "factor" "integer" "logical" 

객체를 data.table로 강제 변형합니다.

당신이있는 경우 list , data.frame , 또는 data.table , 당신은 사용해야 setDT A를 변환하는 기능을 data.table 이 사본을 (이 만드는 대신 참조로 변환을 수행하기 때문에 as.data.table 않습니다). 대형 데이터 세트로 작업하는 경우 이는 중요합니다.

(예 : 매트릭스로) 또 다른 R 객체가있는 경우 사용해야합니다 as.data.table A와 그것을 강요 data.table .

mat <- matrix(0, ncol = 10, nrow = 10)

DT <- as.data.table(mat)
# or
DT <- data.table(mat)

열 추가 및 수정

DT[where, select|update|do, by] 구문은 data.table의 열을 사용하여 작업하는 데 사용됩니다.

• "where"부분이 i 인수입니다.
• "select | update | do"부분은 j 인수입니다.

이 두 인수는 일반적으로 이름 대신 위치에 의해 전달됩니다.

아래 예제 데이터는

mtcars = data.table(mtcars, keep.rownames = TRUE)

전체 열 편집

j 안에 := 연산자를 사용하여 새 열을 지정하십시오.

mtcars[, mpg_sq := mpg^2]

NULL 로 설정하여 열 제거 :

mtcars[, mpg_sq := NULL]

:= 연산자의 다 변수 형식을 사용하여 여러 열을 추가합니다.

mtcars[, `:=`(mpg_sq = mpg^2, wt_sqrt = sqrt(wt))]
# or 
mtcars[, c("mpg_sq", "wt_sqrt") := .(mpg^2, sqrt(wt))]

열이 종속되어 있고 순서대로 정의해야하는 경우 한 가지 방법은 다음과 같습니다.

mtcars[, c("mpg_sq", "mpg2_hp") := .(temp1 <- mpg^2, temp1/hp)]

.() 구문은 LHS := RHS 의 오른쪽이 열 목록 일 때 사용됩니다.

동적으로 결정된 열 이름의 경우 괄호를 사용하십시오.

vn = "mpg_sq"
mtcars[, (vn) := mpg^2]

거의 필요하지는 않지만 열을 set 으로 수정할 수도 있습니다.

set(mtcars, j = "hp_over_wt", v = mtcars$hp/mtcars$wt)

열의 하위 집합 편집

i 인수를 사용하여 "어디에서"편집해야하는 행을 부분 집합으로 만드십시오.

mtcars[1:3, newvar := "Hello"]
# or
set(mtcars, j = "newvar", i = 1:3, v = "Hello")  

data.frame에서와 같이 행 번호 나 논리 테스트를 사용하여 부분 집합을 만들 수 있습니다. i 에서 "조인"을 사용할 수도 있지만, 더 복잡한 작업은 다른 예에서 다룹니다.

열 속성 수정하기

levels<- 또는 names<- 과 같은 속성을 편집하는 함수는 실제로 오브젝트를 수정 된 사본으로 대체합니다. data.table의 한 열에서만 사용 되더라도 전체 객체가 복사되고 대체됩니다.

복사본이없는 객체를 수정하려면 setnames 를 사용하여 data.table 또는 data.frame 및 setattr 의 열 이름을 변경하여 객체의 속성을 변경합니다.

# Print a message to the console whenever the data.table is copied
tracemem(mtcars)
mtcars[, cyl2 := factor(cyl)]

# Neither of these statements copy the data.table
setnames(mtcars, old = "cyl2", new = "cyl_fac")
setattr(mtcars$cyl_fac, "levels", c("four", "six", "eight"))

# Each of these statements copies the data.table
names(mtcars)[names(mtcars) == "cyl_fac"] <- "cf"
levels(mtcars$cf) <- c("IV", "VI", "VIII")

이 변경 사항은 참조로 작성되므로 전역 적 입니다. 한 환경 내에서 변경하면 모든 환경의 개체에 영향을줍니다.

# This function also changes the levels in the global environment
edit_levels <- function(x) setattr(x, "levels", c("low", "med", "high"))
edit_levels(mtcars$cyl_factor)

data.table의 특수 기호

.SD

.SD 의 서브 세트를 의미 data.table 에 사용되는 모든 열을 제외한 각 그룹 용 by .

.SD 함께 lapply A의기로 여러 열 어떤 함수를 적용하는 데 사용될 수 data.table

동일한 기본 제공 데이터 세트 인 mtcars 를 계속 사용합니다.

mtcars = data.table(mtcars) # Let's not include rownames to keep things simpler

실린더 수 , cyl 의한 데이터 집합의 모든 열의 평균 :

mtcars[ , lapply(.SD, mean), by = cyl]

#   cyl      mpg     disp        hp     drat       wt     qsec        vs        am     gear     carb
#1:   6 19.74286 183.3143 122.28571 3.585714 3.117143 17.97714 0.5714286 0.4285714 3.857143 3.428571
#2:   4 26.66364 105.1364  82.63636 4.070909 2.285727 19.13727 0.9090909 0.7272727 4.090909 1.545455
#3:   8 15.10000 353.1000 209.21429 3.229286 3.999214 16.77214 0.0000000 0.1428571 3.285714 3.500000

cyl 외에도 데이터 세트에는 vs , am , gear 및 carb 와 같은 다른 카테고리 칼럼이 있습니다. 이 컬럼들의 mean 을 취하는 것은 실제로 의미가 없습니다. 그렇다면이 열을 제외 시키십시오. 이것은 .SDcols 가 그림에 나오는 곳입니다.

.SDcols

.SDcols 의 열을 지정 data.table 에 포함 .SD .

기어의 수에 의한 데이터 세트의 모든 열 (연속 열)의 평균 gear 및 실린더 번호 cyl 하여 배치 gear 와 cyl :

# All the continuous variables in the dataset
cols_chosen <- c("mpg", "disp", "hp", "drat", "wt", "qsec")

mtcars[order(gear, cyl), lapply(.SD, mean), by = .(gear, cyl), .SDcols = cols_chosen]

#   gear cyl    mpg     disp       hp     drat       wt    qsec
#1:    3   4 21.500 120.1000  97.0000 3.700000 2.465000 20.0100
#2:    3   6 19.750 241.5000 107.5000 2.920000 3.337500 19.8300
#3:    3   8 15.050 357.6167 194.1667 3.120833 4.104083 17.1425
#4:    4   4 26.925 102.6250  76.0000 4.110000 2.378125 19.6125
#5:    4   6 19.750 163.8000 116.5000 3.910000 3.093750 17.6700
#6:    5   4 28.200 107.7000 102.0000 4.100000 1.826500 16.8000
#7:    5   6 19.700 145.0000 175.0000 3.620000 2.770000 15.5000
#8:    5   8 15.400 326.0000 299.5000 3.880000 3.370000 14.5500

우리는 그룹별로 mean 을 계산하고 싶지 않을 수도 있습니다. 데이터 세트의 모든 자동차에 대한 평균을 계산하기 위해 by 변수를 지정하지 않았습니다.

mtcars[ , lapply(.SD, mean), .SDcols = cols_chosen] 

#        mpg     disp       hp     drat      wt     qsec
#1: 20.09062 230.7219 146.6875 3.596563 3.21725 17.84875

노트 :

• 미리 cols_chosen 을 정의 할 필요는 없습니다. .SDcols 는 직접 열 이름을 사용할 수 있습니다.
• .SDcols 는 .SDcols 의 벡터를 직접 가져올 수도 있습니다. 위의 예에서 이것은 mtcars[ , lapply(.SD, mean), .SDcols = c(1,3:7)]

.엔

.N 은 그룹의 행 수를 .N 입니다.

iris[, .(count=.N), by=Species]

#      Species count
#1:     setosa    50
#2: versicolor    50
#3:  virginica    50

data.frame 및 data.table과 호환되는 코드 작성

부분 집합 구문의 차이점

data.table 또한 R에서 사용 가능한 여러 개의 차원 데이터 구조 중 하나이다 data.frame , matrix 및 (2D) array . 이 모든 클래스는 부분 집합에 매우 유사하지만 동일하지 않은 구문 인 A[rows, cols] 스키마를 사용합니다.

(A)에 저장된 다음 데이터 고려 matrix 하는 data.frame 및 data.table :

ma <- matrix(rnorm(12), nrow=4, dimnames=list(letters[1:4], c('X', 'Y', 'Z')))
df <- as.data.frame(ma)
dt <- as.data.table(ma)

ma[2:3]  #---> returns the 2nd and 3rd items, as if 'ma' were a vector (because it is!)
df[2:3]  #---> returns the 2nd and 3rd columns
dt[2:3]  #---> returns the 2nd and 3rd rows!

반환 될 내용을 확실히 알고 싶다면 명시 적으로 하는 것이 좋습니다.

특정 행 을 가져 오려면 범위 뒤에 쉼표를 추가하십시오.

ma[2:3, ]  # \
df[2:3, ]  #  }---> returns the 2nd and 3rd rows
dt[2:3, ]  # /

그러나 열 을 부분 집합으로 만들려면 일부 경우가 다르게 해석됩니다. 세 변수 모두 변수에 저장 되지 않은 정수 또는 문자 인덱스를 사용하여 같은 방식으로 부분 집합을 만들 수 있습니다.

ma[, 2:3]          #  \
df[, 2:3]          #   \
dt[, 2:3]          #    }---> returns the 2nd and 3rd columns
ma[, c("Y", "Z")]  #   /
df[, c("Y", "Z")]  #  /
dt[, c("Y", "Z")]  # /

그러나 인용되지 않은 변수 이름은 다릅니다.

mycols <- 2:3
ma[, mycols]                # \
df[, mycols]                #  }---> returns the 2nd and 3rd columns
dt[, mycols, with = FALSE]  # /

dt[, mycols]                # ---> Raises an error

마지막 경우에는 mycols 가 열 이름으로 평가됩니다. dt 가 mycols 라는 열을 찾을 수 없기 때문에 오류가 발생합니다.

참고 : data.table 패키지 data.table 버전의 경우이 동작이 약간 다릅니다. 열 인덱스의 모든 항목은 dt 를 환경으로 사용하여 평가되었습니다. 따라서 dt[, 2:3] 와 dt[, mycols] 는 벡터 2:3 반환합니다. mycols 변수가 상위 환경에 존재하기 때문에 두 번째 경우에는 오류가 발생하지 않습니다.

data.frame 및 data.table과의 호환성 유지 전략

함께 작동하도록 보장 코드를 작성하는 많은 이유가 있습니다 data.frame 및 data.table . 어쩌면 data.frame 을 사용해야 할 수도 있습니다. 그렇지 않으면 사용 방법을 모르는 코드를 공유해야 할 수도 있습니다. 따라서 편의를 위해 다음을 달성하기위한 몇 가지 주요 전략이 있습니다.

1. 두 클래스 모두에 대해 동일한 동작을하는 구문을 사용하십시오.
2. 가장 짧은 구문과 동일한 기능을하는 공통 함수를 사용하십시오.
3. 강제 data.table 으로 행동 data.frame (특정 메서드 호출 .: 전 print.data.frame ).
4. 그들이 궁극적으로 list 취급하십시오.
5. 무엇이든하기 전에 테이블을 data.frame 변환하십시오 (거대한 테이블 인 경우 나쁜 생각).
6. 종속성이 문제가되지 않는다면 표를 data.table 변환하십시오.

부분 행 그것의 단순한, 그냥 콤마로 [, ] 선택기를 사용 하십시오 :

A[1:10, ]
A[A$var > 17, ]  # A[var > 17, ] just works for data.table

하위 집합 열입니다. 단일 열이 필요하면 $ 또는 [[ ]] 선택기를 사용하십시오.

A$var
colname <- 'var'
A[[colname]]
A[[1]]

균일 한 방법으로 둘 이상의 열을 가져 오려면 비트를 표시해야합니다.

B <- `[.data.frame`(A, 2:4)

# We can give it a better name
select <- `[.data.frame`
B <- select(A, 2:4)
C <- select(A, c('foo', 'bar'))

하위 집합 '색인'행. 하지만 data.frame 있다 row.names , data.table 독특한이 key 기능을. 가장 좋은 방법은 row.names 완전히 피하고 가능한 경우 data.table 의 경우 기존 최적화를 이용하는 것입니다.

B <- A[A$var != 0, ]
# or...
B <- with(A, A[var != 0, ])  # data.table will silently index A by var before subsetting

stuff <- c('a', 'c', 'f')
C <- A[match(stuff, A$name), ]  # really worse than: setkey(A); A[stuff, ]

1 열 테이블을 가져 와서 행을 벡터로 가져옵니다. 이것들은 우리가 지금까지 본 것들로 쉽습니다 :

B <- select(A, 2)    #---> a table with just the second column
C <- unlist(A[1, ])  #---> the first row as a vector (coerced if necessary)

data.table에 키 설정하기

예, 1.9.6 이전으로 설정해야합니다.

과거에는 (1.9.6 이전) 테이블에 대한 키로 열을 설정하여 data.table 속도가 빨라 data.table , 특히 큰 테이블의 경우 더욱 그렇습니다. [검색 속도가 544 배 향상된 2015 년 9 월 버전의 intro vignette 5 페이지를 참조하십시오.] 테이블을 설정할 때이 설정 키를 'setkey'또는 'key ='열로 사용하는 오래된 코드를 발견 할 수 있습니다.

library(data.table)
DT <- data.table(
  x = letters[1:5], 
  y = 5:1, 
  z = (1:5) > 3
)

#> DT
#   x y     z
#1: a 5 FALSE
#2: b 4 FALSE
#3: c 3 FALSE
#4: d 2  TRUE
#5: e 1  TRUE

setkey 명령으로 키를 설정하십시오. 여러 열이있는 키를 가질 수 있습니다.

setkey(DT, y)

테이블에서 테이블 키 확인 ()

tables()

> tables()
     NAME NROW NCOL MB COLS  KEY
[1,] DT      5    3  1 x,y,z y  
Total: 1MB

데이터가 다시 정렬됩니다.

#> DT
#   x y     z
#1: e 1  TRUE
#2: d 2  TRUE
#3: c 3 FALSE
#4: b 4 FALSE
#5: a 5 FALSE

이제는 불필요합니다.

v1.9.6 이전에는 특정 작업, 특히 테이블 조인을위한 키를 설정해야했습니다. data.table의 개발자는 속도가 빨라졌으며 키에 대한 의존성을 대체 할 수있는 "on=" 기능을 도입했습니다. 자세한 내용은 SO 대답을 참조하십시오 .

2017 년 1 월 개발자는 "on"구문을 설명하고 빠른 색인 생성을 위해 다른 열을 식별 할 수 있도록 보조 색인 주위 에 비 네트를 작성했습니다.

보조 색인 만들기?

key와 비슷한 방식으로, 당신은 setindex(DT, key.col) 또는 setindexv(DT, "key.col.string") 설정할 수 있습니다. DT는 여러분의 data.table입니다. setindex(DT, NULL) 모든 인덱스를 제거하십시오.

indices(DT) 보조 색인을보십시오.

왜 2 차 지표입니까?

이 옵션 은 키와 달리 테이블을 정렬하지 않지만 "on"구문을 사용하여 빠른 색인을 허용합니다. 하나의 키만있을 수 있지만 여러 개의 2 차 인덱스를 사용할 수 있습니다. 그러면 테이블을 다시 키워야하고 저장해야합니다. 하위 집합하려는 열을 변경하면 하위 집합의 속도가 빨라집니다.

위의 예제에서 y는 테이블 DT의 ​​키입니다.

DT
# x y     z
# 1: e 1  TRUE
# 2: d 2  TRUE
# 3: c 3 FALSE
# 4: b 4 FALSE
# 5: a 5 FALSE

# Let us set x as index 
setindex(DT, x)

# Use indices to see what has been set
indices(DT)
# [1] "x"

# fast subset using index and not keyed column
DT["c", on ="x"]
#x y     z
#1: c 3 FALSE

# old way would have been rekeying DT from y to x, doing subset and 
# perhaps keying back to y (now we save two sorts)
# This is a toy example above but would have been more valuable with big data sets