आर पैकेज टिडर और इसके नए फ़ंक्शन पिवोट_लॉन्गर और पिवोट_वाइडर

पैकेज साफ-सुथरा आर भाषा में सबसे लोकप्रिय पुस्तकालयों में से एक के मूल में शामिल - साफ सुथरा.
पैकेज का मुख्य उद्देश्य डेटा को सटीक रूप में लाना है।

हैबे पर पहले से ही उपलब्ध है प्रकाशन इस पैकेज को समर्पित है, लेकिन यह 2015 का है। और मैं आपको सबसे ताज़ा बदलावों के बारे में बताना चाहता हूं, जिनकी घोषणा कुछ दिन पहले इसके लेखक हेडली विकम ने की थी।

SJK: क्या इकट्ठा () और स्प्रेड () को बहिष्कृत कर दिया जाएगा?

हैडली विकम: कुछ हद तक। हम अब इन फ़ंक्शंस के उपयोग की अनुशंसा नहीं करेंगे और उनमें बग को ठीक नहीं करेंगे, लेकिन वे अपनी वर्तमान स्थिति में पैकेज में मौजूद रहेंगे।

सामग्री

यदि आप डेटा विश्लेषण में रुचि रखते हैं, तो आपको मेरी रुचि भी हो सकती है तार и यूट्यूब चैनल. अधिकांश सामग्री आर भाषा को समर्पित है।

• सुव्यवस्थित डेटा अवधारणा
• मुख्य कार्य tidyr पैकेज में शामिल हैं
• डेटा को विस्तृत से लंबे प्रारूप में और इसके विपरीत परिवर्तित करने की नई अवधारणा
• Tidyr 0.8.3.9000 का नवीनतम संस्करण स्थापित किया जा रहा है
• नई सुविधाओं में परिवर्तन
• डेटा को विस्तृत से दीर्घ प्रारूप में परिवर्तित करने का एक सरल उदाहरण
• निर्दिष्टीकरण
• एकाधिक मानों का उपयोग कर विशिष्टता (.मान)
• दिनांक फ़्रेम को लंबे से विस्तृत प्रारूप में परिवर्तित करना
  • किसी तालिका को विस्तृत प्रारूप में परिवर्तित करने का सबसे सरल उदाहरण
  • एकाधिक स्रोत चर से एक कॉलम नाम उत्पन्न करना
• नई टिडर अवधारणा के साथ काम करने के कई उन्नत उदाहरण
  • उदाहरण के तौर पर अमेरिकी जनगणना आय और किराया डेटासेट का उपयोग करके डेटा साफ़ करना।
  • विश्व बैंक
  • संपर्क सूची
• निष्कर्ष

सुव्यवस्थित डेटा अवधारणा

लक्ष्य साफ-सुथरा - डेटा को तथाकथित साफ़-सुथरे रूप में लाने में आपकी सहायता करें। नीट डेटा वह डेटा है जहां:

• प्रत्येक वेरिएबल एक कॉलम में है.
• प्रत्येक अवलोकन एक स्ट्रिंग है.
• प्रत्येक मान एक सेल है.

विश्लेषण करते समय सुव्यवस्थित डेटा में प्रस्तुत किए गए डेटा के साथ काम करना बहुत आसान और अधिक सुविधाजनक है।

मुख्य कार्य tidyr पैकेज में शामिल हैं

tidyr में तालिकाओं को रूपांतरित करने के लिए डिज़ाइन किए गए फ़ंक्शंस का एक सेट शामिल है:

• fill() — पिछले मानों वाले कॉलम में लुप्त मानों को भरना;
• separate() - एक विभाजक का उपयोग करके एक फ़ील्ड को कई भागों में विभाजित करता है;
• unite() - कई क्षेत्रों को एक में संयोजित करने का कार्य करता है, जो फ़ंक्शन की विपरीत क्रिया है separate();
• pivot_longer() - एक फ़ंक्शन जो डेटा को विस्तृत प्रारूप से लंबे प्रारूप में परिवर्तित करता है;
• pivot_wider() - एक फ़ंक्शन जो डेटा को लंबे प्रारूप से विस्तृत प्रारूप में परिवर्तित करता है। फ़ंक्शन द्वारा निष्पादित एक का रिवर्स ऑपरेशन pivot_longer().
• gather()अप्रचलित - एक फ़ंक्शन जो डेटा को विस्तृत प्रारूप से लंबे प्रारूप में परिवर्तित करता है;
• spread()अप्रचलित - एक फ़ंक्शन जो डेटा को लंबे प्रारूप से विस्तृत प्रारूप में परिवर्तित करता है। फ़ंक्शन द्वारा निष्पादित एक का रिवर्स ऑपरेशन gather().

डेटा को विस्तृत से लंबे प्रारूप में और इसके विपरीत परिवर्तित करने की नई अवधारणा

पहले, इस प्रकार के परिवर्तन के लिए फ़ंक्शंस का उपयोग किया जाता था gather() и spread(). इन फ़ंक्शंस के अस्तित्व के वर्षों में, यह स्पष्ट हो गया कि पैकेज के लेखक सहित अधिकांश उपयोगकर्ताओं के लिए, इन फ़ंक्शंस के नाम और उनके तर्क बिल्कुल स्पष्ट नहीं थे, और उन्हें ढूंढने और समझने में कठिनाइयों का कारण बना कि इनमें से कौन सा फ़ंक्शंस परिवर्तित होता है विस्तृत से दीर्घ प्रारूप में एक दिनांक फ़्रेम, और इसके विपरीत।

इस संबंध में, में साफ-सुथरा दो नए, महत्वपूर्ण फ़ंक्शन जोड़े गए हैं जो दिनांक फ़्रेम को बदलने के लिए डिज़ाइन किए गए हैं।

नई सुविधाएँ pivot_longer() и pivot_wider() पैकेज की कुछ विशेषताओं से प्रेरित थे cdata, जॉन माउंट और नीना ज़ुमेल द्वारा निर्मित।

