Tidy Evaluation: {{ }} und .data
Schreiben Sie dplyr-Funktionen, die Spaltennamen sicher als Argumente akzeptieren.
Tidy Evaluation: {{ }} und .data ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Das Problem: Programmieren mit dplyr
dplyr verwendet non-standard evaluation (NSE) — Spaltennamen werden ohne Anführungszeichen übergeben. Das ist bei interaktiver Verwendung praktisch, kann aber beim Schreiben von Funktionen kompliziert sein. Wie übergeben Sie einen Spaltennamen als Variable an eine dplyr-Funktion?
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!')Der {{ }}-Embrace-Operator
Verwenden Sie innerhalb einer Funktion {{ col_var }} (auch „curly-curly“ oder „embrace“ genannt), um einen Spaltennamen zu übergeben, der im Kontext des Data Frames ausgewertet wird. Dies ist für die meisten dplyr-Funktionen die empfohlene Vorgehensweise beim Programmieren.
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){{ }} für Spaltennamen in der Ausgabe
Sie können {{ }} auch auf der linken Seite von := verwenden, um Ausgabespalten dynamisch zu benennen. Der Operator := (Walross-Operator) ermöglicht Variablennamen auf der linken Seite von Zuweisungen innerhalb von dplyr-Verben.
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)Das .data-Pronomen
Mit .data[['col_name']] können Sie eine Spalte mithilfe einer String-Variablen auswählen. Dadurch weisen Sie dplyr ausdrücklich an, die Spalte im aktuellen Data Frame nachzuschlagen. Das ist nützlich, wenn Ihnen Spaltennamen als Zeichenketten vorliegen.
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() — Auf mehrere Spalten anwenden
across(cols, fns) innerhalb von mutate() oder summarize() wendet gleichzeitig eine Funktion auf mehrere Spalten an. Wählen Sie Spalten mit tidyselect-Hilfsfunktionen aus: starts_with(), where(is.numeric), everything() usw.
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() mit benannten Funktionen
Übergeben Sie across() eine benannte Liste von Funktionen, um mehrere Statistiken pro Spalte zu berechnen. Die Ausgabespalten werden als col_fn benannt. Mit .names können Sie das Benennungsmuster anpassen.
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() in mutate()
Wenn Sie across() innerhalb von mutate() verwenden, werden mehrere Spalten gleichzeitig transformiert. Dadurch müssen Sie dieselbe Transformation nicht für jede Spalte einzeln wiederholen.
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() — Spalten für Operationen auswählen
pick() (dplyr 1.1+) wählt eine Teilmenge von Spalten als kleinen Data Frame aus. Das ist nützlich, wenn Sie diese an Funktionen übergeben möchten, die einen Data Frame erwarten. Die Funktion kann innerhalb von mutate() und summarize() verwendet werden.
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))
)Wiederverwendbare dplyr-Funktionen schreiben
Durch die Kombination von {{ }}, .data[[]] und across() können Sie leistungsfähige, wiederverwendbare Analysefunktionen schreiben. Das grundlegende Muster: Akzeptieren Sie Spaltennamen als Argumente ohne Anführungszeichen (verwenden Sie {{ }}) oder als Zeichenketten (verwenden Sie .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)Hilfsfunktionen für tidyselect
tidyselect-Hilfsfunktionen funktionieren innerhalb von across(), select() und pick(): starts_with(), ends_with(), contains(), matches(), num_range(), where(predicate) und 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()
)Tidy-Eval-Muster kombinieren
Funktionen aus der Praxis kombinieren häufig {{ }} für Gruppierungsvariablen, across() für mehrere Kennzahlen und .data[[]] für Spaltennamen als Zeichenketten. Wenn Sie wissen, wann welches Muster verwendet wird, können Sie flexiblen und korrekten Code schreiben.
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')Schnelltest
Wie übergeben Sie innerhalb einer eigenen Funktion einen Spaltennamen korrekt als Argument ohne Anführungszeichen an dplyr?
Zusammenfassung: Tidy Evaluation
Die wichtigsten Punkte zum Programmieren mit dplyr:
{{ col }}— Argumente mit Spaltennamen ohne Anführungszeichen in Funktionen umschließen.data[['col_name']]— über den Namen als Zeichenkettenvariable auf Spalten zugreifen:=-Walross-Operator — mit{{ }}oder Glue-Zeichenketten für dynamische Ausgabennamen verwendenacross(cols, fns)— eine oder mehrere Funktionen gleichzeitig auf mehrere Spalten anwendenpick(cols)— Spalten als Data-Frame-Teilmenge für zeilenweise Operationen auswählen- tidyselect-Hilfsfunktionen:
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)
Lerne R mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 43
- Lektionen
- 159
Häufig gestellte Fragen
Ist die Lektion „Tidy Evaluation: {{ }} und .data“ kostenlos?
Ja — der vollständige Text von „Tidy Evaluation: {{ }} und .data“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Tidy Evaluation: {{ }} und .data“?
Schreiben Sie dplyr-Funktionen, die Spaltennamen sicher als Argumente akzeptieren. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Tidy Evaluation: {{ }} und .data“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Gruppierte Zusammenfassungen und group_by()
- Window-Funktionen: lag, lead, cumsum
- Joins über mehrere Tabellen in dplyr
- Tidy Evaluation: {{ }} und .data