Daten filtern und subsetten in R (subset, [ ], dplyr filter)

Zeilen filtern: die logische Maske

Um einen Data Frame in R zu filtern, setzt man eine Bedingung an die Zeilenposition der Klammern: df[bedingung, ]. Die Bedingung ergibt einen Vektor aus TRUE/FALSE, einen pro Zeile, und R behält die TRUE-Zeilen:

scores <- data.frame(
    name  = c("Ana", "Ben", "Chen", "Dana", "Eli"),
    team  = c("red", "blue", "red", "blue", "red"),
    score = c(91, 74, 88, 95, 62)
)

high <- scores[scores$score > 80, ]
print(high)

Lies scores[scores$score > 80, ] von innen nach außen: scores$score > 80 erzeugt TRUE FALSE TRUE TRUE FALSE, und die Klammern behalten die Zeilen 1, 3 und 4. Das abschließende Komma ist nicht optional. Klammern auf einem Data Frame nehmen [zeilen, spalten]; den Spalten-Slot leer zu lassen bedeutet "alle Spalten". Vergisst man das Komma, indexiert man stattdessen Spalten - einer der häufigsten Anfängerfehler in R.

Beachte, dass die ausgegebenen Zeilennummern 1 3 4 sind, nicht 1 2 3 - das Filtern behält die ursprünglichen Zeilenlabels. Harmlos, aber es überrascht viele.

Mehrere Bedingungen: & und | (nicht &&)

Kombiniere Bedingungen mit & (UND) und | (ODER). Jede Bedingung bekommt ihren eigenen vollständigen Vergleich:

scores <- data.frame(
    name  = c("Ana", "Ben", "Chen", "Dana", "Eli"),
    team  = c("red", "blue", "red", "blue", "red"),
    score = c(91, 74, 88, 95, 62)
)

print(scores[scores$score > 80 & scores$team == "red", ])
print(scores[scores$score > 90 | scores$score < 70, ])

Die Falle: R hat auch && und ||, und die sind hier nicht mit & und | austauschbar. Die doppelten Formen arbeiten auf Einzelwerten (sie existieren für if-Bedingungen); bekommen sie ganze Spalten, bricht modernes R (4.3+) mit einem Fehler wie 'length = 5' in coercion to 'logical(1)' ab, und älteres R verglich stillschweigend nur die erste Zeile - was wohl noch schlimmer ist. Innerhalb von Klammern immer das einfache & und |. Die Operatoren-Doku behandelt den Unterschied vollständig.

%in%: gegen eine Menge von Werten abgleichen

Wenn eine Spalte einem von mehreren Werten entsprechen soll, kette nicht == mit | - verwende %in%:

orders <- data.frame(
    id     = 1:6,
    status = c("paid", "pending", "paid", "refunded", "shipped", "pending")
)

open <- orders[orders$status %in% c("pending", "shipped"), ]
print(open)

x %in% set gibt überall dort TRUE zurück, wo x einer der Werte in set ist. Es liest sich besser als status == "pending" | status == "shipped", skaliert auf beliebig viele Werte und lässt sich sauber negieren: !(orders$status %in% c("refunded")).

Spalten auswählen

Der Spalten-Slot der Klammern nimmt Namen oder Positionen:

scores <- data.frame(
    name  = c("Ana", "Ben", "Chen"),
    team  = c("red", "blue", "red"),
    score = c(91, 74, 88)
)

print(scores[, c("name", "score")])            # by name - prefer this
print(scores[scores$team == "red", "score"])   # rows AND columns at once

Zwei Anmerkungen. Auswahl nach Name übersteht eine Umsortierung der Spalten; Auswahl nach Position (scores[, c(1, 3)]) geht an dem Tag kaputt, an dem jemand eine Spalte einfügt. Und die Abfrage einer einzelnen Spalte gibt einen einfachen Vektor zurück, keinen Data Frame - deshalb zeigt das zweite print() 91 88 ohne Tabelle drumherum. Wenn du die Data-Frame-Form behalten musst, ergänze drop = FALSE: scores[, "score", drop = FALSE].

