וקטורים ב-R: c(), seq(), אינדקסים וחישוב וקטורי

ב-R הכול וקטור

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

scores <- c(70, 85, 92)
print(scores)
print(length(scores))

print(is.vector(5))
print(length(5))

c(), קיצור של combine, היא הדרך לבנות וקטור ביד. length() אומרת כמה איברים הוא מחזיק. ו-5 לבדו מדווח is.vector כ-TRUE עם אורך 1: R אף פעם לא מפסיקה לעבוד עם וקטורים, היא רק לפעמים עובדת עם וקטורים קצרים מאוד.

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

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

mixed <- c(1, "two", TRUE)
print(mixed)
print(class(mixed))

numish <- c(1, TRUE, FALSE)
print(numish)
print(class(numish))

מחרוזת בתערובת הופכת הכול למחרוזות ("1", "TRUE"). ערכים לוגיים בין מספרים הופכים ל-1 ו-0. ההמרה הכפויה (coercion) הזאת עוקבת אחרי סדר עדיפויות קבוע, logical → integer → double → character, והיא קורית בלי אזהרה, ולכן "7" תועה בעמודה של מספרים יכול להפוך בשקט את כל מאגר הנתונים שלכם לטקסט. ההיררכיה המלאה מוסברת ב-סוגי נתונים; אם צריך להחזיק ערכים מעורבים באמת, בשביל זה יש רשימות.

יצירת סדרות: :, seq() ו-rep()

הקלדת כל איבר לתוך c() נמאסת מהר. ל-R יש שלושה קיצורי דרך לדפוסים קבועים:

print(1:10)
print(seq(0, 1, by = 0.25))
print(seq(2, 20, length.out = 4))
print(seq_len(5))

print(rep("ha", 3))
print(rep(c(1, 2), times = 3))
print(rep(c(1, 2), each = 3))

• 1:10 הוא היומיומי: מספרים שלמים מגבול אחד לשני, בקפיצות של 1.
• seq() מכליל אותו: בחרו את הקפיצה עם by =, או אמרו כמה איברים אתם רוצים עם length.out = ותנו ל-R לחשב את המרווחים.
• seq_len(n) מפיק 1 עד n והוא הדרך הבטוחה לבנות אינדקסים ללולאה: בניגוד ל-1:n, הוא נותן כראוי וקטור ריק כש-n הוא 0, במקום לספור 1 0 אחורה.
• rep() חוזר על דברים: times = חוזר על כל הווקטור מקצה לקצה (1 2 1 2 1 2), each = חוזר על כל איבר במקומו (1 1 1 2 2 2). קל לבלבל ביניהם; הריצו את הקטע והשוו.

אינדקסים: R סופרת מ-1

סוגריים מרובעים שולפים איברים. האיבר הראשון הוא [1], לא [0]. אם אתם מגיעים מ-Python או מ-JavaScript, זו המעידה הנפוצה ביותר בהתחלה:

fruits <- c("apple", "banana", "cherry", "date")

print(fruits[1])
print(fruits[c(2, 4)])
print(fruits[-1])
print(fruits[-c(1, 2)])

שלושה דברים כאן ששווה לעצור עליהם:

• אפשר לבחור לפי וקטור של מיקומים: fruits[c(2, 4)] שולף את השני ואת הרביעי במכה אחת.
• אינדקסים שליליים פירושם "הכול חוץ מ". fruits[-1] הוא הווקטור בלי האיבר הראשון שלו. זה שונה לגמרי מ-Python, שם -1 פירושו האיבר האחרון. אי אפשר לערבב אינדקסים חיוביים ושליליים באותה קריאה.
• fruits[0] אינו שגיאה: הוא מחזיר character(0) ריק. באג של טעות באחד ב-R מפיק לעיתים קרובות תוצאות ריקות ושקטות ולא קריסה, ולכן כדאי לבדוק length() כשמשהו בהמשך נראה ריק באופן מסתורי.

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

prices <- c(coffee = 3.5, tea = 2.8, juice = 4.2)
print(prices["tea"])
print(prices[c("coffee", "juice")])
print(names(prices))

וקטורים עם שמות עובדים כמו טבלת חיפוש קלה ושומרים על קוד קריא: prices["tea"] אומר את מה שהוא מתכוון, prices[2] לא.