Tidyr 0.8.3.9000 का नवीनतम संस्करण स्थापित किया जा रहा है

पैकेज का नया, सबसे वर्तमान संस्करण स्थापित करने के लिए साफ-सुथरा 0.8.3.9000, जहां नई सुविधाएँ उपलब्ध हैं, निम्नलिखित कोड का उपयोग करें।

devtools::install_github("tidyverse/tidyr")

लेखन के समय, ये फ़ंक्शन केवल GitHub पर पैकेज के डेव संस्करण में उपलब्ध हैं।

नई सुविधाओं में परिवर्तन

वास्तव में, नए कार्यों के साथ काम करने के लिए पुरानी स्क्रिप्ट को स्थानांतरित करना मुश्किल नहीं है; बेहतर समझ के लिए, मैं पुराने कार्यों के दस्तावेज़ीकरण से एक उदाहरण लूंगा और दिखाऊंगा कि नए कार्यों का उपयोग करके समान संचालन कैसे किया जाता है pivot_*() कार्य।

विस्तृत प्रारूप को लंबे प्रारूप में बदलें।

एकत्रित फ़ंक्शन दस्तावेज़ से उदाहरण कोड

# example
library(dplyr)
stocks <- data.frame(
  time = as.Date('2009-01-01') + 0:9,
  X = rnorm(10, 0, 1),
  Y = rnorm(10, 0, 2),
  Z = rnorm(10, 0, 4)
)

# old
stocks_gather <- stocks %>% gather(key   = stock, 
                                   value = price, 
                                   -time)

# new
stocks_long   <- stocks %>% pivot_longer(cols      = -time, 
                                       names_to  = "stock", 
                                       values_to = "price")

लंबे प्रारूप को विस्तृत प्रारूप में परिवर्तित करना।

स्प्रेड फ़ंक्शन दस्तावेज़ीकरण से उदाहरण कोड

# old
stocks_spread <- stocks_gather %>% spread(key = stock, 
                                          value = price) 

# new 
stock_wide    <- stocks_long %>% pivot_wider(names_from  = "stock",
                                            values_from = "price")

क्योंकि साथ काम करने के उपरोक्त उदाहरणों में pivot_longer() и pivot_wider(), मूल तालिका में स्टॉक्स तर्कों में कोई कॉलम सूचीबद्ध नहीं है नाम_से и values_to उनके नाम उद्धरण चिह्नों में होने चाहिए.

एक तालिका जो आपको आसानी से यह पता लगाने में मदद करेगी कि किसी नई अवधारणा के साथ काम करने के लिए कैसे स्विच किया जाए साफ-सुथरा.

लेखक से नोट

नीचे दिया गया सारा पाठ अनुकूली है, मैं इसे निःशुल्क अनुवाद भी कहूँगा शब्दचित्र आधिकारिक टिडीवर्स लाइब्रेरी वेबसाइट से।

डेटा को विस्तृत से दीर्घ प्रारूप में परिवर्तित करने का एक सरल उदाहरण

pivot_longer () - कॉलम की संख्या कम करके और पंक्तियों की संख्या बढ़ाकर डेटा सेट को लंबा बनाता है।

लेख में प्रस्तुत उदाहरणों को चलाने के लिए, आपको सबसे पहले आवश्यक पैकेज कनेक्ट करने होंगे:

library(tidyr)
library(dplyr)
library(readr)

मान लीजिए कि हमारे पास एक सर्वेक्षण के परिणामों वाली एक तालिका है जिसमें (अन्य बातों के अलावा) लोगों से उनके धर्म और वार्षिक आय के बारे में पूछा गया है:

#> # A tibble: 18 x 11
#>    religion `<$10k` `$10-20k` `$20-30k` `$30-40k` `$40-50k` `$50-75k`
#>    <chr>      <dbl>     <dbl>     <dbl>     <dbl>     <dbl>     <dbl>
#>  1 Agnostic      27        34        60        81        76       137
#>  2 Atheist       12        27        37        52        35        70
#>  3 Buddhist      27        21        30        34        33        58
#>  4 Catholic     418       617       732       670       638      1116
#>  5 Don’t k…      15        14        15        11        10        35
#>  6 Evangel…     575       869      1064       982       881      1486
#>  7 Hindu          1         9         7         9        11        34
#>  8 Histori…     228       244       236       238       197       223
#>  9 Jehovah…      20        27        24        24        21        30
#> 10 Jewish        19        19        25        25        30        95
#> # … with 8 more rows, and 4 more variables: `$75-100k` <dbl>,
#> #   `$100-150k` <dbl>, `>150k` <dbl>, `Don't know/refused` <dbl>

इस तालिका में उत्तरदाताओं का धर्म डेटा पंक्तियों में है, और आय स्तर कॉलम नामों में बिखरे हुए हैं। प्रत्येक श्रेणी के उत्तरदाताओं की संख्या धर्म और आय स्तर के प्रतिच्छेदन पर सेल मूल्यों में संग्रहीत की जाती है। तालिका को साफ-सुथरे, सही प्रारूप में लाने के लिए, इसका उपयोग करना पर्याप्त है pivot_longer():

pew %>% 
  pivot_longer(cols = -religion, names_to = "income", values_to = "count")

pew %>% 
  pivot_longer(cols = -religion, names_to = "income", values_to = "count")
#> # A tibble: 180 x 3
#>    religion income             count
#>    <chr>    <chr>              <dbl>
#>  1 Agnostic <$10k                 27
#>  2 Agnostic $10-20k               34
#>  3 Agnostic $20-30k               60
#>  4 Agnostic $30-40k               81
#>  5 Agnostic $40-50k               76
#>  6 Agnostic $50-75k              137
#>  7 Agnostic $75-100k             122
#>  8 Agnostic $100-150k            109
#>  9 Agnostic >150k                 84
#> 10 Agnostic Don't know/refused    96
#> # … with 170 more rows

समारोह तर्क pivot_longer()

