खोज…


टिप्पणियों

एक अनुस्मारक: DT[where, select|update|do, by] सिंटैक्स का उपयोग डेटा के स्तंभ के साथ काम करने के लिए किया जाता है।

  • "जहां" भाग i तर्क है
  • "सेलेक्ट | अपडेट | डू" पार्ट j तर्क है

इन दो तर्कों को आमतौर पर नाम के बजाय स्थिति से पारित किया जाता है।

समूह द्वारा पंक्तियों की गिनती

# example data
DT = data.table(iris)
DT[, Bin := cut(Sepal.Length, c(4,6,8))]

का उपयोग करते हुए। .N

.N में j सबसेट में पंक्तियों की संख्या को स्टोर करता है। डेटा की खोज करते समय, .N लिए आसान है ...

  1. एक समूह में पंक्तियों को गिनें,

    DT[Species == "setosa", .N]
    
    # 50
    
  2. या सभी समूहों में पंक्तियों को गिनें,

    DT[, .N, by=.(Species, Bin)]
    
    #       Species   Bin  N
    # 1:     setosa (4,6] 50
    # 2: versicolor (6,8] 20
    # 3: versicolor (4,6] 30
    # 4:  virginica (6,8] 41
    # 5:  virginica (4,6]  9
    
  3. या उन समूहों को खोजें जिनकी एक निश्चित संख्या में पंक्तियाँ हैं।

    DT[, .N, by=.(Species, Bin)][ N < 25 ]
    
    #       Species   Bin  N
    # 1: versicolor (6,8] 20
    # 2:  virginica (4,6]  9
    

लापता समूहों को संभालना

हालाँकि, हम शून्य से ऊपर की संख्या वाले समूह को याद कर रहे हैं। यदि वे मायने रखते हैं, तो हम आधार से table उपयोग कर सकते हैं:

DT[, data.table(table(Species, Bin))][ N < 25 ]

#       Species   Bin  N
# 1:  virginica (4,6]  9
# 2:     setosa (6,8]  0
# 3: versicolor (6,8] 20

वैकल्पिक रूप से, हम सभी समूहों में शामिल हो सकते हैं:

DT[CJ(Species=Species, Bin=Bin, unique=TRUE), on=c("Species","Bin"), .N, by=.EACHI][N < 25]

#       Species   Bin  N
# 1:     setosa (6,8]  0
# 2: versicolor (6,8] 20
# 3:  virginica (4,6]  9

नोट पर .N :

  • इस उदाहरण का उपयोग करता है .N में j , जहां यह एक सबसेट के आकार को दर्शाता है।
  • i , यह पंक्तियों की कुल संख्या को संदर्भित करता है।

कस्टम सारांश

# example data
DT = data.table(iris)
DT[, Bin := cut(Sepal.Length, c(4,6,8))]

मान लें कि हम Sepal.Length के लिए summary फ़ंक्शन आउटपुट चाहते हैं। टिप्पणियों की संख्या के साथ Sepal.Length :

DT[, c(
    as.list(summary(Sepal.Length)),
    N = .N
), by=.(Species, Bin)]

#       Species   Bin Min. 1st Qu. Median  Mean 3rd Qu. Max.  N
# 1:     setosa (4,6]  4.3     4.8    5.0 5.006     5.2  5.8 50
# 2: versicolor (6,8]  6.1     6.2    6.4 6.450     6.7  7.0 20
# 3: versicolor (4,6]  4.9     5.5    5.6 5.593     5.8  6.0 30
# 4:  virginica (6,8]  6.1     6.4    6.7 6.778     7.2  7.9 41
# 5:  virginica (4,6]  4.9     5.7    5.8 5.722     5.9  6.0  9

हमें j को कॉलम की एक सूची बनानी होगी। आमतौर पर, कुछ लोग c , as.list और के साथ खेल रहे हैं . आगे बढ़ने का सही तरीका जानने के लिए पर्याप्त है।

सारांश आंकड़ों को नए कॉलम के रूप में असाइन करना

सारांश तालिका बनाने के बजाय, हम एक सारांश को एक नए कॉलम में संग्रहीत करना चाहते हैं। हम उपयोग कर सकते हैं := हमेशा की तरह। उदाहरण के लिए,

DT[, is_big := .N >= 25, by=.(Species, Bin)]

नुकसान

अयोग्य डेटा

यदि आप अपने आप को स्तंभ नामों को पार्स करना चाहते हैं, जैसे

x.Length/x.Width x । का अर्थ लें जहां x दस अलग-अलग मान लेता है।

तब आप संभवतः कॉलम नामों में एम्बेडेड डेटा देख रहे हैं, जो एक बुरा विचार है। सुव्यवस्थित डेटा के बारे में पढ़ें और फिर लंबे प्रारूप में फिर से व्यवस्थित करें

रोवई समरी

डेटा फ़्रेम और डेटा। टेबल्स डेटा के लिए डेटाटेबल्स को अच्छी तरह से डिज़ाइन किया गया है, जहां पंक्तियाँ चर के लिए टिप्पणियों और स्तंभों के अनुरूप हैं। यदि आप अपने आप को पंक्तियों पर संक्षेप में प्रस्तुत करना चाहते हैं, जैसे

प्रत्येक पंक्ति के लिए स्तंभों में मानक विचलन खोजें।

