Типы данных в R: numeric, character, logical (typeof и class)

Типы данных в R

У каждого значения в R есть один из небольшого набора атомарных типов. Четыре из них делают почти всю работу:

• double — десятичные числа: 3.14, -2, 1e6. Именно это R подразумевает под «numeric», и это тип по умолчанию для любого набранного вами числа.
• integer — целые числа, хранящиеся точно, записываются с суффиксом L: 42L.
• character — текст в кавычках: "hello".
• logical — два значения истинности TRUE и FALSE (плюс NA, пропущенное значение — см. пропущенные значения).

Есть ещё complex (2 + 3i) для редких задач цифровой обработки сигналов; можно годами обходиться без него. typeof() сообщает, какой тип у значения:

cat(typeof(3.14), "\n")
cat(typeof(42L), "\n")
cat(typeof("hello"), "\n")
cat(typeof(TRUE), "\n")
cat(typeof(2 + 3i), "\n")

Обратите внимание на первую строку: обычное число — это double, даже если выглядит целым. typeof(42) даёт "double"; целое — только 42L. В повседневном анализе разница почти не важна — R преобразует их молча, — но она объясняет много иначе непонятного вывода typeof().

typeof() против class(): почему они расходятся

В R есть две функции, каждая из которых будто отвечает на вопрос «что это?», но отвечают они на слегка разные вопросы.

• typeof() сообщает тип хранения: как значение лежит в памяти.
• class() сообщает поведенческий тип: ярлык, по которому диспетчеризация методов R решает, какой, скажем, print или summary запустить.

Для простых значений ответы различаются только словами:

x <- 3.14
cat(typeof(x), "\n")
cat(class(x), "\n")

typeof() говорит double (хранение), class() говорит numeric (поведение). Для структур разрыв шире:

m <- matrix(1:4, nrow = 2)
cat(typeof(m), "\n")
print(class(m))

Матрица хранится как обычный целочисленный вектор, но ведёт себя как матрица — именно class() заставляет R печатать её сеткой. То же расхождение проявляется у датафреймов (typeof говорит "list", class — "data.frame") и у дат (typeof говорит "double", class — "Date").

Практическое правило: пользуйтесь class(), когда хотите узнать, что это такое в обыденном смысле, и typeof(), когда отлаживаете то, что R делает под капотом.

Проверка типов через is.*()

У каждого типа есть парный предикат, возвращающий TRUE или FALSE, — удобно внутри функций, которым нужно проверить свои входные данные:

x <- 10
cat(is.numeric(x), is.character(x), is.logical(x), "\n")

Одна ловушка, о которой стоит знать: is.numeric() даёт TRUE и для double, и для integer (это всё числа), а вот is.integer() проверяет хранение, поэтому для обычной 42 он FALSE:

cat(is.numeric(42L), "\n")
cat(is.integer(42), "\n")
cat(is.integer(42L), "\n")

Если вас когда-нибудь удивляло, что is.integer(7) равно FALSE для числа, которое в математическом смысле очевидно целое, — вот почему. 7 — это double; 7L — integer.

Преобразование типов через as.*()

Явное преобразование выполняется семейством as.* — по одной функции на целевой тип:

cat(as.numeric("3.5") + 1, "\n")
cat(as.integer(7.9), "\n")
cat(as.character(42), "\n")
cat(as.logical("TRUE"), "\n")

Два поведения стоит запомнить. as.integer() усекает в сторону нуля, а не округляет — 7.9 становится 7. И когда преобразование бессмысленно, R не бросает ошибку; он возвращает NA и выдаёт предупреждение:

result <- as.numeric("abc")
print(result)

Запустите это — и увидите NA плюс предупреждение «NAs introduced by coercion». Это по-настоящему полезно — преобразуйте целый столбец грязного текста в числа, и неразбираемые записи станут NA вместо падения скрипта, — но это же означает, что тихий NA может просочиться в ваши данные. Когда преобразование важно, проверяйте после него появление новых NA.

Логические значения преобразуются в числа и обратно так, как и хотелось бы: as.numeric(TRUE) это 1, as.logical(0) это FALSE. Поэтому sum() от логического вектора считает количество TRUE:

passed <- c(TRUE, TRUE, FALSE, TRUE)
cat(sum(passed), "out of", length(passed), "\n")

Неявное приведение: правило одного типа для векторов

Атомарный вектор в R может хранить только один тип. Объедините смешанные значения через c() — и R молча повысит всё до самого гибкого из присутствующих типов по фиксированной лестнице:

logical → integer → double → character

print(c(TRUE, FALSE, 2L))
print(c(1L, 2L, 3.5))
print(c(1, 2, "three"))

Логические стали 1 и 0, целые стали double, а в последней строке всё стало текстом — character всегда побеждает, потому что любое значение можно записать строкой. Убедиться можно через typeof():

cat(typeof(c(TRUE, 1L)), "\n")
cat(typeof(c(1L, 2.5)), "\n")
cat(typeof(c(1, "a")), "\n")

Приведение типов — источник номер один багов «почему мой столбец текстовый?»: одна затесавшаяся строка "N/A" в столбце чисел приводит весь вектор к character. Когда так случилось, сначала исправьте виновное значение, а затем преобразуйте обратно через as.numeric().

Что вы уносите с собой

• Четыре рабочих типа: double («numeric»), integer (42L), character, logical.
• typeof() = как хранится; class() = как ведёт себя. 3.14 — это double, ведущий себя как numeric.
• Проверяйте через is.numeric() и родственные функции; преобразуйте через as.numeric() и родственные — неудачные преобразования дают NA с предупреждением, а не ошибку.
• Векторы хранят только один тип; смешивание приводит по цепочке logical → integer → double → character.

Дальше: подробнее о числовых типах — округление, математические функции и сюрпризы плавающей точки, общие для всех языков.