• पहला तर्क कर्नल, वर्णन करता है कि किन स्तंभों को मर्ज करने की आवश्यकता है। इस मामले में, सभी कॉलम को छोड़कर पहर.
• तर्क नाम_से उस वेरिएबल का नाम देता है जो हमारे द्वारा संयोजित कॉलमों के नामों से बनाया जाएगा।
• values_to एक वेरिएबल का नाम देता है जो मर्ज किए गए कॉलम की कोशिकाओं के मानों में संग्रहीत डेटा से बनाया जाएगा।

निर्दिष्टीकरण

यह पैकेज की एक नई कार्यक्षमता है साफ-सुथरा, जो पहले विरासत कार्यों के साथ काम करते समय अनुपलब्ध था।

एक विनिर्देशन एक डेटा फ़्रेम है, जिसकी प्रत्येक पंक्ति नए आउटपुट दिनांक फ़्रेम में एक कॉलम से मेल खाती है, और दो विशेष कॉलम जो इससे शुरू होते हैं:

• . नाम मूल स्तंभ नाम शामिल है.
• ।कीमत इसमें उस कॉलम का नाम शामिल है जिसमें सेल मान होंगे।

विनिर्देश के शेष कॉलम दर्शाते हैं कि नया कॉलम संपीड़ित कॉलमों का नाम कैसे प्रदर्शित करेगा . नाम.

विनिर्देश एक कॉलम नाम में संग्रहीत मेटाडेटा का वर्णन करता है, प्रत्येक कॉलम के लिए एक पंक्ति और प्रत्येक चर के लिए एक कॉलम, कॉलम नाम के साथ संयुक्त, यह परिभाषा फिलहाल भ्रमित करने वाली लग सकती है, लेकिन कुछ उदाहरणों को देखने के बाद यह बहुत अधिक हो जाएगी अधिक स्पष्ट.

विनिर्देश का मुद्दा यह है कि आप परिवर्तित किए जा रहे डेटाफ़्रेम के लिए नए मेटाडेटा को पुनः प्राप्त, संशोधित और परिभाषित कर सकते हैं।

किसी तालिका को विस्तृत प्रारूप से लंबे प्रारूप में परिवर्तित करते समय विशिष्टताओं के साथ काम करने के लिए, फ़ंक्शन का उपयोग करें pivot_longer_spec().

यह फ़ंक्शन कैसे काम करता है, यह किसी भी दिनांक फ़्रेम को लेता है और ऊपर वर्णित तरीके से अपना मेटाडेटा उत्पन्न करता है।

उदाहरण के तौर पर, आइए पैकेज के साथ उपलब्ध कराए गए हू डेटासेट को लें साफ-सुथरा. इस डेटासेट में तपेदिक की घटनाओं पर अंतर्राष्ट्रीय स्वास्थ्य संगठन द्वारा प्रदान की गई जानकारी शामिल है।

who
#> # A tibble: 7,240 x 60
#>    country iso2  iso3   year new_sp_m014 new_sp_m1524 new_sp_m2534
#>    <chr>   <chr> <chr> <int>       <int>        <int>        <int>
#>  1 Afghan… AF    AFG    1980          NA           NA           NA
#>  2 Afghan… AF    AFG    1981          NA           NA           NA
#>  3 Afghan… AF    AFG    1982          NA           NA           NA
#>  4 Afghan… AF    AFG    1983          NA           NA           NA
#>  5 Afghan… AF    AFG    1984          NA           NA           NA
#>  6 Afghan… AF    AFG    1985          NA           NA           NA
#>  7 Afghan… AF    AFG    1986          NA           NA           NA
#>  8 Afghan… AF    AFG    1987          NA           NA           NA
#>  9 Afghan… AF    AFG    1988          NA           NA           NA
#> 10 Afghan… AF    AFG    1989          NA           NA           NA
#> # … with 7,230 more rows, and 53 more variables

चलिए इसके स्पेसिफिकेशन बनाते हैं.

spec <- who %>%
  pivot_longer_spec(new_sp_m014:newrel_f65, values_to = "count")

#> # A tibble: 56 x 3
#>    .name        .value name        
#>    <chr>        <chr>  <chr>       
#>  1 new_sp_m014  count  new_sp_m014 
#>  2 new_sp_m1524 count  new_sp_m1524
#>  3 new_sp_m2534 count  new_sp_m2534
#>  4 new_sp_m3544 count  new_sp_m3544
#>  5 new_sp_m4554 count  new_sp_m4554
#>  6 new_sp_m5564 count  new_sp_m5564
#>  7 new_sp_m65   count  new_sp_m65  
#>  8 new_sp_f014  count  new_sp_f014 
#>  9 new_sp_f1524 count  new_sp_f1524
#> 10 new_sp_f2534 count  new_sp_f2534
#> # … with 46 more rows

फील्ड्स देश, iso2, iso3 पहले से ही परिवर्तनशील हैं. हमारा काम कॉलमों को पलटना है new_sp_m014 पर newrel_f65.

इन स्तंभों के नाम निम्नलिखित जानकारी संग्रहीत करते हैं:

• उपसर्ग new_ इंगित करता है कि कॉलम में तपेदिक के नए मामलों पर डेटा है, वर्तमान तिथि सीमा में केवल नई बीमारियों की जानकारी है, इसलिए वर्तमान संदर्भ में इस उपसर्ग का कोई अर्थ नहीं है।
• sp/rel/sp/ep किसी बीमारी के निदान के लिए एक विधि का वर्णन करता है।
• m/f रोगी का लिंग.
• 014/1524/2535/3544/4554/65 रोगी की आयु सीमा.

हम फ़ंक्शन का उपयोग करके इन कॉलमों को विभाजित कर सकते हैं extract()नियमित अभिव्यक्ति का उपयोग करना।

spec <- spec %>%
        extract(name, c("diagnosis", "gender", "age"), "new_?(.*)_(.)(.*)")

