apply, lapply, sapply в R: семейство apply

Семейство apply в одном предложении

Каждый член семейства apply делает одну и ту же работу: берёт функцию и прогоняет её по каждому элементу некоторой структуры, собирая результаты. Различаются форма входа и форма выхода. Карта семейства:

• apply(m, MARGIN, FUN) — строки или столбцы матрицы.
• lapply(x, FUN) — каждый элемент списка или вектора; всегда возвращает список.
• sapply(x, FUN) — то же, что lapply, но затем упрощает до вектора или матрицы, когда может.
• vapply(x, FUN, FUN.VALUE) — sapply с объявленным и проверяемым типом возврата.
• mapply(FUN, x, y, ...) — идёт по нескольким входам параллельно, элемент за элементом.
• tapply(values, groups, FUN) — применяет FUN внутри каждой группы: один результат на группу.

Все они принимают функции, которые вы пишете сами, включая анонимные, — отсюда и берётся сила семейства.

apply(): строки и столбцы матрицы

apply принимает матрицу, MARGIN (1 для строк, 2 для столбцов) и функцию:

m <- matrix(1:6, nrow = 2)
print(m)

print(apply(m, 1, sum))   # one sum per row
print(apply(m, 2, sum))   # one sum per column

Матрица заполняется по столбцам, поэтому строки это 1 3 5 и 2 4 6: суммы по строкам печатаются как 9 12, а по столбцам — как 3 7 11. Для двух самых частых случаев базовый R поставляет специальные, более быстрые помощники — rowSums, colSums, rowMeans, colMeans, — так что берегите apply для функций, у которых такого помощника нет, вроде apply(m, 2, max).

Одна ловушка: apply на датафрейме молча сначала преобразует его в матрицу, что приводит все столбцы к одному общему типу. Для датафреймов относитесь к столбцам как к списку и используйте lapply/sapply.

lapply() всегда даёт список, sapply() упрощает

lapply отображает функцию на каждый элемент и возвращает список той же длины, что бы ни случилось:

scores <- list(math = c(80, 90), art = c(70, 75, 95))

print(lapply(scores, mean))
print(sapply(scores, mean))

Одно и то же вычисление, две формы: lapply возвращает список с 85 и 80; sapply замечает, что каждый результат имеет длину 1, и упрощает до именованного числового вектора — гораздо приятнее читать и подавать дальше в вычисления.

Однако у удобства острый край: тип возврата sapply зависит от данных. Если хотя бы один элемент даст другую длину, упрощение не удастся, и вы молча снова получите список:

uneven <- list(a = 1:2, b = 1:3)

result <- sapply(uneven, function(x) x * 10)
print(class(result))                          # could not simplify: still a list

print(sapply(1:3, function(x) x * 10))        # lengths match: a numeric vector

В интерактивной работе на это можно пожать плечами; внутри скрипта это означает, что код, работавший весь год, ломается в день, когда данные сменили форму. Ровно ради этого и существует vapply.

vapply(): типобезопасный sapply

vapply добавляет третий аргумент, FUN.VALUE, — шаблон, объявляющий, как должен выглядеть один результат. integer(1) означает «каждый вызов возвращает ровно одно целое число»:

words <- c("apply", "lapply", "sapply")

print(vapply(words, nchar, integer(1)))

Вы получаете именованный целочисленный вектор — 5 6 6 — и, что важнее, гарантию: если бы nchar когда-нибудь вернула два значения или строку, vapply остановилась бы с ошибкой прямо в месте вызова, а не пустила бы результат неправильной формы дальше по коду. Объявление заодно служит документацией:

vapply(words, nchar, character(1))
# Error in vapply(words, nchar, character(1)) : values must be type 'character'

Правило большого пальца: sapply в консоли, vapply в функциях и скриптах, которые должны работать без присмотра.

mapply() и tapply(): параллельные входы и группы

lapply идёт по одной структуре. Когда каждому вызову нужен элемент из нескольких структур на совпадающих позициях, используйте mapply — обратите внимание, что функция идёт первой:

print(mapply(function(a, b) a * b, 1:4, c(10, 100, 1000, 10000)))

Каждый элемент вывода объединяет первые значения, затем вторые и так далее: 10 200 3000 40000.

tapply — групповой член семейства: она разбивает values по groups и применяет функцию внутри каждой группы, возвращая по одному результату на группу:

values <- c(10, 20, 30, 40, 50, 60)
groups <- c("a", "b", "a", "b", "a", "b")

print(tapply(values, groups, mean))

Группа a в среднем даёт 30, группа b — 40. Это ответ базового R на вопрос «среднее по категории» — тот же тип вопроса, на который для датафреймов отвечает group_by + summarize; если вы уже в мире dplyr, используйте его, а tapply блистает, когда у вас два голых вектора и нужна одна строка.

Два удобства работают во всём семействе. Дополнительные аргументы после функции пробрасываются в неё на каждом вызове:

readings <- list(c(3.14159, 2.71828), c(1.41421))

print(sapply(c(3.14159, 2.71828), round, digits = 2))
print(lapply(readings, round, digits = 1))

А анонимные функции вставляются всякий раз, когда готовая функция не подходит: sapply(x, \(v) max(v) - min(v)) вычисляет размах для каждого элемента, не требуя сначала называть вспомогательную функцию.

Семейство apply против циклов for

Вам скажут, что циклы for в R медленные, а семейство apply быстрое. По большей части это миф. По-настоящему медленным является наращивание результата внутри цикла — result <- c(result, new_value) копирует весь вектор на каждом проходе. Цикл, заранее выделяющий свой выход, работает нормально:

squares <- numeric(10)            # pre-allocate, then fill
for (i in 1:10) {
  squares[i] <- i^2
}
print(squares)

print(sapply(1:10, \(i) i^2))     # same result as an expression

Так что выбирайте по читаемости, а не по производительности. Версия с apply говорит что в одну строку — «возведи каждый элемент в квадрат» — и берёт выделение памяти на себя, поэтому она и является идиомой для прямолинейной поэлементной работы. Цикл for окупается, когда итерации зависят от предыдущих результатов, когда нужны досрочные выходы через break или когда тело настолько длинное, что лямбда только навредит. Оба варианта — законный R.

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

• Всё семейство — одна идея: прогнать функцию по каждому элементу и собрать результаты.
• apply предназначена для строк матрицы (MARGIN = 1) и столбцов (MARGIN = 2); предпочитайте rowSums/colMeans, когда они существуют.
• lapply всегда возвращает список; sapply упрощает, когда может, — а значит, её тип возврата может меняться вместе с данными.
• vapply фиксирует тип возврата; используйте её в коде, который не должен вас удивлять.
• mapply сшивает несколько входов вместе; tapply агрегирует значения внутри групп.
• Циклы for не медленные по своей природе — медленно растут векторы. Выбирайте написание, которое читается лучше.

Дальше: пайпы — оператор, который сцепляет эти вызовы в читаемые пошаговые конвейеры.