אופרטורים ב-R: חשבון, השוואה, לוגיקה, %in% ו-%%

האופרטורים ש-R נותן לכם

האופרטורים של R מתחלקים לארבע קבוצות עבודה: חשבון (+ - * / ^ %% %/%), השוואה (== != < <= > >=), לוגיקה (& | && || ! xor), ובדיקת השייכות %in%. שני דברים מבדילים אותם מרוב השפות: כמעט כולם וקטוריים, כלומר פועלים על וקטורים שלמים בבת אחת, איבר אחר איבר, ול-R יש שני אופרטורי AND ושני אופרטורי OR שאינם ניתנים להחלפה. העמוד הזה מכסה את כולם, ובנוסף את מלכודות הקדימות שמייצרות תשובות שגויות בשקט.

חשבון: +, -, *, /, ^, %% ו-%/%

חמשת הראשונים עושים את מה שמצפים. השניים העטופים בסימני אחוז, %% (מודולו, השארית) ו-%/% (חילוק שלמים, המנה), הם אלה שאנשים מחפשים:

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

שימו לב ש-/ תמיד מבצע חילוק בנקודה צפה: 17 / 5 הוא 3.4, אף פעם לא 3. אם אתם רוצים את החלק השלם, בדיוק בשביל זה קיים %/%.

העבודה היומיומית של %% היא התחלקות. מספר הוא זוגי כשחילוק ב-2 לא משאיר שארית:

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

כדאי לעצור על השורה השנייה: עם אופרנד שלילי, %% של R מחזיר תוצאה עם הסימן של המחלק (-7 %% 3 הוא 2, כי -7 = -3 * 3 + 2). יש שפות שעושות את זה הפוך; אם אתם מעבירים קוד משפה אחרת, בדקו.

אופרטורי השוואה הם וקטוריים

==, !=, <, <=, >, >= משווים איבר אחר איבר ומחזירים וקטור לוגי, לא תשובה אחת:

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

זה המנוע שמאחורי כמעט כל סינון ב-R: משווים וקטור שלם לערך, מקבלים מסכה לוגית ומשתמשים במסכה כדי לחתוך. זהירות אחת עם == על מספרים עשרוניים: מספרים בנקודה צפה מאוחסנים בקירוב, ולכן 0.1 + 0.2 == 0.3 הוא FALSE. להשוואות עשרוניות, העדיפו all.equal() או בדקו abs(x - y) < 1e-9.

אופרטורים לוגיים: & מול && (הבלבול הקלאסי)

ל-R יש שני אופרטורי AND ושני אופרטורי OR, ובחירה באופרטור הלא נכון היא טקס חניכה.

& ו-| הם וקטוריים. הם משלבים שני וקטורים לוגיים איבר אחר איבר:

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

השתמשו בהם בכל פעם שאתם בונים סינון על נתונים: df[df$age > 30 & df$city == "Lisbon", ].

&& ו-|| סקלריים ומבצעים קצר חשמלי. הם מקבלים ערכים בודדים, מחזירים TRUE/FALSE יחיד, ומדלגים לגמרי על האופרנד השני אם הראשון כבר מכריע את התשובה:

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

השורה השנייה מדגימה קצר חשמלי: מכיוון ש-x < 0 הוא FALSE, R לעולם לא מעריך את הקריאה ל-stop(). בדיוק בגלל זה && שייך לתנאי if(): אפשר לכתוב if (!is.na(x) && x > 10) והחלק x > 10 מדולג בבטחה כש-x הוא NA.

כלל האצבע: &/| לווקטורים ולסינון נתונים, &&/|| לתנאי if(). ומאז R 4.3, זה נאכף בתוקף: העברת וקטור באורך גדול מ-1 ל-&& או ל-|| היא שגיאה (גרסאות ישנות של R השתמשו בשקט רק באיבר הראשון, מה שהסתיר באגים אמיתיים במשך שנים).

xor(a, b) משלים את הסט: TRUE כשבדיוק אחד מהשניים הוא TRUE:

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in%: בדיקת שייכות

x %in% table שואל, עבור כל איבר של x, "האם הוא מופיע במקום כלשהו ב-table?". זה אחד האופרטורים הנפוצים ביותר בקוד R אמיתי:

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

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

הוא גם מנצח את החלופה שהייתם כותבים אחרת, שרשרת של == שמודבקת עם |:

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

עם חמישה ערכים מותרים, שרשרת ה-== הופכת לקיר של חזרות; בגרסת ה-%in% פשוט מגדילים את הווקטור. יש יתרון שני, עדין יותר: %in% לעולם לא מחזיר NA:

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 הוא NA כי R לא יכול לדעת אם ערך לא ידוע שווה ל-1, התנהגות שמוסברת לעומק בערכים חסרים. ה-NA הזה מרעיל אחר כך כל if() שהוא מגיע אליו. %in% עוקף את כל הבעיה כי הוא תמיד עונה TRUE או FALSE, ולכן הוא הבחירה הבטוחה יותר לתנאים על נתונים שעלולים להיות חסרים.

מלכודות קדימות

שתי מלכודות של קדימות אופרטורים אחראיות לחלק לא פרופורציונלי מרגעי "R שבור". ראשית, ^ נקשר חזק יותר ממינוס אונרי:

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

שנית, הנקודתיים נקשרות חזק יותר מחשבון בינארי:

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

כשיש ספק, הוסיפו סוגריים. הם לא עולים כלום, וכל קורא (כולל אתם בעתיד) מפרש אותם בדיוק כמו המפרש.

$ ו-[ ]: אופרטורי הגישה

תראו גם כל הזמן את $, [ ] ו-[[ ]], שמבחינה טכנית הם גם אופרטורים, ומשמשים לשליפת ערכים ממבנים ולא לחישוב איתם:

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

הם מקבלים כיסוי מלא בעמודים על וקטורים, רשימות ו-data frames. כאן מספיק לזהות אותם כחברים באותה משפחת אופרטורים.

מה לקחת מכאן

• %% נותן את השארית, %/% את המנה השלמה; x %% 2 == 0 בודק זוגיות.
• השוואות הן וקטוריות: הן מחזירות וקטור לוגי שאפשר לסנן איתו.
• &/| משלבים וקטורים איבר אחר איבר; &&/|| מיועדים לערכים בודדים ב-if() ומבצעים קצר חשמלי. מאז R 4.3, && על וקטור ארוך יותר הוא שגיאה.
• x %in% table מחליף == משורשרים ולעולם לא מחזיר NA.
• -2^2 הוא -4 ו-1:n - 1 מתחיל ב-0: הוסיפו סוגריים כשיש ספק.

בהמשך: הפעלת האופרטורים האלה בתוך if, else ו-ifelse(), משפטי התנאי של R.