#> # A tibble: 56 x 5
#>    .name        .value diagnosis gender age  
#>    <chr>        <chr>  <chr>     <chr>  <chr>
#>  1 new_sp_m014  count  sp        m      014  
#>  2 new_sp_m1524 count  sp        m      1524 
#>  3 new_sp_m2534 count  sp        m      2534 
#>  4 new_sp_m3544 count  sp        m      3544 
#>  5 new_sp_m4554 count  sp        m      4554 
#>  6 new_sp_m5564 count  sp        m      5564 
#>  7 new_sp_m65   count  sp        m      65   
#>  8 new_sp_f014  count  sp        f      014  
#>  9 new_sp_f1524 count  sp        f      1524 
#> 10 new_sp_f2534 count  sp        f      2534 
#> # … with 46 more rows

कृपया कॉलम नोट करें . नाम अपरिवर्तित रहना चाहिए क्योंकि यह मूल डेटासेट के कॉलम नामों में हमारा सूचकांक है।

लिंग और उम्र (कॉलम) लिंग и उम्र) के निश्चित और ज्ञात मान हैं, इसलिए इन स्तंभों को कारकों में बदलने की अनुशंसा की जाती है:

spec <-  spec %>%
            mutate(
              gender = factor(gender, levels = c("f", "m")),
              age = factor(age, levels = unique(age), ordered = TRUE)
            ) 

अंततः, हमारे द्वारा बनाए गए विनिर्देश को मूल दिनांक फ़्रेम पर लागू करने के लिए कौन हमें एक तर्क का उपयोग करने की आवश्यकता है कल्पना समारोह में pivot_longer().

who %>% pivot_longer(spec = spec)

#> # A tibble: 405,440 x 8
#>    country     iso2  iso3   year diagnosis gender age   count
#>    <chr>       <chr> <chr> <int> <chr>     <fct>  <ord> <int>
#>  1 Afghanistan AF    AFG    1980 sp        m      014      NA
#>  2 Afghanistan AF    AFG    1980 sp        m      1524     NA
#>  3 Afghanistan AF    AFG    1980 sp        m      2534     NA
#>  4 Afghanistan AF    AFG    1980 sp        m      3544     NA
#>  5 Afghanistan AF    AFG    1980 sp        m      4554     NA
#>  6 Afghanistan AF    AFG    1980 sp        m      5564     NA
#>  7 Afghanistan AF    AFG    1980 sp        m      65       NA
#>  8 Afghanistan AF    AFG    1980 sp        f      014      NA
#>  9 Afghanistan AF    AFG    1980 sp        f      1524     NA
#> 10 Afghanistan AF    AFG    1980 sp        f      2534     NA
#> # … with 405,430 more rows

हमने जो कुछ भी किया उसे योजनाबद्ध रूप से इस प्रकार चित्रित किया जा सकता है:

एकाधिक मानों का उपयोग कर विशिष्टता (.मान)

उपरोक्त उदाहरण में, विनिर्देशन कॉलम ।कीमत इसमें केवल एक ही मान होता है, अधिकांश मामलों में यही स्थिति होती है।

लेकिन कभी-कभी ऐसी स्थिति उत्पन्न हो सकती है जब आपको विभिन्न डेटा प्रकार के मान वाले कॉलम से डेटा एकत्र करने की आवश्यकता होती है। एक विरासत फ़ंक्शन का उपयोग करना spread() ऐसा करना काफी कठिन होगा.

नीचे दिया गया उदाहरण से लिया गया है शब्दचित्र पैकेज के लिए डेटा तालिका.

आइए एक प्रशिक्षण डेटाफ़्रेम बनाएं।

family <- tibble::tribble(
  ~family,  ~dob_child1,  ~dob_child2, ~gender_child1, ~gender_child2,
       1L, "1998-11-26", "2000-01-29",             1L,             2L,
       2L, "1996-06-22",           NA,             2L,             NA,
       3L, "2002-07-11", "2004-04-05",             2L,             2L,
       4L, "2004-10-10", "2009-08-27",             1L,             1L,
       5L, "2000-12-05", "2005-02-28",             2L,             1L,
)
family <- family %>% mutate_at(vars(starts_with("dob")), parse_date)

#> # A tibble: 5 x 5
#>   family dob_child1 dob_child2 gender_child1 gender_child2
#>    <int> <date>     <date>             <int>         <int>
#> 1      1 1998-11-26 2000-01-29             1             2
#> 2      2 1996-06-22 NA                     2            NA
#> 3      3 2002-07-11 2004-04-05             2             2
#> 4      4 2004-10-10 2009-08-27             1             1
#> 5      5 2000-12-05 2005-02-28             2             1

बनाई गई दिनांक फ़्रेम में प्रत्येक पंक्ति में एक परिवार के बच्चों का डेटा शामिल है। परिवारों में एक या दो बच्चे हो सकते हैं। प्रत्येक बच्चे के लिए, जन्म तिथि और लिंग पर डेटा प्रदान किया जाता है, और प्रत्येक बच्चे का डेटा अलग-अलग कॉलम में होता है; हमारा काम इस डेटा को विश्लेषण के लिए सही प्रारूप में लाना है।

कृपया ध्यान दें कि हमारे पास प्रत्येक बच्चे के बारे में जानकारी के साथ दो चर हैं: उनका लिंग और जन्म तिथि (उपसर्ग के साथ कॉलम) डाट जन्मतिथि, उपसर्ग वाले कॉलम शामिल हैं लिंग इसमें बच्चे का लिंग शामिल है)। अपेक्षित परिणाम यह है कि उन्हें अलग-अलग कॉलम में प्रदर्शित होना चाहिए। हम एक विनिर्देश तैयार करके ऐसा कर सकते हैं जिसमें कॉलम .value दो अलग-अलग अर्थ होंगे.

spec <- family %>%
  pivot_longer_spec(-family) %>%
  separate(col = name, into = c(".value", "child"))%>%
  mutate(child = parse_number(child))

#> # A tibble: 4 x 3
#>   .name         .value child
#>   <chr>         <chr>  <dbl>
#> 1 dob_child1    dob        1
#> 2 dob_child2    dob        2
#> 3 gender_child1 gender     1
#> 4 gender_child2 gender     2