מסכות לוגיות ו-which()

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

temps <- c(18, 25, 31, 22, 35)

hot <- temps > 24
print(hot)
print(temps[hot])

print(temps[temps > 24 & temps < 33])
print(which(temps > 24))

temps > 24 לא נותן תשובה אחת: הוא נותן חמש, אחת לכל איבר. הצבת המסכה הזאת בתוך [ ] משאירה את האיברים שבהם המסכה היא TRUE. שלבו תנאים עם & (וגם) ו-| (או), שמוסברים עם שאר ה-אופרטורים.

which() מתרגמת מסכה למיקומים: כאן 2 3 5, האינדקסים של המדידות החמות. השתמשו בה כשצריך לדעת איפה ההתאמות נמצאות: כדי לדווח עליהן, או כדי לבחור מווקטור אחר באותם מקומות. לסינון פשוט, temps[temps > 24] ישיר יותר מ-temps[which(temps > 24)].

דפוס הסינון עם מסכה הוא עמוד השדרה של כמעט כל עבודת נתונים ב-R: הוא חוזר ישר כשמסננים שורות של data frame.

חישוב וקטורי וכלל המחזור

חשבון ב-R חל איבר אחר איבר על וקטורים שלמים, בלי צורך בלולאה:

prices <- c(10, 20, 30)

print(prices * 2)
print(prices + c(1, 2, 3))
print(c(1, 2, 3, 4) + c(10, 20))

השורה הראשונה היא התכונה המרכזית: prices * 2 מכפיל כל איבר. במקום ששפות אחרות צריכות לולאת for, R צריכה אופרטור, והצורה הווקטורית גם קצרה יותר וגם מהירה יותר, כי הלולאה קורית בקוד C ממוטב מתחת לפני השטח. כתבו לולאת for כשכל שלב תלוי בקודם; לחישוב איבר אחר איבר, עבדו וקטורית.

השורה השלישית מדגימה את כלל המחזור: כשלווקטורים יש אורכים שונים, R חוזרת על הקצר כדי להתאים. c(10, 20) ממוחזר ל-10 20 10 20, ונותן 11 22 13 24. מחזור של 2 על פני וקטור באורך 3 הוא בדיוק מה שגרם ל-prices * 2 לעבוד: סקלר הוא פשוט וקטור באורך 1 שממוחזר.

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

print(c(1, 2, 3) + c(10, 20))

מקבלים 11 22 13 ועוד אזהרה שאורך האובייקט הארוך אינו כפולה של אורך האובייקט הקצר. התייחסו לאזהרה הזאת כאל דיווח על באג: מחזור חלקי כמעט אף פעם אינו מה שהתכוונתם, ובדרך כלל הוא אומר ששני וקטורים שהיו אמורים להיות באותו אורך אינם כאלה.

מיון, היפוך, הסרת כפילויות

שלושה כלים קטנים שתשתמשו בהם כל הזמן:

x <- c(3, 1, 4, 1, 5)

print(sort(x))
print(sort(x, decreasing = TRUE))
print(rev(x))
print(unique(x))

sort() מסדרת את הערכים, rev() הופכת את הסדר הקיים בלי למיין, ו-unique() משמיטה כפילויות ושומרת את ההופעות הראשונות. אף אחת מהן לא משנה את x: כמו כמעט כל דבר ב-R, הן מחזירות וקטור חדש ומשאירות את המקור בשקט.

מה לקחת מכאן

• וקטור הוא יחידת הבסיס של R: מסודר, מסוג אחד לכל אורכו, ואפילו ערכים בודדים הם וקטורים באורך 1.
• בנו עם c(), ייצרו דפוסים עם :, seq() ו-rep(), וזכרו ש-c() ממירה בשקט סוגים מעורבים.
• האינדקסים מתחילים מ-1; אינדקסים שליליים משמיטים איברים; שמות מאפשרים לבחור לפי תווית.
• מסכות לוגיות (x[x > 5]) הן דרך הסינון של כל השפה; which() הופכת מסכה למיקומים.
• החישוב וקטורי, וקטורים קצרים יותר ממוחזרים, ואזהרת מחזור חלקי אומרת שיש לכם באג.

הבא בתור: רשימות. המכל למקרים שבהם הערכים שלכם לא כולם מאותו סוג.