R Academy · Lektion

NA in R verstehen

Lernen Sie, was NA bedeutet, warum es sich fortpflanzt und wie es sich von NULL unterscheidet.

Lektion 1 von 413 Schritte

NA in R verstehen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist NA in R?

NA steht für Not Available (nicht verfügbar) – es bezeichnet einen fehlenden oder unbekannten Wert. Anders als NULL (das Fehlen eines Objekts) oder NaN (keine Zahl) ist NA ein Platzhalter für Daten, die vorhanden, aber unbekannt sind.

# NA represents a missing value
height_cm <- c(175, NA, 162, 188, NA, 170)
cat('Heights:', height_cm, '
')
cat('Length:', length(height_cm), '
')  # NA counts as an element
cat('Sum:', sum(height_cm), '
')        # NA propagates

NA und NULL

NA ist ein fehlender Wert innerhalb eines Vektors – der Platz ist vorhanden, aber sein Wert ist nicht bekannt. NULL bezeichnet das vollständige Fehlen eines Objekts – es hat die Länge 0 und kann nicht in einem Vektor gespeichert werden.

# NA: element exists, value unknown
vec_with_na <- c(1, NA, 3)
cat('Vector with NA, length:', length(vec_with_na), '
')  # 3

# NULL: nothing there at all
vec_with_null <- c(1, NULL, 3)
cat('Vector with NULL, length:', length(vec_with_null), '
')  # 2!

# NULL gets dropped; NA is kept
cat('vec_with_na:', vec_with_na, '
')
cat('vec_with_null:', vec_with_null, '
')

NA und NaN

NaN (Not a Number, keine Zahl) entsteht durch mathematisch nicht definierte Operationen wie 0/0 oder sqrt(-1). Es ist ein spezieller numerischer Wert, während NA eine allgemeine Markierung für einen fehlenden Wert ist, die auf jeden Datentyp angewendet werden kann.

# NaN from undefined operations
cat('0/0 =', 0/0, '
')          # NaN
cat('sqrt(-1) =', sqrt(-1), '
') # NaN (with warning)
cat('Inf - Inf =', Inf - Inf, '
') # NaN

# NaN IS also NA (a special case)
cat('is.nan(NaN):', is.nan(NaN), '
')
cat('is.na(NaN): ', is.na(NaN), '
')  # TRUE!
cat('is.nan(NA): ', is.nan(NA), '
')  # FALSE

NA vs. Inf

Inf und -Inf stehen für positive bzw. negative Unendlichkeit – sie entstehen beispielsweise durch Operationen wie 1/0. Anders als NA ist Inf ein bekannter, wenn auch extremer numerischer Wert und verhält sich bei Vergleichen ganz normal.

cat('1/0 =', 1/0, '
')         # Inf
cat('-1/0 =', -1/0, '
')       # -Inf
cat('Inf + 1 =', Inf + 1, '
') # Inf
cat('Inf > 1000:', Inf > 1000, '
')  # TRUE
cat('is.infinite(Inf):', is.infinite(Inf), '
')
cat('is.na(Inf):       ', is.na(Inf), '
')  # FALSE

Weitergabe von NA in arithmetischen Operationen

NA ist in arithmetischen Operationen ansteckend: Jede Operation, an der NA beteiligt ist, gibt NA zurück. Das ist beabsichtigt – wenn ein Wert in einer Berechnung unbekannt ist, ist auch das Ergebnis unbekannt.

x <- NA
cat('NA + 5:  ', x + 5, '
')      # NA
cat('NA * 0:  ', x * 0, '
')      # NA (not 0!)
cat('NA == NA:', x == NA, '
')     # NA (not TRUE!)
cat('NA > 5:  ', x > 5, '
')      # NA
cat('sum(1,NA):', sum(1, NA), '
') # NA

typeof(NA) – Typisierte NAs

Das Standard-NA hat den Typ logical. R stellt für jeden atomaren Typ typisierte NA-Varianten bereit. Diese sind bei der Arbeit mit typisierten Vektoren wichtig, um eine unbeabsichtigte Typkonvertierung zu vermeiden.

cat('typeof(NA):            ', typeof(NA), '
')           # logical
cat('typeof(NA_integer_):  ', typeof(NA_integer_), '
')   # integer
cat('typeof(NA_real_):     ', typeof(NA_real_), '
')      # double
cat('typeof(NA_complex_):  ', typeof(NA_complex_), '
')   # complex
cat('typeof(NA_character_):', typeof(NA_character_), '
') # character

NA_integer_ in der Praxis

Wenn Sie einen Integer-Vektor mit einem fehlenden Wert erstellen, verwenden Sie NA_integer_, damit der Vektortyp erhalten bleibt. Die Verwendung von einfachem NA führt in manchen Kontexten implizit zur Konvertierung in double.

# Using plain NA in an integer vector
v1 <- c(1L, 2L, NA, 4L)
cat('typeof with NA:         ', typeof(v1), '
')  # integer (OK here)

# Explicit typed NA is safer in functions
v2 <- c(1L, 2L, NA_integer_, 4L)
cat('typeof with NA_integer_:', typeof(v2), '
')  # integer

# Check they behave the same
cat('Same?', identical(v1, v2), '
')

NA_real_ und NA_character_

NA_real_ wird für fehlende Werte in Double-Vektoren (numerischen Vektoren) verwendet, NA_character_ für fehlende Zeichenketten. Diese Varianten sind besonders wichtig, wenn Sie innerhalb von Funktionen Vektoren erstellen, bei denen Typkonsistenz erforderlich ist.

# Character vector with missing
names_vec <- c('Alice', 'Bob', NA_character_, 'Dave')
cat('Names:', names_vec, '
')
cat('typeof:', typeof(names_vec), '
')

# Numeric with missing
readings <- c(22.5, NA_real_, 21.3, NA_real_, 24.1)
cat('Readings:', readings, '
')
cat('Non-NA count:', sum(!is.na(readings)), '
')

NA in logischen Operationen

NA folgt in logischen Operationen der dreiwertigen Logik: TRUE | NA ergibt TRUE (weil TRUE ODER beliebiger Wert TRUE ergibt), aber FALSE | NA ergibt NA (ohne den Wert von NA zu kennen, lässt sich das Ergebnis nicht bestimmen).

cat('TRUE  | NA:', TRUE | NA, '
')   # TRUE
cat('FALSE | NA:', FALSE | NA, '
')  # NA
cat('TRUE  & NA:', TRUE & NA, '
')   # NA
cat('FALSE & NA:', FALSE & NA, '
')  # FALSE

# Never use == to test for NA!
cat('NA == NA:', NA == NA, '
')    # NA (not TRUE!)
cat('is.na(NA):', is.na(NA), '
')  # TRUE (correct way)

NA in Vektoren und Data Frames

Fehlende Werte kommen in realen Daten häufig vor. Wenn Sie verstehen, wie sich NA verhält, können Sie Zusammenfassungen korrekt interpretieren, Probleme mit der Datenqualität erkennen und die passende Vorgehensweise auswählen.

ages <- c(25, NA, 32, NA, 29, 41, NA, 35)
cat('Ages:', ages, '
')
cat('Length:', length(ages), '
')
cat('Missing count:', sum(is.na(ages)), '
')
cat('Present count:', sum(!is.na(ages)), '
')
cat('Mean (fails):', mean(ages), '
')           # NA
cat('Mean (works):', mean(ages, na.rm = TRUE), '
') # 32.4

NA-Typen: Das vollständige Bild

Hier ist eine Zusammenfassung der besonderen NA-bezogenen Werte in R:

NA – allgemeiner fehlender Wert (logischer Typ)
NA_integer_, NA_real_, NA_complex_, NA_character_ – typisierte NAs
NaN – undefinierte Zahl (Ergebnis von 0/0, sqrt(-1))
Inf, -Inf – unendliche Werte (Ergebnis von 1/0)
NULL – Fehlen eines Objekts (Länge 0)

# Test functions for special values
x <- c(1, NA, NaN, Inf, -Inf, 0)
cat('Values:         ', x, '
')
cat('is.na():        ', is.na(x), '
')        # TRUE for NA and NaN
cat('is.nan():       ', is.nan(x), '
')       # TRUE only for NaN
cat('is.infinite():  ', is.infinite(x), '
')  # TRUE for Inf and -Inf
cat('is.finite():    ', is.finite(x), '
')    # TRUE only for normal numbers

Kurze Wissensprüfung

Welchen Wert ergibt NA == NA in R?

Beantworte es in der interaktiven Lektion

Zusammenfassung: NA verstehen

Ausgezeichnet! Die wichtigsten Erkenntnisse aus dieser Lektion:

NA = fehlender Wert (es ist bekannt, dass der Wert existiert, aber sein konkreter Wert ist unbekannt)
NULL = Fehlen eines Objekts (wird aus Vektoren entfernt)
NaN = undefiniertes arithmetisches Ergebnis (ist ebenfalls NA)
Inf / -Inf = unendliche Werte (sind NICHT NA)
NA ist in arithmetischen Operationen ansteckend – Operationen mit NA geben NA zurück
Verwenden Sie typisierte NAs (NA_integer_ usw.) für typsicheren Code
Prüfen Sie NA immer mit is.na(), niemals mit == NA

# Key tests side by side
special_vals <- list(NA=NA, NaN=NaN, Inf=Inf, 'NULL-in-vec'=c(1,NULL,3)[2])
for (name in names(special_vals)) {
  v <- special_vals[[name]]
  cat(name, '| is.na:', is.na(v), '| is.nan:', is.nan(v[!is.infinite(v)]), '
')
}

Kostenlos starten

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

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „NA in R verstehen“ kostenlos?

Ja — der vollständige Text von „NA in R verstehen“ 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 „NA in R verstehen“?

Lernen Sie, was NA bedeutet, warum es sich fortpflanzt und wie es sich von NULL unterscheidet. 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 1 von 4.

Wie lange dauert die Lektion „NA in R verstehen“?

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

← Zurück zu R Academy