apply, lapply, sapply no R: A Família apply Explicada

A Família apply em Uma Frase

Todo membro da família apply faz o mesmo trabalho: pegar uma função e rodá-la sobre cada elemento de alguma estrutura, coletando os resultados. O que varia é o formato da entrada e o formato da saída. O mapa:

• apply(m, MARGIN, FUN) - linhas ou colunas de uma matriz.
• lapply(x, FUN) - cada elemento de uma lista ou vetor; sempre retorna uma lista.
• sapply(x, FUN) - igual a lapply, e depois simplifica para um vetor ou matriz quando dá.
• vapply(x, FUN, FUN.VALUE) - o sapply com um tipo de retorno declarado e obrigatório.
• mapply(FUN, x, y, ...) - percorre várias entradas em paralelo, elemento a elemento.
• tapply(values, groups, FUN) - aplica FUN dentro de cada grupo: um resultado por grupo.

Todas aceitam as funções que você mesmo escreve, inclusive anônimas, e é daí que a família tira seu poder.

apply(): Linhas e Colunas de uma Matriz

apply recebe uma matriz, uma MARGIN (1 para linhas, 2 para colunas) e uma função:

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

A matriz é preenchida coluna por coluna, então as linhas são 1 3 5 e 2 4 6: as somas por linha saem como 9 12 e as somas por coluna como 3 7 11. Para os dois casos mais comuns o R base traz auxiliares dedicados e mais rápidos - rowSums, colSums, rowMeans, colMeans - então reserve apply para funções que não têm um equivalente, como apply(m, 2, max).

Uma armadilha: apply sobre um data frame o converte silenciosamente para matriz antes, o que força todas as colunas a um tipo comum. Para data frames, trate as colunas como uma lista e use lapply/sapply.

lapply() Sempre Dá uma Lista, sapply() Simplifica

lapply mapeia uma função sobre cada elemento e retorna uma lista do mesmo comprimento, aconteça o que acontecer:

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

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

Mesmo cálculo, dois formatos: lapply devolve uma lista contendo 85 e 80; sapply percebe que todo resultado tem comprimento 1 e simplifica para um vetor numérico nomeado - muito mais agradável de ler e de alimentar cálculos seguintes.

A conveniência tem um fio afiado, porém: o tipo de retorno do sapply depende dos dados. Se apenas um elemento produzir um comprimento diferente, a simplificação falha e você silenciosamente recebe uma lista de novo:

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

No modo interativo isso é um dar de ombros; dentro de um script significa código que funcionou o ano todo quebrando no dia em que os dados mudam de formato. É exatamente por isso que o vapply existe.

vapply(): O sapply Seguro Quanto a Tipos

vapply acrescenta um terceiro argumento, FUN.VALUE: um modelo declarando como um resultado deve ser. integer(1) significa "cada chamada retorna exatamente um inteiro":

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

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

Você recebe um vetor de inteiros nomeado - 5 6 6 - e, mais importante, uma garantia: se nchar algum dia retornasse dois valores ou um caractere, vapply pararia com um erro no local da chamada em vez de deixar um resultado malformado seguir adiante. A declaração serve também de documentação:

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

Regra prática: sapply no console, vapply em funções e scripts que precisam rodar sem supervisão.

mapply() e tapply(): Entradas Paralelas e Grupos

lapply percorre uma estrutura. Quando cada chamada precisa de um elemento de várias estruturas em posições correspondentes, use mapply - repare que a função vem primeiro:

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

Cada elemento da saída combina os primeiros valores, depois os segundos, e assim por diante: 10 200 3000 40000.

tapply é o membro voltado a grupos: ele divide values por groups e aplica a função dentro de cada grupo, retornando um resultado por grupo:

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

print(tapply(values, groups, mean))

O grupo a tem média 30, o grupo b tem média 40. Essa é a resposta do R base para "média por categoria" - o mesmo formato de pergunta que group_by + summarize responde para data frames, então se você já está em território dplyr use aquilo; tapply brilha quando você tem dois vetores soltos e quer uma linha só.

Duas conveniências valem para a família inteira. Argumentos extras depois da função são encaminhados a ela em toda chamada:

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))

E funções anônimas se encaixam sempre que nenhuma função pronta serve - sapply(x, \(v) max(v) - min(v)) calcula uma amplitude por elemento sem precisar nomear um auxiliar antes.

Família apply vs Laços for

Você vai ouvir que laços for são lentos no R e que a família apply é rápida. Isso é, em boa parte, mito. O que é genuinamente lento é fazer um resultado crescer dentro de um laço - result <- c(result, new_value) copia o vetor inteiro a cada passagem. Um laço que pré-aloca sua saída tem bom desempenho:

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

Então escolha por legibilidade, não por desempenho. A versão com apply diz o quê em uma linha - "eleve cada elemento ao quadrado" - e cuida da alocação por você, e é por isso que ela é o idioma para trabalho direto elemento a elemento. Um laço for se justifica quando as iterações dependem de resultados anteriores, quando você precisa de saídas antecipadas com break, ou quando o corpo é longo o bastante para que um lambda atrapalhe mais do que ajude. Os dois são R legítimo.

O Que Você Leva Daqui

• A família inteira é uma ideia só: rodar uma função sobre cada elemento e coletar os resultados.
• apply é para linhas (MARGIN = 1) e colunas (MARGIN = 2) de matrizes; prefira rowSums/colMeans quando existirem.
• lapply sempre retorna uma lista; sapply simplifica quando pode - o que significa que seu tipo de retorno pode mudar com os dados.
• vapply trava o tipo de retorno; use-o em código que não pode te surpreender.
• mapply combina várias entradas em paralelo; tapply agrega valores dentro de grupos.
• Laços for não são lentos por natureza - fazer vetores crescerem é. Escolha a grafia que se lê melhor.

A seguir: pipes - o operador que encadeia essas chamadas em pipelines legíveis, passo a passo.