🥇R חבילת tidyr והפונקציות החדשות שלה pivot_longer ו- pivot_wider

חבילה מסודר נכלל בליבה של אחת הספריות הפופולריות ביותר בשפת R - מסודר.
המטרה העיקרית של החבילה היא להביא את הנתונים לצורה מדויקת.

כבר זמין ב-Habré פרסום מוקדש לחבילה זו, אך היא מתוארכת ל-2015. ואני רוצה לספר לכם על השינויים העדכניים ביותר, שהוכרזו לפני מספר ימים על ידי מחברו, הדלי וויקהאם.

SJK: האם ה-collect() ו- spread() יבוטלו?

הדלי וויקהאם: במידה מסוימת. לא נמליץ עוד על השימוש בפונקציות הללו ונתקן בהן באגים, אך הן ימשיכו להיות נוכחות בחבילה במצבן הנוכחי.

תוכן

אם אתה מעוניין בניתוח נתונים, אולי אתה מעוניין ב- שלי מברק и YouTube ערוצים. רוב התוכן מוקדש לשפת R.

קונספט TidyData
פונקציות עיקריות הכלולות בחבילת tidyr
קונספט חדש להמרת נתונים מפורמט רחב לארוך ולהיפך
התקנת הגרסה העדכנית ביותר של tidyr 0.8.3.9000
מעבר לתכונות חדשות
דוגמה פשוטה להמרת נתונים מפורמט רחב לארוך
מפרטים
מפרט באמצעות ערכים מרובים (.value)
המרת מסגרות תאריך מפורמט ארוך לרחב
- הדוגמה הפשוטה ביותר להמרת טבלה לפורמט רחב
- יצירת שם עמודה ממשתני מקור מרובים
מספר דוגמאות מתקדמות לעבודה עם הקונספט החדש של tidyr
מסקנה

קונספט TidyData

יעד מסודר - לעזור לך להביא את הנתונים לצורה מסודרת כביכול. נתונים מסודרים הם נתונים שבהם:

כל משתנה נמצא בעמודה.
כל תצפית היא מחרוזת.
כל ערך הוא תא.

הרבה יותר קל ונוח לעבוד עם נתונים שמוצגים בנתונים מסודרים בעת ביצוע ניתוח.

פונקציות עיקריות הכלולות בחבילת 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")

בזמן כתיבת שורות אלה, פונקציות אלו זמינות רק בגרסת ה-dev של החבילה ב-GitHub.

מעבר לתכונות חדשות

למעשה, לא קשה להעביר סקריפטים ישנים לעבודה עם פונקציות חדשות; להבנה טובה יותר, אקח דוגמה מהתיעוד של פונקציות ישנות ואראה כיצד אותן פעולות מתבצעות באמצעות חדשות pivot_*() פונקציות.

המרת פורמט רחב לפורמט ארוך.

קוד לדוגמה מתוך תיעוד פונקציית ה-collect

# 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 נותן שם של משתנה שייווצר מהנתונים המאוחסנים בערכי התאים של העמודות הממוזגות.

מפרטים

זוהי פונקציונליות חדשה של החבילה מסודר, שלא היה זמין בעבר בעת עבודה עם פונקציות מדור קודם.

מפרט הוא מסגרת נתונים, שכל שורה שלה מתאימה לעמודה אחת במסגרת תאריך הפלט החדשה, ושתי עמודות מיוחדות שמתחילות ב:

. שם מכיל את שם העמודה המקורי.
.value מכיל את שם העמודה שתכיל את ערכי התא.

העמודות הנותרות של המפרט משקפות כיצד העמודה החדשה תציג את שם העמודות הדחוסות . שם.

המפרט מתאר את המטא נתונים המאוחסנים בשם עמודה, עם שורה אחת לכל עמודה ועמודה אחת לכל משתנה, בשילוב עם שם העמודה, הגדרה זו עשויה להיראות מבלבלת כרגע, אך לאחר שתסתכל על כמה דוגמאות היא תהפוך להרבה יותר ברור.

הפואנטה של המפרט היא שאתה יכול לאחזר, לשנות ולהגדיר מטא נתונים חדשים עבור מסגרת הנתונים המומרת.

כדי לעבוד עם מפרטים בעת המרת טבלה מפורמט רחב לפורמט ארוך, השתמש בפונקציה pivot_longer_spec().

איך הפונקציה הזו עובדת היא שהיא לוקחת כל מסגרת תאריך ומייצרת את המטא נתונים שלה באופן שתואר לעיל.

כדוגמה, ניקח את מערך הנתונים who שסופק עם החבילה מסודר. מערך נתונים זה מכיל מידע שסופק על ידי ארגון הבריאות הבינלאומי על שכיחות שחפת.

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

כל מה שעשינו זה עתה יכול להיות מתואר באופן סכמטי באופן הבא:

מפרט באמצעות ערכים מרובים (.value)

בדוגמה למעלה, עמודת המפרט .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")) - לפצל את העמודה . שם, המכיל את שמות שדות המקור, תוך שימוש בקו התחתון והזנת הערכים המתקבלים לעמודות .value и ילד.
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(): העמודות שצוינו ב . שם, באמצעות ערכים מ .value ועמודות אחרות.

עבור מערך הנתונים הזה, אתה יכול ליצור מפרט מותאם אישית אם אתה רוצה שלכל מדינה ושילוב מוצר אפשרי תהיה עמודה משלו, לא רק אלה הקיימים בנתונים:

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

ניקוי נתונים באמצעות מערך הנתונים של הכנסה ושכר דירה בארה"ב כדוגמה.

מערך נתונים us_rent_income מכיל מידע חציוני על הכנסה ושכר דירה עבור כל מדינה בארה"ב לשנת 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

בצורה שבה הנתונים מאוחסנים במערך הנתונים us_rent_income העבודה איתם היא מאוד לא נוחה, אז נרצה ליצור מערך נתונים עם עמודות: השכרה, rent_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

הבנק העולמי

לפעמים הבאת מערך נתונים לצורה הרצויה דורשת מספר שלבים.
מערך נתונים פופ_בנק_עולמי מכיל נתוני הבנק העולמי על אוכלוסיית כל מדינה בין השנים 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

R package tidyr והפונקציות החדשות שלה pivot_longer ו- pivot_wider