0Pricing
R Academy · Lektion

Konvertierung von Logical und Character

Konvertieren Sie mit as.logical() und as.character() zwischen logical, character und numeric.

Konvertierung von Logical und Character ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Zwischen Typen umwandeln

R stellt as.*()-Funktionen bereit, um zwischen allen grundlegenden Typen umzuwandeln. Diese Lektion behandelt Umwandlungen zwischen den Typen logical, character und numeric – den häufigsten Hin-und-zurück-Umwandlungen, die Ihnen bei der Datenbereinigung begegnen.

# Quick overview of as.*() functions
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.numeric(TRUE): ', as.numeric(TRUE), '
')  # 1
cat('as.character(3.14):', as.character(3.14), '
') # "3.14"
cat('as.logical("TRUE"):', as.logical('TRUE'), '
') # TRUE

Numerisch in logisch umwandeln

Bei der Umwandlung einer Zahl in einen logischen Wert wird 0 zu FALSE, jede Zahl ungleich null zu TRUE. Diese Regel gilt sowohl für Integer als auch für Double.

cat('as.logical(0):    ', as.logical(0), '
')     # FALSE
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.logical(-5):   ', as.logical(-5), '
')    # TRUE (non-zero)
cat('as.logical(0.001):', as.logical(0.001), '
') # TRUE (non-zero)
cat('as.logical(0L):   ', as.logical(0L), '
')    # FALSE
cat('as.logical(3L):   ', as.logical(3L), '
')    # TRUE

Logisch in numerisch umwandeln

TRUE wird zu 1 und FALSE zu 0 umgewandelt. Diese Umwandlung bildet die Grundlage vieler R-Idiome – etwa der Verwendung von sum() zum Zählen von TRUE-Werten oder von mean() zum Berechnen von Anteilen.

cat('as.numeric(TRUE):  ', as.numeric(TRUE), '
')   # 1
cat('as.numeric(FALSE): ', as.numeric(FALSE), '
')  # 0
cat('as.integer(TRUE):  ', as.integer(TRUE), '
')   # 1L

# Practical use: count TRUEs by summing
passed <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE)
cat('Passed count:', sum(as.numeric(passed)), '
')  # 4
cat('Pass rate:   ', mean(passed) * 100, '%
')      # 66.67%

as.logical() aus Zeichenketten

as.logical('TRUE') und as.logical('FALSE') wandeln Zeichenkettenrepräsentationen um. R akzeptiert außerdem 'T' und 'F' als Abkürzungen. Alles andere (einschließlich kleingeschriebenem 'true') ergibt NA.

cat('as.logical("TRUE"):  ', as.logical('TRUE'), '
')   # TRUE
cat('as.logical("FALSE"): ', as.logical('FALSE'), '
')  # FALSE
cat('as.logical("T"):     ', as.logical('T'), '
')      # TRUE
cat('as.logical("F"):     ', as.logical('F'), '
')      # FALSE
cat('as.logical("yes"):   ', as.logical('yes'), '
')    # NA (not recognised)
cat('as.logical("true"):  ', as.logical('true'), '
')   # NA (case-sensitive!)

Numerisch in Zeichenkette umwandeln

as.character(x) wandelt eine Zahl in ihre Zeichenkettenrepräsentation um. Dies ist nützlich, um Beschriftungen oder IDs zu erstellen oder Zahlen in Zeichenketten einzufügen.

num_val <- 3.14159
char_val <- as.character(num_val)
cat('as.character(3.14159):', char_val, '
')  # '3.14159'
cat('class:', class(char_val), '
')           # character

# Building labels
ids <- 1:5
labels <- paste0('Item_', as.character(ids))
cat('Labels:', labels, '
')

Zeichenkette in numerischen Wert umwandeln

as.numeric('3.14') interpretiert eine Zeichenkette als Double. Kann die Zeichenkette nicht als Zahl interpretiert werden, gibt R NA mit einer Warnung zurück. Validieren Sie Eingaben in produktivem Code immer vor der Umwandlung.

cat('as.numeric("3.14"):  ', as.numeric('3.14'), '
')   # 3.14
cat('as.numeric("100"):   ', as.numeric('100'), '
')    # 100
cat('as.numeric("-5.5"):  ', as.numeric('-5.5'), '
')   # -5.5
cat('as.numeric("abc"):   ', as.numeric('abc'), '
')    # NA with warning
cat('as.numeric("1e3"):   ', as.numeric('1e3'), '
')    # 1000 (sci notation OK)

Logisch in Zeichenkette umwandeln

as.character(TRUE) erzeugt die Zeichenkette 'TRUE'. Dies ist nützlich, wenn Sie logische Werte in Textausgaben, Datei-Exporte oder Zeichenkettenverkettungen aufnehmen müssen.

flag_t <- TRUE
flag_f <- FALSE

cat('as.character(TRUE): ', as.character(flag_t), '
')  # 'TRUE'
cat('as.character(FALSE):', as.character(flag_f), '
')  # 'FALSE'
cat('class:', class(as.character(flag_t)), '
')         # character

# In paste()
message <- paste('System status:', as.character(flag_t))
cat(message, '
')

Hin-und-zurück-Umwandlung

Die meisten Umwandlungen sind umkehrbar (Hin-und-zurück-Umwandlung), allerdings kann es zu Informationsverlust kommen: numeric -> character -> numeric kann je nach Formatierung der Zahl als Zeichenkette an Genauigkeit verlieren.

original <- 3.141592653589793
char_version <- as.character(original)
back_to_num <- as.numeric(char_version)

cat('Original:  ', original, '
')
cat('As string: ', char_version, '
')
cat('Back:      ', back_to_num, '
')
cat('Identical?:', identical(original, back_to_num), '
')
cat('Equal?:    ', original == back_to_num, '
')

Vektoren unterschiedlicher Herkunft umwandeln

Wenn Sie as.numeric() auf einen Zeichenkettenvektor anwenden, wird jedes Element unabhängig umgewandelt. Elemente, die nicht interpretiert werden können, werden zu NA. Dies ist die übliche Methode, um numerisch aussehende Daten aus CSV-Dateien zu bereinigen.

# Simulated data from CSV (all read as character)
raw_data <- c('42', '37.5', 'N/A', '55', '', '28.0')
cat('Raw character data:', raw_data, '
')

numeric_data <- suppressWarnings(as.numeric(raw_data))
cat('Converted:         ', numeric_data, '
')  # 42 37.5 NA 55 NA 28
cat('NA count:          ', sum(is.na(numeric_data)), '
')

Logische Umwandlung in ifelse()

Die Kombination von as.numeric() mit ifelse() oder die direkte Multiplikation mit einem logischen Vektor ist ein verbreitetes R-Idiom für bedingte Bewertungen oder Feature Engineering in der Datenanalyse.

# Score: 1 for correct, 0 for incorrect
quiz_answers <- c('A', 'C', 'B', 'D', 'B')
correct      <- c('A', 'B', 'B', 'D', 'C')

is_correct <- quiz_answers == correct
cat('Correct:  ', is_correct, '
')
cat('As 0/1:   ', as.numeric(is_correct), '
')
cat('Score:    ', sum(is_correct), '/', length(is_correct), '
')

Zusammenfassung der Umwandlungen

Hier finden Sie eine Zusammenfassung der wichtigsten Umwandlungen von logischen Werten und Zeichenketten:

  • as.logical(0) → FALSE; jeder Wert ungleich null → TRUE
  • as.logical('TRUE'/'T') → TRUE; Groß- und Kleinschreibung wird berücksichtigt; alle anderen Werte → NA
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) → Zeichenkettenrepräsentation von x
  • as.numeric('3.14') → 3.14; nicht numerische Zeichenketten → NA mit Warnung
# All conversions in one snippet
cat('logical->num:  ', as.numeric(c(TRUE, FALSE)), '
')
cat('num->logical:  ', as.logical(c(0, 1, -1, 0.5)), '
')
cat('char->num:     ', suppressWarnings(as.numeric(c('5', 'abc', '3.1'))), '
')
cat('char->logical: ', as.logical(c('TRUE', 'FALSE', 'yes')), '
')
cat('logical->char: ', as.character(c(TRUE, FALSE)), '
')

Schnelltest

Worauf wird as.numeric(TRUE) + as.numeric(FALSE) in R ausgewertet?

Zusammenfassung: Umwandlung logischer Werte und Zeichenketten

Ausgezeichnet! Die wichtigsten Erkenntnisse aus dieser Lektion:

  • as.logical(0) → FALSE; Werte ungleich null → TRUE; 'TRUE'/'T' → TRUE
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) wandelt jeden Wert in seine Zeichenkettendarstellung um
  • as.numeric('3.14') interpretiert eine numerische Zeichenkette; ungültige Zeichenketten → NA
  • as.logical('true') ist NA – die Übereinstimmung berücksichtigt die Groß- und Kleinschreibung ('TRUE' funktioniert)
  • Umwandlungen sind größtenteils umkehrbar; verwenden Sie suppressWarnings(), wenn Sie Spalten mit erwarteten, NA-erzeugenden Einträgen umwandeln
# Practical: parse a messy survey score column
raw_scores <- c('8', '7', 'N/A', '9', 'skip', '6')
numeric_scores <- suppressWarnings(as.numeric(raw_scores))
cat('Parsed:', numeric_scores, '
')
cat('Valid responses:', sum(!is.na(numeric_scores)), '
')
cat('Average score:  ', round(mean(numeric_scores, na.rm = TRUE), 2), '
')

Häufig gestellte Fragen

Ist die Lektion „Konvertierung von Logical und Character“ kostenlos?

Ja — der vollständige Text von „Konvertierung von Logical und Character“ 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 „Konvertierung von Logical und Character“?

Konvertieren Sie mit as.logical() und as.character() zwischen logical, character und numeric. 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 3 von 4.

Wie lange dauert die Lektion „Konvertierung von Logical und Character“?

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. Überblick über R's Typsystem
  2. Zwischen numerischen Typen konvertieren
  3. Konvertierung von Logical und Character
  4. Fallstricke und Best Practices bei der Typumwandlung
← Zurück zu R Academy