0Pricing
R Academy · Lektion

Fehlende Werte erkennen und zählen

Verwenden Sie is.na(), anyNA() und sum(is.na()), um fehlende Daten zu überprüfen.

Fehlende Werte erkennen und zählen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

is.na() – Das zentrale Prüfwerkzeug

is.na(x) prüft jedes Element von x und gibt einen logischen Vektor derselben Länge zurück. An den Stellen mit dem Wert NA (oder NaN) steht TRUE. Dies ist das grundlegende Werkzeug zum Erkennen fehlender Werte.

heights <- c(175, NA, 162, 188, NA, 170, NA, 165)
cat('Heights:', heights, '
')
cat('is.na() :', is.na(heights), '
')
cat('!is.na():', !is.na(heights), '
')

NAs mit sum(is.na()) zählen

Da TRUE == 1 und FALSE == 0 in arithmetischen Operationen gilt, zählt sum(is.na(x)) die Gesamtzahl der fehlenden Werte. mean(is.na(x)) liefert den Anteil der fehlenden Werte.

survey <- c(8, NA, 6, NA, 9, 7, NA, 5, NA, 8)
cat('Survey responses:', survey, '
')
cat('Total NAs:    ', sum(is.na(survey)), '
')
cat('Total present:', sum(!is.na(survey)), '
')
cat('NA proportion:', mean(is.na(survey)), '
')
cat('NA percentage:', mean(is.na(survey)) * 100, '%
')

anyNA() – Schnelle Prüfung auf Vorhandensein

anyNA(x) gibt ein einzelnes TRUE zurück, wenn irgendein Element NA ist, andernfalls FALSE. Die Funktion ist schneller als any(is.na(x)), weil sie beim ersten gefundenen NA abbricht.

complete_data <- c(1, 2, 3, 4, 5)
incomplete_data <- c(1, 2, NA, 4, 5)

cat('anyNA(complete)  :', anyNA(complete_data), '
')    # FALSE
cat('anyNA(incomplete):', anyNA(incomplete_data), '
')  # TRUE

# Use in validation
if (anyNA(incomplete_data)) {
  cat('Warning: data contains missing values!
')
}

which(is.na()) – Positionen finden

which(is.na(x)) gibt die Indizes (Positionen) der fehlenden Werte in einem Vektor zurück. Das ist unerlässlich, um zu prüfen, bei welchen Beobachtungen Werte fehlen, und um gezielt Imputationen vorzunehmen.

temperatures <- c(22.1, NA, 19.8, NA, 25.1, NA, 17.3, 20.0)
cat('Temperatures:', temperatures, '
')

missing_pos <- which(is.na(temperatures))
cat('Missing at positions:', missing_pos, '
')
cat('Number missing:', length(missing_pos), '
')

# What values are NOT missing?
present_pos <- which(!is.na(temperatures))
cat('Present at positions:', present_pos, '
')

NAs in einem Data Frame zählen

Für Data Frames gibt is.na(df) eine logische Matrix mit denselben Dimensionen zurück. In Kombination mit colSums() erhalten Sie die Anzahl der fehlenden Werte pro Spalte – eine schnelle Möglichkeit, die Datenqualität zu prüfen.

# Simulate a small data frame
name_col <- c('Alice', 'Bob', 'Carol', 'Dave', 'Eve')
age_col  <- c(28, NA, 32, NA, 29)
sal_col  <- c(55000, 72000, NA, 90000, 61000)
scr_col  <- c(88, NA, 75, NA, NA)

cat('Age NAs:   ', sum(is.na(age_col)), '
')
cat('Salary NAs:', sum(is.na(sal_col)), '
')
cat('Score NAs: ', sum(is.na(scr_col)), '
')

Das Muster colSums(is.na(df))

Das Muster colSums(is.na(df)) ist die schnellste Möglichkeit, fehlende Werte pro Spalte eines Data Frames zu zählen. Es gibt einen benannten numerischen Vektor zurück, der für jede Spalte die Anzahl der NAs angibt.

# Build a data frame manually
df <- data.frame(
  name   = c('Alice', 'Bob', 'Carol', 'Dave', 'Eve'),
  age    = c(28, NA, 32, NA, 29),
  salary = c(55000, 72000, NA, 90000, 61000),
  score  = c(88, NA, 75, NA, NA)
)
cat('Missing values per column:
')
print(colSums(is.na(df)))
cat('Total missing:', sum(is.na(df)), '
')

Anteil der NAs pro Spalte

Wenn Sie durch die Anzahl der Zeilen teilen, erhalten Sie den Anteil fehlender Werte pro Spalte. Das ist aussagekräftiger als die absoluten Anzahlen, wenn die Spalten unterschiedlich viele Werte enthalten.

df <- data.frame(
  x1 = c(1, NA, 3, NA, 5),
  x2 = c(NA, 2, NA, 4, NA),
  x3 = c(1, 2, 3, NA, 5)
)
n_rows <- nrow(df)
na_counts <- colSums(is.na(df))
na_pct <- round(na_counts / n_rows * 100, 1)

cat('NA counts:     '); print(na_counts)
cat('NA percentage: '); print(na_pct)

table(is.na()) – Häufigkeiten zählen

table(is.na(x)) erzeugt eine benannte Häufigkeitstabelle, die zeigt, wie viele FALSE- (vorhandene) und TRUE-Werte (fehlende Werte) es gibt. Sie lässt sich auf einen Blick leicht erfassen.

responses <- c(5, NA, 8, 6, NA, 9, 7, NA, NA, 8)

cat('NA frequency table:
')
print(table(is.na(responses)))

# For multiple columns:
cat('Age table:
')
ages <- c(28, NA, 32, NA, 29)
print(table(is.na(ages)))

Zeilen mit beliebigem NA finden

Um herauszufinden, welche Zeilen eines Data Frames mindestens einen fehlenden Wert enthalten, verwenden Sie apply(is.na(df), 1, any). Das Ergebnis ist ein logischer Vektor, der für unvollständige Zeilen TRUE enthält.

df <- data.frame(
  id     = 1:5,
  age    = c(28, NA, 32, NA, 29),
  salary = c(55000, 72000, NA, 90000, 61000)
)

# Which rows have at least one NA?
has_na <- apply(is.na(df), 1, any)
cat('Rows with any NA:', which(has_na), '
')
cat('Complete rows:   ', which(!has_na), '
')
cat('Complete row count:', sum(!has_na), '/', nrow(df), '
')

Einen vollständigen Datensatz prüfen

Ein praktischer Ablauf zur NA-Prüfung: Zählen, lokalisieren und melden Sie fehlende Werte, um die Datenqualität vor der Analyse zu verstehen. Hier ist eine eigenständige Prüf-Funktion.

audit_na <- function(v, label) {
  n_total   <- length(v)
  n_missing <- sum(is.na(v))
  pct       <- round(n_missing / n_total * 100, 1)
  positions <- which(is.na(v))
  cat(label, ':', n_missing, '/', n_total,
      '(', pct, '%) NA at positions', positions, '
')
}

heights <- c(175, NA, 162, 188, NA, 170)
weights <- c(70, 85, NA, 92, 68, NA)
audit_na(heights, 'Height')
audit_na(weights, 'Weight')

Zusammenfassung der NA-Erkennung

Schnellreferenz für Werkzeuge zur Erkennung von NA:

  • is.na(x) – logischer Vektor: TRUE an Stellen mit NA
  • anyNA(x) – einzelnes TRUE/FALSE: Ist irgendein NA vorhanden?
  • sum(is.na(x)) – Anzahl der NAs
  • mean(is.na(x)) – Anteil der NAs
  • which(is.na(x)) – Positionen der NAs
  • colSums(is.na(df)) – Anzahl der NAs pro Spalte
  • table(is.na(x)) – Häufigkeitstabelle für NA/nicht NA
x <- c(10, NA, 30, NA, 50, NA, 70)
cat('is.na:       ', is.na(x), '
')
cat('anyNA:       ', anyNA(x), '
')
cat('sum(is.na):  ', sum(is.na(x)), '
')
cat('mean(is.na): ', mean(is.na(x)), '
')
cat('which(is.na):', which(is.na(x)), '
')

Kurze Wissensprüfung

Welchen Wert gibt sum(is.na(c(1, NA, 3, NA, 5))) zurück?

Zusammenfassung: NAs erkennen und zählen

Gut gemacht! Die wichtigsten Erkenntnisse aus dieser Lektion:

  • is.na(x) ist das wichtigste Werkzeug und gibt einen logischen Vektor zurück
  • sum(is.na(x)) zählt fehlende Werte; mean(is.na(x)) liefert ihren Anteil
  • anyNA(x) prüft schnell, ob überhaupt ein NA vorhanden ist
  • which(is.na(x)) zeigt die genauen Positionen der NAs
  • colSums(is.na(df)) ist die übliche Methode, um einen Data Frame zu prüfen
  • Verwenden Sie niemals x == NA, um NA zu erkennen – verwenden Sie immer is.na(x)
# Full audit of a data frame in 3 lines
df <- data.frame(a=c(1,NA,3), b=c(NA,2,NA), c=c(1,2,3))
cat('Per column:', colSums(is.na(df)), '
')
cat('Total:     ', sum(is.na(df)), '/', nrow(df)*ncol(df), '
')
cat('Complete rows:', sum(complete.cases(df)), '/', nrow(df), '
')

Häufig gestellte Fragen

Ist die Lektion „Fehlende Werte erkennen und zählen“ kostenlos?

Ja — der vollständige Text von „Fehlende Werte erkennen und zählen“ 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 „Fehlende Werte erkennen und zählen“?

Verwenden Sie is.na(), anyNA() und sum(is.na()), um fehlende Daten zu überprüfen. 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 2 von 4.

Wie lange dauert die Lektion „Fehlende Werte erkennen und zählen“?

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

  1. NA in R verstehen
  2. Fehlende Werte erkennen und zählen
  3. NA-Werte entfernen und ersetzen
  4. NA in Berechnungen und Aggregationen
← Zurück zu R Academy