0Pricing
R Academy · Lektion

Zwischen numerischen Typen konvertieren

Verwenden Sie as.integer(), as.double() und as.numeric() sicher.

Zwischen numerischen Typen konvertieren 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.

Integer vs. Double in R

R besitzt zwei numerische Typen: integer (Ganzzahlen, erzeugt mit dem Suffix L) und double (Gleitkommazahlen, der Standard für numerische Literale). Meist verwendet R Double, aber die Unterscheidung ist für Typsicherheit und Speichereffizienz wichtig.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() – In Integer umwandeln

as.integer(x) wandelt einen Wert in einen Integer um, indem der Dezimalteil abgeschnitten wird (nicht gerundet). Aus 3.9 wird also 3 und nicht 4. Das Suffix L ist syntaktischer Zucker für Integer-Literale.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() und as.numeric()

as.double(x) und as.numeric(x) sind gleichbedeutend – beide wandeln einen Wert in einen Double-Wert (Gleitkommazahl) um. Verwenden Sie sie, wenn Sie Integer in Double umwandeln müssen, um Nachkommagenauigkeit zu erhalten.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Ganzzahlarithmetik

Ganzzahlarithmetik in R liefert bei +, - und * Integer, gibt bei / jedoch immer Double zurück. Das kann zu Überraschungen führen, wenn Sie erwarten, dass eine Ganzzahldivision ganzzahlig bleibt.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Abschneiden vs. Runden

Ein entscheidender Unterschied: as.integer() schneidet ab (entfernt Dezimalstellen), während round() auf die nächste Ganzzahl rundet. Legen Sie immer ausdrücklich fest, welches Verhalten Sie beabsichtigen.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Risiko eines Integer-Überlaufs

Integer in R sind 32-Bit-Werte und können Werte bis ungefähr ±2,1 Milliarden speichern. Wird dieser Bereich überschritten, führt das zu einem NA mit einer Warnung. Double kann deutlich größere Werte speichern (bis etwa 1,8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

Das Suffix L in Vektoren

Sie können Integer-Vektoren erzeugen, indem Sie jedes Element mit dem Suffix L versehen, oder indem Sie eine Sequenz an as.integer() übergeben. Der Doppelpunktoperator : erzeugt automatisch Integer.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Speicher und Leistung

Integer verwenden 4 Byte pro Element, Double 8 Byte. Bei sehr großen Vektoren mit Ganzzahlen kann die Verwendung von Integer den Speicherbedarf halbieren. Arithmetik zwischen gemischten Typen wird jedoch automatisch zu Double hochgestuft.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Integer-Speicher mit is.integer() prüfen

Verwenden Sie immer is.integer() (nicht is.numeric()), wenn Sie gezielt den Integer-Speicher überprüfen müssen. Eine Zahl ohne das Suffix L ist Double, auch wenn sie wie eine Ganzzahl aussieht.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Beispiel für einen Umwandlungsworkflow

Ein praktischer Workflow: Lesen Sie Daten als Double ein (dem Standard), führen Sie Berechnungen durch und wandeln Sie die Ergebnisse anschließend explizit in Integer um, wenn Ganzzahlen erforderlich sind (z. B. bei Zählwerten, Indizes oder IDs).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Zusammenfassung der numerischen Umwandlung

Wichtige Umwandlungsfunktionen für numerische Typen:

  • as.integer(x) – in Integer umwandeln (Dezimalstellen in Richtung null abschneiden)
  • as.double(x) / as.numeric(x) – in Double umwandeln
  • round(x) – auf die nächste Ganzzahl runden (für ganzzahlähnliche Werte verwenden)
  • floor(x) / ceiling(x) – abrunden / aufrunden
  • Syntax 5L – Integer-Literal (keine Umwandlung erforderlich)
  • 1:n – erzeugt immer Integer
x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Schnelltest

Was gibt as.integer(3.9) in R zurück?

Zusammenfassung: Umwandlung numerischer Typen

Ausgezeichnet! Die wichtigsten Erkenntnisse aus dieser Lektion:

  • R besitzt zwei numerische Typen: integer (Suffix L, 4 Byte) und double (Standard, 8 Byte)
  • as.integer(x) schneidet in Richtung null ab – es wird nicht gerundet
  • as.double() und as.numeric() sind identisch – sie wandeln in Double um
  • / gibt immer Double zurück, auch bei Integer-Operanden
  • 1:n erzeugt Integer-Sequenzen; numerische Literale ohne L sind Double
  • Integer-Überlauf ab etwa 2,1 Milliarden → verwenden Sie für sehr große Ganzzahlen Double
# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Häufig gestellte Fragen

Ist die Lektion „Zwischen numerischen Typen konvertieren“ kostenlos?

Ja — der vollständige Text von „Zwischen numerischen Typen konvertieren“ 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 „Zwischen numerischen Typen konvertieren“?

Verwenden Sie as.integer(), as.double() und as.numeric() sicher. 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 „Zwischen numerischen Typen konvertieren“?

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