R Language
विवरण सारणी

परिचय

वाक्य - विन्यास

• DT[i, j, by]
  # डीटी [जहां, चयन करें | अपडेट करें | क्या करें, द्वारा]
• DT[...][...]
  # पीछा करना
• ################# Shortcuts, special functions and special symbols inside DT[...]
• । ()
  # कई तर्कों में, सूची की जगह ()
• जे()
  # i में, सूची की जगह ()
• : =
  # जम्मू में, एक फ़ंक्शन कॉलम जोड़ने या संशोधित करने के लिए उपयोग किया जाता है
• .N
  # में, पंक्तियों की कुल संख्या
  # जम्मू में, एक समूह में पंक्तियों की संख्या
• ।मैं
  # j में, तालिका में पंक्ति संख्याओं का वेक्टर (i द्वारा फ़िल्टर किया गया)
• .SD
  # जम्मू में, डेटा का वर्तमान सबसेट
  # .SDcols तर्क द्वारा चयनित
• .GRP
  # जम्मू में, डेटा के सबसेट का वर्तमान सूचकांक
• ।द्वारा
  # j में, डेटा के वर्तमान सबसेट के लिए मानों की सूची
• V1, V2, ...
  j में बनाए गए अनाम स्तंभों के लिए # डिफ़ॉल्ट नाम
• ################# Joins inside DT[...]
• DT1 [DT2, on, j]
  # दो तालिकाओं में शामिल हों
• मैं।*
  # जुड़ने के बाद DT2 के कॉलम पर विशेष उपसर्ग
• = .EACHI द्वारा
  # विशेष विकल्प केवल एक जॉइन के साथ उपलब्ध है
• DT1 [! DT2, ऑन, जे]
  # विरोधी दो तालिकाओं
• DT1 [DT2, ऑन, रोल, j]
  # अंतिम टेबल पर = पर रोलिंग करते हुए, दो टेबल से जुड़ें
• ################# Reshaping, stacking and splitting
• पिघल (DT, id.vars, उपाय। हार)
  # लंबे प्रारूप में बदलना
  # कई कॉलमों के लिए, मेज़ =vars = प्रतिमान (...) का उपयोग करें
• dcast (DT, सूत्र)
  # विस्तृत प्रारूप में बदलना
• rbind (DT1, DT2, ...)
  # स्टैक प्रगणित data.tables
• rbindlist (DT_list, idcol)
  # data.tables की सूची स्टैक करें
• विभाजन (डीटी, द्वारा)
  # एक सूची में एक data.table विभाजित
• ################# Some other functions specialized for data.tables
• foverlaps
  # ओवरलैप जुड़ता है
• मर्ज
  # दो तालिकाओं में शामिल होने का दूसरा तरीका
• सेट
  # कॉलम जोड़ने या संशोधित करने का दूसरा तरीका
• फ़ाइनट्रेक्ट, फ़सेटडिफ, फन, फ़ेसटेसिपल, यूनिक, डुप्लिकेटेड, anyDuplicated
  # सेट-सिद्धांत संचालन पंक्तियों के साथ तत्वों के रूप में
• uniqueN
  # अलग-अलग पंक्तियों की संख्या
• पंक्तिदेव (DT, cols)
  # पंक्ति ID (1 से .N) कोल्स द्वारा निर्धारित प्रत्येक समूह के भीतर
• रलीदेव (DT, cols)
  # समूह ID (1 से .GRP) प्रत्येक समूह के भीतर जो कि कोल के रन द्वारा निर्धारित किया जाता है
• पारी (डीटी, एन, टाइप = सी ("अंतराल", "लीड"))
  # हर कॉलम के लिए एक शिफ्ट ऑपरेटर लागू करें
• 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, बेस R से डेटा.फ्रेम क्लास का एक एन्हांस्ड वर्जन है। जैसे कि, इसकी class() विशेषता वेक्टर "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 कारकों के लिए data.table ज़बरदस्ती नहीं करेगा:

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

में पढ़ें

हम एक पाठ फ़ाइल से पढ़ सकते हैं:

dt <- fread("my_file.csv")

विपरीत read.csv , fread तार तार के रूप में, कारकों के रूप में नहीं पढ़ा जाएगा।

एक data.frame संशोधित करें

दक्षता के लिए, डेटाटेबल डेटा को बदलने के लिए एक डेटा.फ्रेम या सूची बदलने का एक तरीका प्रदान करता है। एक जगह (एक प्रतिलिपि बनाने या इसकी मेमोरी स्थान को बदले बिना):

# 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 समारोह में परिवर्तित करने के लिए एक के लिए data.table क्योंकि यह एक प्रति (जो बनाने के बजाय संदर्भ द्वारा रूपांतरण करता as.data.table करता है)। यह महत्वपूर्ण है यदि आप बड़े डेटासेट के साथ काम कर रहे हैं।