subset(): der freundliche Base-Einzeiler

Base R liefert einen Wrapper mit, der Zeilen und Spalten in einem lesbaren Aufruf erledigt - ohne $, ohne Komma-Buchhaltung:

scores <- data.frame(
    name  = c("Ana", "Ben", "Chen", "Dana"),
    team  = c("red", "blue", "red", "blue"),
    score = c(91, 74, 88, 95)
)

print(subset(scores, score > 80))
print(subset(scores, team == "red", select = c(name, score)))

Innerhalb von subset() schreibt man nackte Spaltennamen (score, nicht scores$score) - sie werden gegen den Data Frame ausgewertet. Das nennt sich Non-Standard Evaluation, und es kommt mit einem dokumentierten Vorbehalt: Namen werden zur Laufzeit auf eine Weise aufgelöst, die sich in eigenen Funktionen fehlverhält (eine Variable namens score in deiner Funktion kann von einer Spalte namens score verdeckt werden). Die Faustregel, direkt aus ?subset: interaktiv großartig, beim Programmieren vermeiden - dort Klammer-Indexierung verwenden.

Die NA-Falle

Ein Vergleich mit NA ergibt NA, nicht FALSE - und Klammer-Filterung behält Zeilen mit NA-Maske als Zeilen voller NA:

df <- data.frame(name = c("Ana", "Ben", "Chen"), score = c(91, NA, 62))

print(df[df$score > 80, ])                     # ghost NA row appears
print(df[!is.na(df$score) & df$score > 80, ])  # explicit and clean

Das erste Ergebnis enthält eine Müllzeile aus NAs, weil die Bedingung von Zeile 2 weder TRUE noch FALSE war. Die Lösung ist, !is.na() explizit zu verlangen. subset() und dplyr's filter() verwerfen Zeilen mit NA-Bedingung beide stillschweigend - bequem, aber man sollte wissen, dass es passiert. Die Doku zu fehlenden Werten erklärt, warum sich NA so ausbreitet.

Der dplyr-Weg: filter() und select()

Das dplyr-Paket teilt die Aufgabe in zwei Verben - filter() für Zeilen, select() für Spalten - mit nackten Spaltennamen und ohne df$-Wiederholung (statisch; die Sandbox führt nur Base R aus):

library(dplyr)

scores |> filter(score > 80)
scores |> filter(score > 80, team == "red")     # comma = AND
scores |> filter(status %in% c("pending", "shipped"))
scores |> select(name, score)
scores |> filter(team == "red") |> select(name, score)

filter() verwirft Zeilen mit NA-Bedingung automatisch und gibt immer einen Data Frame zurück (nie einen nackten Vektor), was beide Base-Stolperfallen von oben beseitigt. Der Preis ist eine Paketabhängigkeit und dieselben Non-Standard-Evaluation-Vorbehalte wie bei subset() - siehe die dplyr-Einführung für die vollständige Verben-Tour.

Was du mitnimmst

• df[bedingung, ] ist das grundlegende Idiom - und das Komma ist Pflicht.
• Bedingungen mit einfachem & und | kombinieren; && wirft bei Vektoren einen Fehler.
• %in% schlägt verkettete == beim Abgleich gegen eine Wertemenge.
• Spalten nach Name auswählen, und daran denken: Einzelspalten fallen auf Vektoren zurück, außer mit drop = FALSE.
• subset() ist der angenehme interaktive Einzeiler; Klammern sind der programmierbare.
• Vergleiche mit NA erzeugen in Klammern Geisterzeilen - mit !is.na() absichern.

Als Nächstes: Spalten hinzufügen und transformieren - df$new <- ..., ifelse() und dplyr's mutate().