R Academy · Aula

Avaliação organizada: {{ }} e .data

Escreva funções dplyr que aceitem nomes de colunas como argumentos com segurança.

Aula 4 de 413 etapas

Avaliação organizada: {{ }} e .data é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O problema: programar com dplyr

O dplyr usa avaliação não padrão (NSE) — os nomes das colunas são passados sem aspas. Isso é conveniente de forma interativa, mas pode ser complicado ao escrever funções. Como passar um nome de coluna como variável para uma função do dplyr?

library(dplyr)

df <- data.frame(x=1:5, y=c(2,4,6,8,10))

# Works fine interactively:
df %>% summarize(mean_x = mean(x))

# But what if 'x' is a variable?
col_name <- 'x'
# df %>% summarize(result = mean(col_name))  # WRONG! treats 'col_name' as column
cat('Need tidy evaluation to solve this!')

O operador de inclusão {{ }}

Dentro de uma função, use {{ col_var }} (chamado de “chaves duplas” ou “inclusão”) para passar um nome de coluna que será avaliado no contexto do quadro de dados. Essa é a abordagem recomendada para a maioria dos casos de programação de funções do dplyr.

library(dplyr)

df <- data.frame(
  group = c('A','A','B','B'),
  sales = c(100, 120, 200, 180),
  costs = c(60, 70, 110, 90)
)

# Function using {{ }}
group_mean <- function(data, group_col, value_col) {
  data %>%
    group_by({{ group_col }}) %>%
    summarize(mean_val = mean({{ value_col }}), .groups = 'drop')
}

group_mean(df, group, sales)
group_mean(df, group, costs)

{{ }} para nomes de colunas na saída

Você também pode usar {{ }} no lado esquerdo de := para nomear dinamicamente as colunas de saída. O operador := (operador morsa) permite nomes de variáveis no lado esquerdo de atribuições dentro dos verbos do dplyr.

library(dplyr)

df <- data.frame(a=1:4, b=c(2,4,6,8))

# Dynamic output column name
compute_mean <- function(data, col) {
  col_name <- paste0('mean_', deparse(substitute(col)))
  data %>% summarize('{col_name}' := mean({{ col }}))
}

compute_mean(df, a)
compute_mean(df, b)

O pronome .data

.data[['col_name']] permite selecionar uma coluna usando uma variável de texto. Ele informa explicitamente ao dplyr que deve procurar a coluna no quadro de dados atual. Isso é útil quando você tem nomes de colunas como textos.

library(dplyr)

df <- data.frame(
  name = c('Alice','Bob','Carol'),
  score = c(85, 92, 78),
  grade = c('B','A','C')
)

# Using .data with a string variable
get_summary <- function(data, col_name) {
  data %>%
    summarize(
      n = n(),
      mean_val = mean(.data[[col_name]])
    )
}

get_summary(df, 'score')

across() — Aplicar a várias colunas

across(cols, fns), dentro de mutate() ou summarize(), aplica uma função a várias colunas de uma só vez. Selecione colunas com auxiliares do tidyselect: starts_with(), where(is.numeric), everything() etc.

library(dplyr)

df <- data.frame(
  id = 1:3,
  sales_q1 = c(100, 200, 150),
  sales_q2 = c(120, 180, 160),
  cost_q1 = c(60, 110, 80),
  cost_q2 = c(70, 100, 85)
)

# Summarize all numeric columns except 'id'
df %>%
  summarize(across(where(is.numeric) & !id, mean))

across() com funções nomeadas

Passe uma lista nomeada de funções para across() a fim de calcular várias estatísticas por coluna. As colunas de saída recebem nomes no formato col_fn. Use .names para personalizar o padrão de nomenclatura.

library(dplyr)

df <- data.frame(
  x = c(10, 20, 30, 40),
  y = c(5, 15, 25, 35)
)

# Compute mean and sd for both columns
df %>%
  summarize(across(
    c(x, y),
    list(mean = mean, sd = sd),
    .names = '{.col}_{.fn}'
  ))

across() em mutate()

Usar across() dentro de mutate() transforma várias colunas simultaneamente. Isso evita repetir a mesma transformação para cada coluna individualmente.

library(dplyr)

df <- data.frame(
  id = 1:3,
  revenue = c(1000, 2000, 1500),
  cost = c(600, 1100, 800),
  tax = c(100, 200, 150)
)

# Round all numeric columns except id to nearest 10
df %>%
  mutate(across(where(is.numeric) & !id,
                ~round(., -2)))

