מיון ב-R: sort(), order() ו-arrange()

sort() ממיינת את הערכים של וקטור

לווקטור רגיל, sort() עושה בדיוק מה שמצפים: מחזירה את הערכים בסדר עולה (המקור לא משתנה):

times <- c(12.4, 9.8, 15.1, 11.0)

print(sort(times))
print(sort(times, decreasing = TRUE))

words <- c("pear", "apple", "cherry")
print(sort(words))

שתי אפשרויות שכדאי להכיר. decreasing = TRUE הופך את הכיוון. ו-sort() משמיטה בשקט ערכי NA כברירת מחדל: sort(c(3, NA, 1)) מחזירה רק 1 3. אם ערכים חסרים חייבים לשרוד את המיון, אמרו לאן הם הולכים: sort(x, na.last = TRUE) שומר אותם, אחרי הערכים הממוינים.

עד כאן, מובן מאליו. החלק המעניין הוא למה sort() היא הכלי הלא נכון ל-data frames.

order() מחזירה מיקומים: השינוי בחשיבה

sort() עונה על "מהם הערכים, לפי הסדר?". order() עונה על שאלה אחרת: "באילו מיקומים צריך לבקר כדי לראות את הערכים לפי הסדר?"

times <- c(12.4, 9.8, 15.1, 11.0)

print(sort(times))    # the values, ordered
print(order(times))   # 2 4 1 3 - the positions, in order

קראו את order(times) כהוראות: הערך הקטן ביותר נמצא במיקום 2, הבא במיקום 4, אחר כך 1, ואז 3. בחירה לפי ההוראות האלה, times[order(times)], משחזרת בדיוק את sort(times).

למה זה חשוב? כי שורה ב-data frame היא צוות של ערכים שחייבים לזוז יחד. מיון של העמודה time לבדה עם sort() היה מסדר מחדש עמודה אחת ומשאיר את חברי הצוות שלה מאחור: כל השורות מבולגנות. order() נותנת במקום זה מיקומי שורות, והצבת מיקומים בחלק של השורות בתוך הסוגריים מזיזה שורות שלמות:

runners <- data.frame(
    name = c("Ana", "Ben", "Chen", "Dana"),
    time = c(12.4, 9.8, 15.1, 11.0)
)

print(runners[order(runners$time), ])

ה-9.8 של Ben מגיע כשהשם של Ben עדיין צמוד אליו. זה כל הטריק, וזו הדרך המקובלת למיין data frames ב-R הבסיסית: df[order(df$column), ]. (תוויות השורות המודפסות, 2 4 1 3, הן מספרי השורות המקוריים שבאים יחד עם השורות; לא מזיק.)

מיון יורד ומיון לפי כמה עמודות

למיון מספרי יורד, הפכו את הסימן של העמודה: מיון עולה של -time הוא מיון יורד של time. ו-order() מקבלת כמה עמודות, הראשונות קודם, והמאוחרות מכריעות במקרה של שוויון:

staff <- data.frame(
    name   = c("Ana", "Ben", "Chen", "Dana", "Eli"),
    dept   = c("ops", "eng", "eng", "ops", "eng"),
    salary = c(70, 95, 88, 75, 95)
)

print(staff[order(-staff$salary), ])                 # highest paid first
print(staff[order(staff$dept, -staff$salary), ])     # by dept, then salary desc

הקריאה השנייה ממיינת מחלקות לפי סדר אלפביתי, ובתוך כל מחלקה, משכורות מהגבוהה לנמוכה. טריק הפיכת הסימן עובד רק על מספרים: -df$name על עמודת תווים הוא שגיאה. לטקסט בסדר יורד, השתמשו במקום זאת ב-order(df$name, decreasing = TRUE) (שהופך את כל מפתחות המיון בבת אחת).

rank() היא האחות השלישית

בדרך אגב: rank(x) עונה על עוד שאלה אחרת, "באיזה מקום נמצא כל ערך?", בלי להזיז שום דבר:

times <- c(12.4, 9.8, 15.1, 11.0)
print(rank(times))   # 3 1 4 2 - Ana came 3rd, Ben 1st...

sort() נותנת ערכים מסודרים, order() נותנת מיקומים לבקר בהם, rank() נותנת את הדירוג של כל ערך במקומו. אנשים מבלבלים בין order() ל-rank() כל הזמן; שימו לב שהן תמורות הופכיות זו של זו, והשתמשו ב-rank() רק כשאתם ממש רוצים דירוגים (טבלאות דירוג, אחוזונים).

הדרך של dplyr: arrange()

arrange() של dplyr עוטפת את כל הריקוד של order() בפועל אחד: עמודות הן מפתחות מיון, ו-desc() הופכת אחת מהן (קוד סטטי; סביבת ההרצה כאן מריצה רק R בסיסית):

library(dplyr)

runners |> arrange(time)
staff   |> arrange(dept, desc(salary))

בלי סוגריים, בלי $, בלי טריק הפיכת סימן: desc() עובדת גם על עמודות תווים. הבדל התנהגותי אחד שכדאי להכיר: arrange() שמה ערכי NA בסוף בלי קשר לכיוון, בעוד שגם order() הבסיסית מוגדרת כברירת מחדל ל-na.last = TRUE. ראו את המבוא ל-dplyr כדי להבין איך arrange() משתלבת בשרשרת עם filter() וחברותיה.

למיון תווים יש קצוות חדים

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

versions <- c("10", "2", "1", "30")

print(sort(versions))              # "1" "10" "2" "30" - not numeric order!
print(sort(as.numeric(versions)))  # 1 2 10 30

"10" ממוין לפני "2" כי ההשוואה נעצרת בסמל הראשון: "1" < "2". אם עמודה של מספרים ממוינת בצורה מוזרה, היא כמעט בוודאות שמורה כ-character: המירו עם as.numeric() קודם (תוצאה נפוצה של ייבוא CSV מבולגן).

שנית, סדר הטקסט תלוי בהגדרות האזוריות (locale) של המערכת: אותיות עם סימנים, אותיות גדולות וקטנות וכתבים שאינם לטיניים יכולים להתמיין אחרת במחשב הנייד שלכם מאשר בשרת עם locale של C. פלט ממוין שחייב להיות זהה בכל המחשבים צריך להגדיר את ה-locale במפורש או למיין לפי מפתח מנורמל.

מה לקחת מכאן

• sort(x) מסדרת את הערכים של וקטור; decreasing = TRUE הופך אותה; ערכי NA מושמטים אלא אם na.last = TRUE.
• order(x) מחזירה מיקומים, ו-df[order(df$x), ] היא הדרך הבסיסית המקובלת למיין data frames.
• כמה עמודות: order(df$a, -df$b); הפיכת סימן לסדר יורד עובדת רק על מספרים.
• rank() נותנת דירוגים בלי לסדר מחדש: היא לא תחליף ל-order().
• arrange(dept, desc(salary)) של dplyr הוא אותו מיון עם פחות סימני פיסוק.
• "10" ממוין לפני "2" בטקסט: בדקו את סוגי העמודות שלכם.

הבא בתור: כיווץ שורות לסיכומים לפי קבוצות עם table(), tapply(), aggregate() ו-group_by() של dplyr.