तब आपको संभवतः पूरी तरह से एक मैट्रिक्स या कुछ अन्य डेटा प्रारूप का उपयोग करना चाहिए।

सारांश समारोह

# example data
DT = data.table(iris)
DT[, Bin := cut(Sepal.Length, c(4,6,8))]

summary सारांश आंकड़ों को ब्राउज़ करने के लिए सारांश आसान है। summary(DT) जैसे प्रत्यक्ष उपयोग के अलावा, इसे प्रति-समूह को split साथ आसानी से लागू किया जा सकता है:

lapply(split(DT, by=c("Species", "Bin"), drop=TRUE, keep.by=FALSE), summary)

# $`setosa.(4,6]`
#   Sepal.Length    Sepal.Width     Petal.Length    Petal.Width   
#  Min.   :4.300   Min.   :2.300   Min.   :1.000   Min.   :0.100  
#  1st Qu.:4.800   1st Qu.:3.200   1st Qu.:1.400   1st Qu.:0.200  
#  Median :5.000   Median :3.400   Median :1.500   Median :0.200  
#  Mean   :5.006   Mean   :3.428   Mean   :1.462   Mean   :0.246  
#  3rd Qu.:5.200   3rd Qu.:3.675   3rd Qu.:1.575   3rd Qu.:0.300  
#  Max.   :5.800   Max.   :4.400   Max.   :1.900   Max.   :0.600  
# 
# $`versicolor.(6,8]`
#   Sepal.Length   Sepal.Width    Petal.Length    Petal.Width  
#  Min.   :6.10   Min.   :2.20   Min.   :4.000   Min.   :1.20  
#  1st Qu.:6.20   1st Qu.:2.80   1st Qu.:4.400   1st Qu.:1.30  
#  Median :6.40   Median :2.90   Median :4.600   Median :1.40  
#  Mean   :6.45   Mean   :2.89   Mean   :4.585   Mean   :1.42  
#  3rd Qu.:6.70   3rd Qu.:3.10   3rd Qu.:4.700   3rd Qu.:1.50  
#  Max.   :7.00   Max.   :3.30   Max.   :5.000   Max.   :1.70  
# 
# [...results truncated...]

शून्य-गणना समूहों को शामिल करने के लिए, split में drop=FALSE सेट करें।

एक सारांश फ़ंक्शन को कई चर पर लागू करना

# example data
DT = data.table(iris)
DT[, Bin := cut(Sepal.Length, c(4,6,8))]

समूह द्वारा प्रत्येक कॉलम में एक ही सारांश फ़ंक्शन को लागू करने के लिए, हम lapply और .SD उपयोग कर सकते हैं

DT[, lapply(.SD, median), by=.(Species, Bin)]

#       Species   Bin Sepal.Length Sepal.Width Petal.Length Petal.Width
# 1:     setosa (4,6]          5.0         3.4         1.50         0.2
# 2: versicolor (6,8]          6.4         2.9         4.60         1.4
# 3: versicolor (4,6]          5.6         2.7         4.05         1.3
# 4:  virginica (6,8]          6.7         3.0         5.60         2.1
# 5:  virginica (4,6]          5.8         2.7         5.00         1.9

हम .SDcols तर्क के साथ .SD में कॉलम फ़िल्टर कर सकते हैं:

DT[, lapply(.SD, median), by=.(Species, Bin), .SDcols="Petal.Length"]

#       Species   Bin Petal.Length
# 1:     setosa (4,6]         1.50
# 2: versicolor (6,8]         4.60
# 3: versicolor (4,6]         4.05
# 4:  virginica (6,8]         5.60
# 5:  virginica (4,6]         5.00

कई सारांश कार्य

वर्तमान में, कई कार्यों के लिए सबसे सरल विस्तार शायद है:

DT[, unlist(recursive=FALSE, lapply(
    .(med = median, iqr = IQR),
    function(f) lapply(.SD, f)
)), by=.(Species, Bin), .SDcols=Petal.Length:Petal.Width]

#       Species   Bin med.Petal.Length med.Petal.Width iqr.Petal.Length iqr.Petal.Width
# 1:     setosa (4,6]             1.50             0.2            0.175           0.100
# 2: versicolor (6,8]             4.60             1.4            0.300           0.200
# 3: versicolor (4,6]             4.05             1.3            0.525           0.275
# 4:  virginica (6,8]             5.60             2.1            0.700           0.500
# 5:  virginica (4,6]             5.00             1.9            0.200           0.200

आप नाम की तरह होना चाहते हैं Petal.Length.med के बजाय med.Petal.Length , आदेश को बदल:

DT[, unlist(recursive=FALSE, lapply(
    .SD,
    function(x) lapply(.(med = median, iqr = IQR), function(f) f(x))
)), by=.(Species, Bin), .SDcols=Petal.Length:Petal.Width]

#       Species   Bin Petal.Length.med Petal.Length.iqr Petal.Width.med Petal.Width.iqr
# 1:     setosa (4,6]             1.50            0.175             0.2           0.100
# 2: versicolor (6,8]             4.60            0.300             1.4           0.200
# 3: versicolor (4,6]             4.05            0.525             1.3           0.275
# 4:  virginica (6,8]             5.60            0.700             2.1           0.500
# 5:  virginica (4,6]             5.00            0.200             1.9           0.200


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow