0Pricing
R Academy · Урок

Преобразование числовых типов

Безопасно используйте as.integer(), as.double() и as.numeric().

«Преобразование числовых типов» — бесплатный урок R Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения R Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс R Academy содержит 4 уроков всего.

Integer и double в R

В R есть два числовых типа: integer (целые числа, создаваемые с суффиксом L) и double (числа с плавающей точкой, используемые по умолчанию для числовых литералов). В большинстве случаев R использует double, но различать эти типы важно для безопасности типов и эффективного использования памяти.

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() — преобразование в integer

as.integer(x) преобразует значение в integer, отбрасывая (а не округляя) десятичную часть. Поэтому 3.9 превращается в 3, а не в 4. Суффикс L — это синтаксическое сокращение для целых числовых литералов.

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() и as.numeric()

as.double(x) и as.numeric(x) эквивалентны: обе функции преобразуют значение в double (число с плавающей точкой). Используйте их для преобразования integer в double, когда требуется дробная точность.

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

Арифметика с integer

Арифметические операции с integer в R возвращают integer для +, - и *, но для / результат всегда имеет тип double. Это может стать неожиданностью, если Вы ожидаете, что целочисленное деление сохранит тип integer.

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

Отбрасывание дробной части и округление

Важно различать эти операции: as.integer() отбрасывает десятичные знаки, а round() округляет до ближайшего целого числа. Всегда явно указывайте, какое поведение Вам требуется.

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

Риск переполнения integer

Integer в R имеет разрядность 32 бита и может хранить значения примерно до ±2,1 миллиарда. Выход за этот диапазон приводит к появлению NA с предупреждением. Double может хранить гораздо большие значения — до ~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

Суффикс L в векторах

Векторы integer можно создавать, добавляя суффикс L к каждому элементу, или передавая последовательность в as.integer(). Оператор двоеточия : автоматически создаёт значения 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

Память и производительность

Каждый элемент integer занимает 4 байта, а double — 8 байт. Для очень больших векторов целых чисел использование integer может вдвое сократить расход памяти. Однако арифметические операции над значениями разных типов автоматически преобразуют результат в double.

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 с помощью is.integer()

Используйте is.integer(), а не is.numeric(), когда необходимо проверить именно хранение в формате integer. Число без суффикса L имеет тип double, даже если выглядит как целое.

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

Пример рабочего процесса преобразования

Практический рабочий процесс: считайте данные в формате double (по умолчанию), выполните вычисления, а затем явно преобразуйте результаты в integer там, где требуются целые числа (например, для количества, индексов и идентификаторов).

# 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), '
')

Краткий обзор преобразований числовых типов

Основные функции преобразования числовых типов:

  • as.integer(x) — преобразовать в integer, отбросив десятичные знаки в направлении к нулю
  • as.double(x) / as.numeric(x) — преобразовать в double
  • round(x) — округлить до ближайшего значения (используйте для значений, подобных целым)
  • floor(x) / ceiling(x) — округлить вниз / вверх
  • Синтаксис 5L — литерал типа integer, преобразование не требуется
  • 1:n — всегда создаёт значения 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

Быстрая проверка

Что возвращает as.integer(3.9) в R?

Итоги: преобразование числовых типов

Отлично! Основные выводы этого урока:

  • В R есть два числовых типа: integer (суффикс L, 4 байта) и double (по умолчанию, 8 байт)
  • as.integer(x) отбрасывает дробную часть в направлении к нулю, а не округляет
  • as.double() и as.numeric() идентичны: они преобразуют значение в double
  • / всегда возвращает double, даже если операнды имеют тип integer
  • 1:n создаёт последовательности integer; числовые литералы без L имеют тип double
  • Переполнение integer происходит примерно после 2,1 миллиарда; для очень больших целых чисел используйте 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)

Часто задаваемые вопросы

Урок «Преобразование числовых типов» бесплатный?

Да — полный текст урока «Преобразование числовых типов» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс R Academy, подпишись на CoddyKit PRO. Курс R Academy содержит 4 уроков всего.

Чему я научусь в уроке «Преобразование числовых типов»?

Безопасно используйте as.integer(), as.double() и as.numeric(). Ты практикуешь R Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать R Academy?

Предыдущий опыт не требуется. R Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Преобразование числовых типов»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке R Academy?

Да. Каждый урок R Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Обзор системы типов R
  2. Преобразование числовых типов
  3. Преобразование логических и строковых значений
  4. Подводные камни и лучшие практики приведения типов
← Назад к R Academy