आर पॅकेज tidyr आणि त्याची नवीन कार्ये pivot_longer आणि pivot_wider

पॅकेज व्यवस्थित R भाषेतील सर्वात लोकप्रिय लायब्ररींपैकी एकामध्ये समाविष्ट आहे - नीटनेटका.
पॅकेजचा मुख्य उद्देश डेटा अचूक स्वरूपात आणणे हा आहे.

Habré वर आधीच उपलब्ध आहे प्रकाशन या पॅकेजसाठी समर्पित आहे, परंतु ते 2015 चे आहे. आणि मला तुम्हाला सर्वात वर्तमान बदलांबद्दल सांगायचे आहे, जे काही दिवसांपूर्वी त्याचे लेखक हेडली विकहॅम यांनी जाहीर केले होते.

एसजेके: gather() आणि spread() नापसंत केले जाईल?

हॅडली विकहॅम: काही प्रमाणात. आम्ही यापुढे या फंक्शन्सच्या वापराची शिफारस करणार नाही आणि त्यामधील दोष दूर करणार नाही, परंतु ते त्यांच्या सध्याच्या स्थितीत पॅकेजमध्ये उपस्थित राहतील.

सामग्री

तुम्हाला डेटा विश्लेषणामध्ये स्वारस्य असल्यास, तुम्हाला माझ्यामध्ये स्वारस्य असेल तार и YouTube चॅनेल बहुतेक सामग्री आर भाषेला समर्पित आहे.

• व्यवस्थित डेटा संकल्पना
• tidyr पॅकेजमध्ये मुख्य कार्ये समाविष्ट आहेत
• डेटा रुंद वरून लांब फॉरमॅटमध्ये रूपांतरित करण्यासाठी नवीन संकल्पना आणि त्याउलट
• tidyr 0.8.3.9000 ची सर्वात वर्तमान आवृत्ती स्थापित करत आहे
• नवीन वैशिष्ट्यांमध्ये संक्रमण
• डेटा रुंद ते लांब फॉरमॅटमध्ये रूपांतरित करण्याचे एक साधे उदाहरण
• तपशील
• एकाधिक मूल्ये वापरून तपशील (.value)
• तारीख फ्रेम लाँग मधून रुंद फॉरमॅटमध्ये रूपांतरित करत आहे
  • सारणीला विस्तृत स्वरूपात रूपांतरित करण्याचे सर्वात सोपे उदाहरण
  • एकाधिक स्त्रोत व्हेरिएबल्समधून स्तंभ नाव तयार करणे
• नवीन tidyr संकल्पनेसह कार्य करण्याची अनेक प्रगत उदाहरणे
  • उदाहरण म्हणून यूएस जनगणना उत्पन्न आणि भाडे डेटासेट वापरून डेटा साफ करणे.
  • जागतिक बँक
  • संपर्क यादी
• निष्कर्ष

व्यवस्थित डेटा संकल्पना

गोल व्यवस्थित — तुम्हाला डेटा एका तथाकथित व्यवस्थित स्वरूपात आणण्यात मदत करा. नीट डेटा असा डेटा आहे जेथे:

• प्रत्येक व्हेरिएबल एका स्तंभात आहे.
• प्रत्येक निरीक्षण एक स्ट्रिंग आहे.
• प्रत्येक मूल्य एक सेल आहे.

विश्लेषण आयोजित करताना नीटनेटका डेटामध्ये सादर केलेल्या डेटासह कार्य करणे खूप सोपे आणि अधिक सोयीस्कर आहे.

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 त्यांची नावे अवतरण चिन्हांमध्ये असणे आवश्यक आहे.

एक सारणी जी तुम्हाला नवीन संकल्पनेसह कार्य करण्यासाठी कसे स्विच करावे हे सहजपणे शोधण्यात मदत करेल व्यवस्थित.

लेखकाकडून टीप

खालील सर्व मजकूर अनुकूली आहे, मी विनामूल्य भाषांतर देखील म्हणेन विग्नेट्स अधिकृत tidyverse लायब्ररी वेबसाइटवरून.

डेटा रुंद ते लांब फॉरमॅटमध्ये रूपांतरित करण्याचे एक साधे उदाहरण

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

फील्ड देशातील, isoxnumx, isoxnumx आधीच व्हेरिएबल्स आहेत. आमचे कार्य स्तंभ फ्लिप करणे आहे 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

आम्ही जे काही केले ते खालीलप्रमाणे योजनाबद्धपणे चित्रित केले जाऊ शकते:

एकाधिक मूल्ये वापरून तपशील (.value)

वरील उदाहरणामध्ये, तपशील स्तंभ .मूल्य फक्त एक मूल्य समाविष्ट आहे, बहुतेक प्रकरणांमध्ये हे असे आहे.

परंतु कधीकधी अशी परिस्थिती उद्भवू शकते जेव्हा आपल्याला मूल्यांमध्ये भिन्न डेटा प्रकार असलेल्या स्तंभांमधून डेटा गोळा करण्याची आवश्यकता असते. लेगसी फंक्शन वापरणे 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) मूळ df परत करेल.

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

फंक्शन कसे कार्य करते हे दाखवण्यासाठी 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 ने भरले जाईल.

तथापि, या प्रकरणात आम्हाला माहित आहे की रेकॉर्ड नसणे म्हणजे मासे दिसले नाहीत, म्हणून आम्ही युक्तिवाद वापरू शकतो values_fill कार्यात 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

नवीन tidyr संकल्पनेसह कार्य करण्याची अनेक प्रगत उदाहरणे

उदाहरण म्हणून यूएस जनगणना उत्पन्न आणि भाडे डेटासेट वापरून डेटा साफ करणे.

डेटा सेट आम्हाला_भाडे_उत्पन्न 2017 साठी यूएस मधील प्रत्येक राज्यासाठी सरासरी उत्पन्न आणि भाडे माहिती समाविष्ट आहे (डेटा संच पॅकेजमध्ये उपलब्ध आहे व्यवस्थित जनगणना).

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

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

  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

जागतिक बँक

कधीकधी इच्छित फॉर्ममध्ये डेटा सेट आणण्यासाठी अनेक चरणांची आवश्यकता असते.
डेटासेट world_bank_pop 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", "john@google.com",
  "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   john@google.com          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  john@google.com
#> 3         3 Huxley Ratcliffe <NA>    <NA>

निष्कर्ष

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

स्त्रोत: www.habr.com