pick() — Selecionar colunas para operações

pick() (dplyr 1.1+) seleciona um subconjunto de colunas como um pequeno quadro de dados, útil para passá-lo a funções que esperam um quadro de dados. Funciona dentro de mutate() e summarize().

library(dplyr)

df <- data.frame(
  id = 1:3,
  a = c(1, 2, 3),
  b = c(4, 5, 6),
  c_val = c(7, 8, 9)
)

# Use pick() to compute row-wise mean across selected columns
df %>%
  mutate(
    row_mean = rowMeans(pick(a, b, c_val)),
    row_max = do.call(pmax, pick(a, b, c_val))
  )

Escrever funções reutilizáveis do dplyr

Combinar {{ }}, .data[[]] e across() permite escrever funções de análise reutilizáveis e poderosas. O padrão principal é aceitar nomes de colunas como argumentos sem aspas (use {{ }}) ou como textos (use .data[[]]).

library(dplyr)

df <- data.frame(
  region = c('East','East','West','West'),
  product = c('A','B','A','B'),
  revenue = c(100, 200, 150, 250),
  units = c(10, 15, 12, 20)
)

# Flexible grouped summary function
group_stats <- function(data, ..., metric) {
  data %>%
    group_by(...) %>%
    summarize(
      total = sum({{ metric }}),
      average = mean({{ metric }}),
      .groups = 'drop'
    )
}

group_stats(df, region, metric = revenue)
group_stats(df, region, product, metric = units)

Auxiliares de seleção organizada

Os auxiliares do tidyselect funcionam dentro de across(), select() e pick(): starts_with(), ends_with(), contains(), matches(), num_range(), where(predicate) e everything().

library(dplyr)

df <- data.frame(
  id = 1:3,
  score_2022 = c(80,85,90),
  score_2023 = c(82,88,91),
  score_2024 = c(85,90,93),
  category = c('A','B','A')
)

# Select all score columns and compute their means
df %>%
  summarize(
    across(starts_with('score'), mean),
    n = n()
  )

Combinar padrões de avaliação organizada

As funções do dplyr usadas no mundo real costumam combinar {{ }} para variáveis de agrupamento, across() para várias métricas e .data[[]] para nomes de colunas em texto. Entender quando usar cada padrão torna seu código flexível e correto.

library(dplyr)

df <- data.frame(
  dept = c('HR','HR','Eng','Eng'),
  salary = c(60000, 65000, 100000, 110000),
  bonus = c(5000, 6000, 15000, 18000)
)

# String-based column selection with .data
summarize_column <- function(data, group_col, value_col_name) {
  data %>%
    group_by(.data[[group_col]]) %>%
    summarize(
      mean = mean(.data[[value_col_name]]),
      total = sum(.data[[value_col_name]]),
      .groups = 'drop'
    )
}

summarize_column(df, 'dept', 'salary')
summarize_column(df, 'dept', 'bonus')

Verificação rápida

Dentro de uma função personalizada, qual é a forma correta de passar um nome de coluna como argumento sem aspas para o dplyr?

Responda na aula interativa

Recapitulação: avaliação organizada

Principais pontos sobre programação com dplyr:

{{ col }} — incluir argumentos de nomes de colunas sem aspas em funções
.data[['col_name']] — acessar colunas pelo nome em uma variável de texto
Operador morsa := — usar com {{ }} ou textos interpolados para nomes de saída dinâmicos
across(cols, fns) — aplicar função ou funções a várias colunas de uma só vez
pick(cols) — selecionar colunas como um subquadro de dados para operações por linha
Auxiliares do tidyselect: starts_with(), where(), contains(), everything()

library(dplyr)

df <- data.frame(
  group = c('A','A','B','B'),
  v1 = c(10, 20, 30, 40),
  v2 = c(5, 15, 25, 35)
)

# Reusable function using {{ }} + across
group_summary <- function(data, grp) {
  data %>%
    group_by({{ grp }}) %>%
    summarize(across(where(is.numeric), list(mean=mean, sum=sum)), .groups='drop')
}

group_summary(df, group)

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Avaliação organizada: {{ }} e .data” é grátis?

Sim — o texto completo de “Avaliação organizada: {{ }} e .data” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Avaliação organizada: {{ }} e .data”?

Escreva funções dplyr que aceitem nomes de colunas como argumentos com segurança. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Avaliação organizada: {{ }} e .data”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy