סוגי נתונים ב-R: numeric, character, logical (typeof ו-class)

סוגי הנתונים ב-R

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

• double: מספרים עשרוניים: 3.14, -2, 1e6. לזה R מתכוונת כשהיא אומרת "numeric", וזו ברירת המחדל לכל מספר שאתם מקלידים.
• integer: מספרים שלמים שמאוחסנים במדויק, ונכתבים עם הסיומת L: 42L.
• character: טקסט במירכאות: "hello".
• logical: שני ערכי האמת TRUE ו-FALSE (ועוד NA, הערך החסר; ראו ערכים חסרים).

יש גם complex (2 + 3i) לחישובים מזדמנים של עיבוד אותות; אפשר לעבור שנים בלי להזדקק לו. typeof() אומרת לכם מאיזה סוג ערך מסוים:

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

שימו לב לשורה הראשונה: מספר רגיל הוא double גם אם הוא נראה שלם. typeof(42) הוא "double"; רק 42L הוא integer. בניתוח יומיומי ההבדל כמעט לא משנה, R ממירה ביניהם בשקט, אבל הוא מסביר הרבה פלט מבלבל של typeof().

typeof() מול class(): למה הן לא מסכימות

ב-R יש שתי פונקציות ששתיהן נראות כאילו הן עונות על "מה זה?", והן עונות על שאלות שונות במעט.

• typeof() מדווחת על סוג האחסון: איך הערך יושב בזיכרון.
• class() מדווחת על סוג ההתנהגות: התווית שבה מנגנון בחירת המתודות של R משתמש כדי להחליט, למשל, איזה print או summary להריץ.

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

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() אומרת double (האחסון), class() אומרת numeric (ההתנהגות). עבור מבנים הפער גדל:

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

המטריצה מאוחסנת כווקטור integer רגיל, אבל היא מתנהגת כמטריצה: class() היא מה שאומר ל-R להדפיס אותה כרשת. אותה חלוקה מופיעה ב-data frames (typeof אומרת "list", class אומרת "data.frame") ובתאריכים (typeof אומרת "double", class אומרת "Date").

הכלל המעשי: השתמשו ב-class() כשאתם רוצים לדעת מה משהו הוא במובן היומיומי, וב-typeof() כשאתם מנפים באגים במה ש-R עושה מתחת למכסה המנוע.

בדיקת סוגים עם is.*()

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

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

מלכודת אחת שכדאי להכיר: is.numeric() מחזירה TRUE גם עבור doubles וגם עבור integers (שניהם מספרים), אבל is.integer() בודקת את האחסון, ולכן היא FALSE עבור 42 רגיל:

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

אם אי פעם הופתעתם ש-is.integer(7) הוא FALSE עבור מספר שהוא כמובן שלם במובן המתמטי, זו הסיבה. 7 הוא double; 7L הוא integer.

המרת סוגים עם as.*()

המרה מפורשת משתמשת במשפחת as.*, פונקציה אחת לכל סוג יעד:

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

שתי התנהגויות שכדאי לזכור. as.integer() קוטעת לכיוון האפס במקום לעגל: 7.9 הופך ל-7. וכשהמרה חסרת היגיון, R לא זורקת שגיאה; היא מחזירה NA ומוציאה אזהרה:

result <- as.numeric("abc")
print(result)

הריצו את זה ותראו NA ועוד אזהרה "NAs introduced by coercion". זה שימושי באמת: המירו עמודה שלמה של טקסט מבולגן למספרים, והערכים שאי אפשר לפענח יהפכו ל-NA במקום להפיל את הסקריפט. אבל זה גם אומר ש-NA שקט יכול לחמוק לתוך הנתונים שלכם. כשהמרה חשובה, בדקו אחריה אם הופיעו ערכי NA חדשים.

ערכים לוגיים מומרים למספרים וממספרים כמו שהייתם מקווים: as.numeric(TRUE) הוא 1, as.logical(0) הוא FALSE. זו הסיבה ש-sum() של וקטור לוגי סופרת את ה-TRUE:

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

כפיית סוג מרומזת: כלל הסוג האחד בווקטורים

וקטור אטומי ב-R יכול להכיל סוג אחד בלבד. שלבו ערכים מעורבים עם c(), ו-R תקדם בשקט הכול לסוג הגמיש ביותר שקיים, לפי סולם קבוע:

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

הערכים הלוגיים הפכו ל-1 ו-0, ה-integers הפכו ל-doubles, ובשורה האחרונה הכול הפך לטקסט: character תמיד מנצח, כי כל ערך אפשר לכתוב כמחרוזת. אפשר לוודא עם typeof():

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

כפיית סוג היא המקור מספר אחת לבאגים מסוג "למה העמודה שלי היא טקסט?": מחרוזת "N/A" תועה אחת בעמודה של מספרים כופה על כל הווקטור להיות character. כשזה קורה, תקנו קודם את הערך הבעייתי, ואז המירו חזרה עם as.numeric().

מה לקחת מכאן

• ארבעה סוגים עיקריים: double ("numeric"), integer (42L), character, logical.
• typeof() = איך זה מאוחסן; class() = איך זה מתנהג. 3.14 הוא double שמתנהג כ-numeric.
• בדקו עם is.numeric() וחברותיה; המירו עם as.numeric() וחברותיה: המרות שנכשלו נותנות NA עם אזהרה, לא שגיאה.
• וקטורים מכילים סוג אחד בלבד; ערבוב כופה סוג לאורך logical → integer → double → character.

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