Операторы R: арифметические, сравнения, логические, %in% и %%

Какие операторы даёт R

Операторы R распадаются на четыре рабочие группы: арифметические (+ - * / ^ %% %/%), сравнения (== != < <= > >=), логические (& | && || ! xor) и проверка вхождения %in%. Две вещи отличают их от большинства языков: почти все они векторизованы — работают сразу над целыми векторами, поэлементно, — и в R есть два оператора И и два оператора ИЛИ, которые не взаимозаменяемы. Эта страница разбирает все из них, а также ловушки приоритета, дающие тихо неверные ответы.

Арифметика: +, -, *, /, ^, %% и %/%

Первые пять делают то, что вы ожидаете. Два оператора в процентах — %% (остаток) и %/% (целочисленное деление, частное) — это как раз то, что люди ищут:

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 два оператора И и два оператора ИЛИ, и выбор неправильного — обряд посвящения.

& и | векторизованы. Они комбинируют два логических вектора поэлементно:

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, когда ровно одно из двух истинно:

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 не может знать, равно ли неизвестное значение единице, — это поведение подробно разобрано в статье про пропущенные значения. Затем этот 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 [[ ]]

Они подробно разобраны на страницах про векторы, списки и датафреймы — здесь достаточно узнавать их как членов того же семейства операторов.

Что вы уносите с собой

• %% даёт остаток, %/% — целую часть частного; x %% 2 == 0 проверяет чётность.
• Сравнения векторизованы — они возвращают логический вектор, которым можно фильтровать.
• &/| комбинируют векторы поэлементно; &&/|| — для одиночных значений в if() и с сокращённым вычислением. Начиная с R 4.3, && на векторе длиннее 1 — ошибка.
• x %in% table заменяет цепочки == и никогда не возвращает NA.
• -2^2 это -4, а 1:n - 1 начинается с 0 — сомневаетесь, ставьте скобки.

Дальше: как заставить эти операторы работать внутри if, else и ifelse() — условных конструкций R.