तो, आइए उपरोक्त कोड द्वारा किए गए कार्यों पर चरण-दर-चरण नज़र डालें।

• pivot_longer_spec(-family) - एक विनिर्देश बनाएं जो पारिवारिक कॉलम को छोड़कर सभी मौजूदा कॉलमों को संपीड़ित करता है।
• separate(col = name, into = c(".value", "child")) - कॉलम को विभाजित करें . नाम, जिसमें अंडरस्कोर का उपयोग करके और परिणामी मानों को कॉलम में दर्ज करके स्रोत फ़ील्ड के नाम शामिल हैं ।कीमत и बच्चा.
• mutate(child = parse_number(child)) - फ़ील्ड मानों को परिवर्तित करें बच्चा पाठ से लेकर संख्यात्मक डेटा प्रकार तक।

अब हम परिणामी विनिर्देश को मूल डेटाफ़्रेम पर लागू कर सकते हैं और तालिका को वांछित रूप में ला सकते हैं।

family %>% 
    pivot_longer(spec = spec, na.rm = T)

#> # A tibble: 9 x 4
#>   family child dob        gender
#>    <int> <dbl> <date>      <int>
#> 1      1     1 1998-11-26      1
#> 2      1     2 2000-01-29      2
#> 3      2     1 1996-06-22      2
#> 4      3     1 2002-07-11      2
#> 5      3     2 2004-04-05      2
#> 6      4     1 2004-10-10      1
#> 7      4     2 2009-08-27      1
#> 8      5     1 2000-12-05      2
#> 9      5     2 2005-02-28      1

हम तर्क का उपयोग करते हैं na.rm = TRUE, क्योंकि डेटा का वर्तमान स्वरूप गैर-मौजूद अवलोकनों के लिए अतिरिक्त पंक्तियों के निर्माण को मजबूर करता है। क्योंकि परिवार 2 में केवल एक बच्चा है, na.rm = TRUE गारंटी देता है कि परिवार 2 में आउटपुट में एक पंक्ति होगी।

दिनांक फ़्रेम को लंबे से विस्तृत प्रारूप में परिवर्तित करना

pivot_wider() - उलटा परिवर्तन है, और इसके विपरीत पंक्तियों की संख्या कम करके दिनांक फ़्रेम के स्तंभों की संख्या बढ़ जाती है।

डेटा को सटीक रूप में लाने के लिए इस प्रकार के परिवर्तन का उपयोग बहुत ही कम किया जाता है, हालांकि, यह तकनीक प्रस्तुतियों में उपयोग की जाने वाली पिवट टेबल बनाने या कुछ अन्य उपकरणों के साथ एकीकरण के लिए उपयोगी हो सकती है।

वास्तव में कार्य pivot_longer() и pivot_wider() सममित हैं, और एक दूसरे के विपरीत क्रियाएं उत्पन्न करते हैं, अर्थात: df %>% pivot_longer(spec = spec) %>% pivot_wider(spec = spec) и df %>% pivot_wider(spec = spec) %>% pivot_longer(spec = spec) मूल डीएफ वापस कर देंगे।

किसी तालिका को विस्तृत प्रारूप में परिवर्तित करने का सबसे सरल उदाहरण

यह प्रदर्शित करने के लिए कि फ़ंक्शन कैसे काम करता है pivot_wider() हम डेटासेट का उपयोग करेंगे मछली_मुठभेड़, जो इस बात की जानकारी संग्रहीत करता है कि विभिन्न स्टेशन नदी के किनारे मछलियों की आवाजाही को कैसे रिकॉर्ड करते हैं।

#> # A tibble: 114 x 3
#>    fish  station  seen
#>    <fct> <fct>   <int>
#>  1 4842  Release     1
#>  2 4842  I80_1       1
#>  3 4842  Lisbon      1
#>  4 4842  Rstr        1
#>  5 4842  Base_TD     1
#>  6 4842  BCE         1
#>  7 4842  BCW         1
#>  8 4842  BCE2        1
#>  9 4842  BCW2        1
#> 10 4842  MAE         1
#> # … with 104 more rows

अधिकांश मामलों में, यदि आप प्रत्येक स्टेशन के लिए एक अलग कॉलम में जानकारी प्रस्तुत करते हैं तो यह तालिका अधिक जानकारीपूर्ण और उपयोग में आसान होगी।

fish_encounters %>% pivot_wider(names_from = station, values_from = seen)

fish_encounters %>% pivot_wider(names_from = station, values_from = seen)
#> # A tibble: 19 x 12
#>    fish  Release I80_1 Lisbon  Rstr Base_TD   BCE   BCW  BCE2  BCW2   MAE
#>    <fct>   <int> <int>  <int> <int>   <int> <int> <int> <int> <int> <int>
#>  1 4842        1     1      1     1       1     1     1     1     1     1
#>  2 4843        1     1      1     1       1     1     1     1     1     1
#>  3 4844        1     1      1     1       1     1     1     1     1     1
#>  4 4845        1     1      1     1       1    NA    NA    NA    NA    NA
#>  5 4847        1     1      1    NA      NA    NA    NA    NA    NA    NA
#>  6 4848        1     1      1     1      NA    NA    NA    NA    NA    NA
#>  7 4849        1     1     NA    NA      NA    NA    NA    NA    NA    NA
#>  8 4850        1     1     NA     1       1     1     1    NA    NA    NA
#>  9 4851        1     1     NA    NA      NA    NA    NA    NA    NA    NA
#> 10 4854        1     1     NA    NA      NA    NA    NA    NA    NA    NA
#> # … with 9 more rows, and 1 more variable: MAW <int>

यह डेटा सेट केवल तभी जानकारी रिकॉर्ड करता है जब स्टेशन द्वारा मछली का पता लगाया गया हो, यानी। यदि किसी स्टेशन द्वारा कोई मछली रिकॉर्ड नहीं की गई, तो यह डेटा तालिका में नहीं होगा। इसका मतलब है कि आउटपुट NA से भरा जाएगा।