यदि आप किसी अन्य आर वस्तु (जैसे एक मैट्रिक्स के रूप में) है, तो आप का उपयोग करना चाहिए as.data.table एक करने के लिए यह मजबूर करने के लिए 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] सिंटैक्स का उपयोग डेटा के कॉलम के साथ काम करने के लिए किया जाता है।

• "जहां" भाग i तर्क है
• "सेलेक्ट | अपडेट | डू" पार्ट 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 के दाहिने-हाथ 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")  

जैसा कि डेटा.फ्रेम में है, हम पंक्ति संख्याओं या तार्किक परीक्षणों का उपयोग करके कम कर सकते हैं। i में "join" का उपयोग करना भी संभव है, लेकिन यह अधिक जटिल कार्य एक अन्य उदाहरण में कवर किया गया है।

स्तंभ विशेषताएँ संपादित करना

वे विशेषताएँ जो विशेषताओं को संपादित करती हैं, जैसे कि levels<- या names<- , वास्तव में किसी वस्तु को संशोधित प्रति के साथ प्रतिस्थापित करते हैं। यहां तक कि अगर केवल data.table में एक कॉलम पर उपयोग किया जाता है, तो संपूर्ण ऑब्जेक्ट को कॉपी और प्रतिस्थापित किया जाता है।

प्रतियों के बिना किसी ऑब्जेक्ट को संशोधित करने के लिए, किसी भी वस्तु के लिए एक विशेषता को बदलने के लिए किसी data.table या data.frame और setattr के कॉलम नामों को बदलने के लिए setnames का उपयोग करें।

# 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 का उपयोग किसी भी फ़ंक्शन को किसी भी फ़ंक्शन को किसी data.table में समूह में लागू करने के लिए किया जा सकता है

हम उसी अंतर्निहित डेटासेट, mtcars का उपयोग करना जारी 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 .SD में शामिल data.table के कॉलम को निर्दिष्ट करता है।

गियर की संख्या से डाटासेट में सभी स्तंभों (निरंतर कॉलम) का मतलब 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 सीधे स्तंभों का वेक्टर ले सकते हैं। उपरोक्त उदाहरण में यह 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 कई दो आयामी डेटा के अलावा आर में उपलब्ध संरचनाओं, में से एक है data.frame , matrix और (2 डी) array । ये सभी वर्ग बहुत समान हैं, लेकिन सब्मिट करने के लिए समान सिंटैक्स का उपयोग नहीं करते हैं, A[rows, cols] कर्ल्स A[rows, cols] स्कीमा।

एक में संग्रहीत निम्न डेटा 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 पैकेज priorto 1.9.8 के संस्करणों के लिए, यह व्यवहार थोड़ा अलग था। पर्यावरण के रूप में dt का उपयोग करके कॉलम इंडेक्स में किसी भी चीज का मूल्यांकन किया गया होगा। तो दोनों dt[, 2:3] और dt[, mycols] वेक्टर 2:3 को वापस करेंगे। दूसरे मामले के लिए कोई त्रुटि नहीं उठाई जाएगी, क्योंकि चर mycols मूल वातावरण में मौजूद है।

डेटा.फ्रेम और 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 से पहले SETKEY की आवश्यकता है

अतीत में (1.9.6 पूर्व), विशेष रूप से बड़ी तालिकाओं के लिए तालिका के लिए कॉलम के रूप में कॉलम सेट करके आपके data.table को data.table गया था। [सितंबर २०१५ संस्करण के इंट्रो विगनेट पेज ५ देखें, जहाँ खोज की गति ५४४ गुना बेहतर थी।] आप टेबल सेट करते समय इस कोड कीज़ का उपयोग 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 में, डेवलपर्स ने माध्यमिक सूचकांकों के चारों ओर एक विगनेट लिखा है जो "ऑन" सिंटैक्स की व्याख्या करता है और अन्य स्तंभों को तेजी से अनुक्रमण के लिए पहचानने की अनुमति देता है।

द्वितीयक सूचकांक बनाना?

कुंजी के समान तरीके से, आप setindex(DT, key.col) या setindexv(DT, "key.col.string") , जहां DT आपका data.table है। setindex(DT, NULL) साथ सभी सूचकांक निकालें।

indices(DT) साथ अपने द्वितीयक सूचक देखें।

माध्यमिक संकेत क्यों?

यह तालिका (कुंजी के विपरीत) को सॉर्ट नहीं करता है , लेकिन "ऑन" सिंटैक्स का उपयोग करके त्वरित अनुक्रमण के लिए अनुमति देता है। ध्यान दें कि केवल एक कुंजी हो सकती है, लेकिन आप कई माध्यमिक सूचकांकों का उपयोग कर सकते हैं, जो टेबल को फिर से भरने और सहारा देने के लिए बचाता है। जब आप सब्मिट करना चाहते हैं तो कॉलम को बदलते समय यह आपकी सब्मिटिंग को गति देगा।

याद करें, उदाहरण के लिए 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