हालाँकि, इस मामले में हम जानते हैं कि रिकॉर्ड की अनुपस्थिति का मतलब है कि मछली नहीं देखी गई थी, इसलिए हम तर्क का उपयोग कर सकते हैं वैल्यू_फिल समारोह में pivot_wider() और इन लुप्त मानों को शून्य से भरें:

fish_encounters %>% pivot_wider(
  names_from = station, 
  values_from = seen,
  values_fill = list(seen = 0)
)

#> # A tibble: 19 x 12
#>    fish  Release I80_1 Lisbon  Rstr Base_TD   BCE   BCW  BCE2  BCW2   MAE
#>    <fct>   <int> <int>  <int> <int>   <int> <int> <int> <int> <int> <int>
#>  1 4842        1     1      1     1       1     1     1     1     1     1
#>  2 4843        1     1      1     1       1     1     1     1     1     1
#>  3 4844        1     1      1     1       1     1     1     1     1     1
#>  4 4845        1     1      1     1       1     0     0     0     0     0
#>  5 4847        1     1      1     0       0     0     0     0     0     0
#>  6 4848        1     1      1     1       0     0     0     0     0     0
#>  7 4849        1     1      0     0       0     0     0     0     0     0
#>  8 4850        1     1      0     1       1     1     1     0     0     0
#>  9 4851        1     1      0     0       0     0     0     0     0     0
#> 10 4854        1     1      0     0       0     0     0     0     0     0
#> # … with 9 more rows, and 1 more variable: MAW <int>

एकाधिक स्रोत चर से एक कॉलम नाम उत्पन्न करना

कल्पना कीजिए कि हमारे पास एक तालिका है जिसमें उत्पाद, देश और वर्ष का संयोजन है। परीक्षण दिनांक फ़्रेम उत्पन्न करने के लिए, आप निम्नलिखित कोड चला सकते हैं:

df <- expand_grid(
  product = c("A", "B"), 
  country = c("AI", "EI"), 
  year = 2000:2014
) %>%
  filter((product == "A" & country == "AI") | product == "B") %>% 
  mutate(value = rnorm(nrow(.)))

#> # A tibble: 45 x 4
#>    product country  year    value
#>    <chr>   <chr>   <int>    <dbl>
#>  1 A       AI       2000 -2.05   
#>  2 A       AI       2001 -0.676  
#>  3 A       AI       2002  1.60   
#>  4 A       AI       2003 -0.353  
#>  5 A       AI       2004 -0.00530
#>  6 A       AI       2005  0.442  
#>  7 A       AI       2006 -0.610  
#>  8 A       AI       2007 -2.77   
#>  9 A       AI       2008  0.899  
#> 10 A       AI       2009 -0.106  
#> # … with 35 more rows

हमारा कार्य डेटा फ़्रेम का विस्तार करना है ताकि एक कॉलम में उत्पाद और देश के प्रत्येक संयोजन के लिए डेटा हो। ऐसा करने के लिए, बस तर्क में आगे बढ़ें नाम_से एक वेक्टर जिसमें मर्ज किए जाने वाले फ़ील्ड के नाम शामिल हैं।

df %>% pivot_wider(names_from = c(product, country),
                 values_from = "value")

#> # A tibble: 15 x 4
#>     year     A_AI    B_AI    B_EI
#>    <int>    <dbl>   <dbl>   <dbl>
#>  1  2000 -2.05     0.607   1.20  
#>  2  2001 -0.676    1.65   -0.114 
#>  3  2002  1.60    -0.0245  0.501 
#>  4  2003 -0.353    1.30   -0.459 
#>  5  2004 -0.00530  0.921  -0.0589
#>  6  2005  0.442   -1.55    0.594 
#>  7  2006 -0.610    0.380  -1.28  
#>  8  2007 -2.77     0.830   0.637 
#>  9  2008  0.899    0.0175 -1.30  
#> 10  2009 -0.106   -0.195   1.03  
#> # … with 5 more rows

आप किसी फ़ंक्शन पर विशिष्टताएँ भी लागू कर सकते हैं pivot_wider(). लेकिन जब सब्मिट किया गया pivot_wider() विनिर्देश विपरीत रूपांतरण करता है pivot_longer(): में निर्दिष्ट कॉलम . नाम, से मानों का उपयोग करना ।कीमत और अन्य कॉलम.

इस डेटासेट के लिए, यदि आप चाहते हैं कि प्रत्येक संभावित देश और उत्पाद संयोजन का अपना कॉलम हो, न कि केवल डेटा में मौजूद कॉलम, तो आप एक कस्टम विनिर्देश तैयार कर सकते हैं:

spec <- df %>% 
  expand(product, country, .value = "value") %>% 
  unite(".name", product, country, remove = FALSE)

#> # A tibble: 4 x 4
#>   .name product country .value
#>   <chr> <chr>   <chr>   <chr> 
#> 1 A_AI  A       AI      value 
#> 2 A_EI  A       EI      value 
#> 3 B_AI  B       AI      value 
#> 4 B_EI  B       EI      value

df %>% pivot_wider(spec = spec) %>% head()

#> # A tibble: 6 x 5
#>    year     A_AI  A_EI    B_AI    B_EI
#>   <int>    <dbl> <dbl>   <dbl>   <dbl>
#> 1  2000 -2.05       NA  0.607   1.20  
#> 2  2001 -0.676      NA  1.65   -0.114 
#> 3  2002  1.60       NA -0.0245  0.501 
#> 4  2003 -0.353      NA  1.30   -0.459 
#> 5  2004 -0.00530    NA  0.921  -0.0589
#> 6  2005  0.442      NA -1.55    0.594

नई टिडर अवधारणा के साथ काम करने के कई उन्नत उदाहरण

उदाहरण के तौर पर अमेरिकी जनगणना आय और किराया डेटासेट का उपयोग करके डेटा साफ़ करना।

डेटा सेट हमें_किराया_आय इसमें 2017 के लिए अमेरिका के प्रत्येक राज्य की औसत आय और किराए की जानकारी शामिल है (डेटा सेट पैकेज में उपलब्ध है)। tidycensus).

us_rent_income
#> # A tibble: 104 x 5
#>    GEOID NAME       variable estimate   moe
#>    <chr> <chr>      <chr>       <dbl> <dbl>
#>  1 01    Alabama    income      24476   136
#>  2 01    Alabama    rent          747     3
#>  3 02    Alaska     income      32940   508
#>  4 02    Alaska     rent         1200    13
#>  5 04    Arizona    income      27517   148
#>  6 04    Arizona    rent          972     4
#>  7 05    Arkansas   income      23789   165
#>  8 05    Arkansas   rent          709     5
#>  9 06    California income      29454   109
#> 10 06    California rent         1358     3
#> # … with 94 more rows

जिस रूप में डेटा को डेटासेट में संग्रहीत किया जाता है हमें_किराया_आय उनके साथ काम करना बेहद असुविधाजनक है, इसलिए हम कॉलम के साथ एक डेटा सेट बनाना चाहेंगे: किराया, किराया_मो, कैसे, आय_मो. इस विनिर्देशन को बनाने के कई तरीके हैं, लेकिन मुख्य बात यह है कि हमें चर मानों के प्रत्येक संयोजन को उत्पन्न करने की आवश्यकता है अनुमान/मोऔर फिर कॉलम नाम जनरेट करें।

  spec <- us_rent_income %>% 
    expand(variable, .value = c("estimate", "moe")) %>% 
    mutate(
      .name = paste0(variable, ifelse(.value == "moe", "_moe", ""))
    )

#> # A tibble: 4 x 3
#>   variable .value   .name     
#>   <chr>    <chr>    <chr>     
#> 1 income   estimate income    
#> 2 income   moe      income_moe
#> 3 rent     estimate rent      
#> 4 rent     moe      rent_moe

यह विशिष्टता प्रदान करना pivot_wider() हमें वह परिणाम देता है जिसकी हम तलाश कर रहे हैं:

us_rent_income %>% pivot_wider(spec = spec)

#> # A tibble: 52 x 6
#>    GEOID NAME                 income income_moe  rent rent_moe
#>    <chr> <chr>                 <dbl>      <dbl> <dbl>    <dbl>
#>  1 01    Alabama               24476        136   747        3
#>  2 02    Alaska                32940        508  1200       13
#>  3 04    Arizona               27517        148   972        4
#>  4 05    Arkansas              23789        165   709        5
#>  5 06    California            29454        109  1358        3
#>  6 08    Colorado              32401        109  1125        5
#>  7 09    Connecticut           35326        195  1123        5
#>  8 10    Delaware              31560        247  1076       10
#>  9 11    District of Columbia  43198        681  1424       17
#> 10 12    Florida               25952         70  1077        3
#> # … with 42 more rows

विश्व बैंक

कभी-कभी किसी डेटा सेट को वांछित रूप में लाने के लिए कई चरणों की आवश्यकता होती है।
डेटासेट वर्ल्ड_बैंक_पॉप इसमें 2000 और 2018 के बीच प्रत्येक देश की जनसंख्या पर विश्व बैंक का डेटा शामिल है।

#> # A tibble: 1,056 x 20
#>    country indicator `2000` `2001` `2002` `2003`  `2004`  `2005`   `2006`
#>    <chr>   <chr>      <dbl>  <dbl>  <dbl>  <dbl>   <dbl>   <dbl>    <dbl>
#>  1 ABW     SP.URB.T… 4.24e4 4.30e4 4.37e4 4.42e4 4.47e+4 4.49e+4  4.49e+4
#>  2 ABW     SP.URB.G… 1.18e0 1.41e0 1.43e0 1.31e0 9.51e-1 4.91e-1 -1.78e-2
#>  3 ABW     SP.POP.T… 9.09e4 9.29e4 9.50e4 9.70e4 9.87e+4 1.00e+5  1.01e+5
#>  4 ABW     SP.POP.G… 2.06e0 2.23e0 2.23e0 2.11e0 1.76e+0 1.30e+0  7.98e-1
#>  5 AFG     SP.URB.T… 4.44e6 4.65e6 4.89e6 5.16e6 5.43e+6 5.69e+6  5.93e+6
#>  6 AFG     SP.URB.G… 3.91e0 4.66e0 5.13e0 5.23e0 5.12e+0 4.77e+0  4.12e+0
#>  7 AFG     SP.POP.T… 2.01e7 2.10e7 2.20e7 2.31e7 2.41e+7 2.51e+7  2.59e+7
#>  8 AFG     SP.POP.G… 3.49e0 4.25e0 4.72e0 4.82e0 4.47e+0 3.87e+0  3.23e+0
#>  9 AGO     SP.URB.T… 8.23e6 8.71e6 9.22e6 9.77e6 1.03e+7 1.09e+7  1.15e+7
#> 10 AGO     SP.URB.G… 5.44e0 5.59e0 5.70e0 5.76e0 5.75e+0 5.69e+0  4.92e+0
#> # … with 1,046 more rows, and 11 more variables: `2007` <dbl>,
#> #   `2008` <dbl>, `2009` <dbl>, `2010` <dbl>, `2011` <dbl>, `2012` <dbl>,
#> #   `2013` <dbl>, `2014` <dbl>, `2015` <dbl>, `2016` <dbl>, `2017` <dbl>

हमारा लक्ष्य अपने स्वयं के कॉलम में प्रत्येक चर के साथ एक साफ-सुथरा डेटा सेट बनाना है। यह स्पष्ट नहीं है कि वास्तव में किन कदमों की आवश्यकता है, लेकिन हम सबसे स्पष्ट समस्या से शुरुआत करेंगे: वर्ष कई स्तंभों में फैला हुआ है।

इसे ठीक करने के लिए आपको फ़ंक्शन का उपयोग करना होगा pivot_longer().

pop2 <- world_bank_pop %>% 
  pivot_longer(`2000`:`2017`, names_to = "year")

#> # A tibble: 19,008 x 4
#>    country indicator   year  value
#>    <chr>   <chr>       <chr> <dbl>
#>  1 ABW     SP.URB.TOTL 2000  42444
#>  2 ABW     SP.URB.TOTL 2001  43048
#>  3 ABW     SP.URB.TOTL 2002  43670
#>  4 ABW     SP.URB.TOTL 2003  44246
#>  5 ABW     SP.URB.TOTL 2004  44669
#>  6 ABW     SP.URB.TOTL 2005  44889
#>  7 ABW     SP.URB.TOTL 2006  44881
#>  8 ABW     SP.URB.TOTL 2007  44686
#>  9 ABW     SP.URB.TOTL 2008  44375
#> 10 ABW     SP.URB.TOTL 2009  44052
#> # … with 18,998 more rows

अगला कदम सूचक चर को देखना है।
pop2 %>% count(indicator)

#> # A tibble: 4 x 2
#>   indicator       n
#>   <chr>       <int>
#> 1 SP.POP.GROW  4752
#> 2 SP.POP.TOTL  4752
#> 3 SP.URB.GROW  4752
#> 4 SP.URB.TOTL  4752

जहां SP.POP.GROW जनसंख्या वृद्धि है, SP.POP.TOTL कुल जनसंख्या है, और SP.URB है। * वही बात, लेकिन केवल शहरी क्षेत्रों के लिए। आइए इन मानों को दो चर में विभाजित करें: क्षेत्र - क्षेत्र (कुल या शहरी) और वास्तविक डेटा (जनसंख्या या वृद्धि) वाला एक चर:

pop3 <- pop2 %>% 
  separate(indicator, c(NA, "area", "variable"))

#> # A tibble: 19,008 x 5
#>    country area  variable year  value
#>    <chr>   <chr> <chr>    <chr> <dbl>
#>  1 ABW     URB   TOTL     2000  42444
#>  2 ABW     URB   TOTL     2001  43048
#>  3 ABW     URB   TOTL     2002  43670
#>  4 ABW     URB   TOTL     2003  44246
#>  5 ABW     URB   TOTL     2004  44669
#>  6 ABW     URB   TOTL     2005  44889
#>  7 ABW     URB   TOTL     2006  44881
#>  8 ABW     URB   TOTL     2007  44686
#>  9 ABW     URB   TOTL     2008  44375
#> 10 ABW     URB   TOTL     2009  44052
#> # … with 18,998 more rows

अब हमें बस वेरिएबल को दो कॉलम में विभाजित करना है:

pop3 %>% 
  pivot_wider(names_from = variable, values_from = value)

#> # A tibble: 9,504 x 5
#>    country area  year   TOTL    GROW
#>    <chr>   <chr> <chr> <dbl>   <dbl>
#>  1 ABW     URB   2000  42444  1.18  
#>  2 ABW     URB   2001  43048  1.41  
#>  3 ABW     URB   2002  43670  1.43  
#>  4 ABW     URB   2003  44246  1.31  
#>  5 ABW     URB   2004  44669  0.951 
#>  6 ABW     URB   2005  44889  0.491 
#>  7 ABW     URB   2006  44881 -0.0178
#>  8 ABW     URB   2007  44686 -0.435 
#>  9 ABW     URB   2008  44375 -0.698 
#> 10 ABW     URB   2009  44052 -0.731 
#> # … with 9,494 more rows

संपर्क सूची

एक आखिरी उदाहरण, कल्पना करें कि आपके पास एक संपर्क सूची है जिसे आपने किसी वेबसाइट से कॉपी और पेस्ट किया है:

contacts <- tribble(
  ~field, ~value,
  "name", "Jiena McLellan",
  "company", "Toyota", 
  "name", "John Smith", 
  "company", "google", 
  "email", "[email protected]",
  "name", "Huxley Ratcliffe"
)

इस सूची को सारणीबद्ध करना काफी कठिन है क्योंकि इसमें कोई चर नहीं है जो यह पहचान सके कि कौन सा डेटा किस संपर्क से संबंधित है। हम यह ध्यान देकर इसे ठीक कर सकते हैं कि प्रत्येक नए संपर्क का डेटा "नाम" से शुरू होता है, इसलिए हम एक अद्वितीय पहचानकर्ता बना सकते हैं और हर बार फ़ील्ड कॉलम में "नाम" मान शामिल होने पर इसे एक बढ़ा सकते हैं:

contacts <- contacts %>% 
  mutate(
    person_id = cumsum(field == "name")
  )
contacts

#> # A tibble: 6 x 3
#>   field   value            person_id
#>   <chr>   <chr>                <int>
#> 1 name    Jiena McLellan           1
#> 2 company Toyota                   1
#> 3 name    John Smith               2
#> 4 company google                   2
#> 5 email   [email protected]          2
#> 6 name    Huxley Ratcliffe         3

अब जबकि हमारे पास प्रत्येक संपर्क के लिए एक अद्वितीय आईडी है, हम फ़ील्ड और मान को कॉलम में बदल सकते हैं:

contacts %>% 
  pivot_wider(names_from = field, values_from = value)

#> # A tibble: 3 x 4
#>   person_id name             company email          
#>       <int> <chr>            <chr>   <chr>          
#> 1         1 Jiena McLellan   Toyota  <NA>           
#> 2         2 John Smith       google  [email protected]
#> 3         3 Huxley Ratcliffe <NA>    <NA>

निष्कर्ष

मेरी व्यक्तिगत राय यह है कि नई अवधारणा साफ-सुथरा वास्तव में अधिक सहज ज्ञान युक्त, और विरासत कार्यों की तुलना में कार्यक्षमता में काफी बेहतर spread() и gather(). मुझे आशा है कि इस लेख से आपको इससे निपटने में मदद मिलेगी pivot_longer() и pivot_wider().

स्रोत: www.habr.com