Язык программирования R/Введение

Зачем использовать R?

• R является Свободным программным обеспечением.
• R — это очень общий пакет статистического анализа. Изучите CRAN Task View(англ.) чтобы глубоко разобраться в том, что умеет делать R.
• R широко используется в социальных науках, статистике, экономике, страховом деле, социологии, финансах, физике высоких энергий и так далее.
• R доступен для всех операционных систем, включая Linux, Mac OS, Windows.
• R включает самые последние методики.
• R — объектно ориентированный. Теоретически, всё что угодно может быть сохранено как объект R.
• R — матричный язык.
• R включает длинный список функций и пакетов, написанных пользователями. Смотрите: CRAN Contributed packages(англ.).
• R использует более систематичный синтаксис, нежели Stata или SAS.
• R может быть установлен на USB-флеш диск.

См. также

• «R Relative to Statistical Package» by Patrick Burns(англ.)

Стиль программирования R

• R — это объектно-ориентированный язык программирования. Это означает, что теоретически всё что угодно может быть сохранено как объект R. Каждый объект имеет свой класс, описывающий что содержит этот объект и что каждая функция может с этими данными делать. Например, plot(x) выводит один результат, если x является регрессией, и другой, если вектором.
• Символом присвоения является «<-». Также возможно использовать классический «=».

Два следующих выражения являются эквивалентными:

> a <- 2
> a = 2

• Аргументы передаются в круглых скобках.
• Обычно, лучше использовать кавычки для имён, но это не всегда необходимо.
• Функции можно просто комбинировать. Например, вы можете написать:

mean(rnorm(1000)^2)

• «#» используется для комментариев:

# Это комментарий
5 + 7 # Это тоже комментарий

• Команды отделяются точкой с запятой «;» или символом перевода каретки. Если вы хотите разместить в одной строке более одного выражения, то необходимо использовать разделитель «;».

a <- 1:10; mean(a);

• Также вы можете разбить одно выражение на несколько строк кода.
• R чувствителен к регистру: «a» и «A» являются двумя разными объектами.
• Традиционно символ подчёркивания «_» не используется в именах. Зачастую лучше использовать символ точки «.». Следует избегать использования символа подчёркивания в качестве первого символа в имени объекта.

См. также

• Google’s R Style Guide(англ.): набор правил для программистов на R

Простые примеры

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

 
> # Простой пример
> # Это комментарий
> 
> 2 # печатает число
[1] 2
> 2+3 # производит простое сложение
[1] 5
> log(2)
[1] 0.6931472

Также возможно сохранять числовые и строковые объекты.

> x <- 2 # сохраняем объект
> x # выводим этот объект
[1] 2
> (x <- 3) # сохраняем и выводим объект
[1] 3
> 
> x <- "Hello" # сохраняем строковый объект
> x
[1] "Hello"

Также можно сохранять векторы.

> Height <- c(168, 177, 177, 177, 178, 172, 165, 171, 178, 170) # Сохраняем вектор
> Height  # выводим вектор
 [1] 168 177 177 177 178 172 165 171 178 170
> 
> Height[2] # Выводим второй элемент вектора (нумерация элементов происходит с единицы)
[1] 177
> Height[2:5] # Выводим второй, третий, четвёртый и пятый элементы вектора
[1] 177 177 177 178
> 
> (obs <- 1:10) # Определяем вектор как последовательность (от 1 до 10)
 [1]  1  2  3  4  5  6  7  8  9 10
> 
> Weight <- c(88, 72, 85, 52, 71, 69, 61, 61, 51, 75)
> 
> BMI <- Weight/((Height/100)^2)   # Производим простые вычисления с векторами
> BMI
 [1] 31.17914 22.98190 27.13141 16.59804 22.40879 23.32342 22.40588 20.86112
 [9] 16.09645 25.95156

Также можно получать данные о векторе при помощи length(), mean() и var():

> length(Height)
[1] 10
> mean(Height) # Вычисляем среднее арифметическое
[1] 173.3
> var(Height)
[1] 22.23333

Можно определить матрицу:

> M <- cbind(obs,Height,Weight,BMI) # Создаём матрицу
> typeof(M) # Получаем тип матрицы
[1] "double"
> class(M)  # Получаем класс объекта
[1] "matrix"
> is.matrix(M) # Проверяем, является ли M матрицей
[1] TRUE
> is.vector(M)  # M не вектор
[1] FALSE
> dim(M)    # Размерности вектора
[1] 10  4

Можно нарисовать данные используя plot():

 
> plot(Height,Weight,ylab="Вес",xlab="Высота",main="Ожирение")

Можно определить структуру данных:

> mydat <- data.frame(M) # Создаём структуру
> names(mydat) # Даём имена каждой переменной
[1] "obs"    "Height" "Weight" "BMI"   
> str(mydat)   # выводим структуру данных
'data.frame':   10 obs. of  4 variables:
 $ obs   : num  1 2 3 4 5 6 7 8 9 10
 $ Height: num  168 177 177 177 178 172 165 171 178 170
 $ Weight: num  88 72 85 52 71 69 61 61 51 75
 $ BMI   : num  31.2 23 27.1 16.6 22.4 ...
> 
> View(mydat)  # Смотрим на данные
> 
> summary(mydat)  # Наглядная статистика
      obs            Height          Weight           BMI       
 Min.   : 1.00   Min.   :165.0   Min.   :51.00   Min.   :16.10  
 1st Qu.: 3.25   1st Qu.:170.2   1st Qu.:61.00   1st Qu.:21.25  
 Median : 5.50   Median :174.5   Median :70.00   Median :22.70  
 Mean   : 5.50   Mean   :173.3   Mean   :68.50   Mean   :22.89  
 3rd Qu.: 7.75   3rd Qu.:177.0   3rd Qu.:74.25   3rd Qu.:25.29  
 Max.   :10.00   Max.   :178.0   Max.   :88.00   Max.   :31.18  
> 

Вы можете сохранить сессию R (все объекты в памяти) и загрузить сессию.

> save.image(file="~/Documents/Logiciels/R/test.rda")
> load("~/Documents/Logiciels/R/test.rda")

Можно определить рабочую директорию. Внимание, для пользователей Windows: R использует прямой, а не обратный слеш, в именах директорий.

> setwd("~/Desktop")            # Устанавливаем рабочую директорию (character string enclosed in "...")
> getwd()                       # Возвращаем текущую рабочую директорию
[1] "/Users/username/Desktop"
> dir() # Выводим список содержимого рабочей директории

В R существуют спецсимволы:

• NA : Not Available (то есть пропущенные значения)
• NaN : Not a Number ("не число", например, неопределённость 0/0)
• Inf: Бесконечность
• -Inf : Минус бесконечность.

Выражение 0 делить на 0 даёт NaN, но 1 делить на 0 даёт $+\infty$

 > 0/0
 [1] NaN
 > 1/0
 [1] Inf

Из R можно выйти используя q(). Аргумент no обозначает, что сессию сохранять не нужно.

q("no")

Типы данных

Все типы данных можно представить двумя группами: контейнеры и первичные типы данных. Любая переменная в языке R может принимать только значение типа контейнера, элементами могут уже являться значения первичных типов данных. Нельзя присвоить переменной значение типа число. Также попытка обратиться к одному элементу вернет контейнер с одним элементом.

При проведении анализа работа почти всегда осуществляется не с отдельными значениями а с группами значений. Поэтому в языке R все операции работают с наборами данных. Кстати команды для выполнения однотипных операций над множеством элементов (расширение SSE) присутствует в системе команд процессора x86-64, это значит что процессор имеет все возможности для оптимизации этих операций, например выполнение суммирования 4х чисел с плавающей точкой float выполняется за один такт. В этой связи в целях оптимизации данные должны быть особым образом представлены в памяти. Из этого вытекают ограничения на однотипность данных в векторах.

Типы данных контейнеров

Тип	Описание	Примеры значений
vector	(вектор) Пронумерованный конечный набор элементов одинакового первичного типа, является наиболее простым в R. Арифметические операции выполняются попарно и требуют одинакового количества элементов в векторах. Количество элементов можно менять. Сами элементы можно менять. Получить доступ к элементу можно указанием его номера например a[1] . Выбирайте этот тип данных если нужно хранить одно или несколько значений, с которыми планируется выполнять одинаковые операции.
factor	(фактор) похож на векторы, но с предопределённым набором уровней.
matrix	(матрицы) похожи на векторы, но с специфическими инструкциями для вывода, чтобы напоминали матрицы из математики.
array	(массивы) похожи на матрицы, но могут иметь размерность больше двух.
list	(список) является вектором для объектов R.
data.frame	(структура) похожа на матрицу, но не требует чтобы все колонки были идентичны по типу. Структура является списком переменных/векторов одинаковой длины.
class	(классы) реализуются как objects (объекты) соответствующего типа данных (то есть класс — это тип данных для переменной, а сама переменная этого типа является объектом — экземпляром класса). Classes (классы) присоединяются к объектам как attribute (атрибуты). Все объекты в R имеют свой класс, тип и размерность.

Первичные типы данных

Тип	Описание	Примеры значений
NULL	Это специальный тип, имеющий лишь одно значение	NULL
logical	Логический тип. Принимает значения NA, NaN, FALSE, TRUE. Значение NA является в своем натуральном представлении в языке как логический тип данных. NA (not available) обозначает, что здесь не доступно какое либо значение для операции. Любые операции с NA вернут NA и таким образом можно будет легко детерминировать ошибку отсутствия данных.	NA, FALSE, TRUE
integer	Целочисленный тип данных. Спец значение NA, NaN	as.integer(NA), 26L
double	Этот тип представляет рациональные числа. Среди специальных значений NA, Inf, -Inf, NaN	as.double(NA), 26
character	Строка или отдельный символ. Специального типа для одиночного символа не предусмотрено. Спец значение NA.

Обратите внимание, во всех контейнерах кроме Dataframe есть требование к одинаковости типов данных элементов, а это значит, у каждого типа данных должно быть свое значение NA, что и показано в таблице.

> class(object)
> typeof(object)
> dim(object)

Векторы

Вы можете создать вектор используя функцию c() которая объединяет несколько однотипных элементов. Возможно, также, создать последовательность используя символ : или функцию seq(). Например, 1:5 создаёт вектор-последовательность чисел от 1 до 5. Функция seq() позволяет указывать интервал между числами. Можно повторять образец используя функцию rep(). Также можно создать численный вектор с пропущенными значениями, используя функцию numeric(), или символьный — character(), или логический (то есть TRUE или FALSE) — logical().

> c(1,2,3,4,5)
[1] 1 2 3 4 5
> c("a","b","c","d","e")
[1] "a" "b" "c" "d" "e"
> c(T,F,T,F)
[1]  TRUE FALSE  TRUE FALSE

> 1:5
[1] 1 2 3 4 5
> 5:1
[1] 5 4 3 2 1
> seq(1,5)
[1] 1 2 3 4 5
> seq(1,5,step=.5)
[1] 1 2 3 4 5
> seq(1,5,by=.5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
> rep(1,5)
[1] 1 1 1 1 1
> rep(1:2,5)
 [1] 1 2 1 2 1 2 1 2 1 2
> numeric(5)
[1] 0 0 0 0 0
> logical(5)
[1] FALSE FALSE FALSE FALSE FALSE
> character(5)
[1] "" "" "" "" ""

Функция length() вычисляет длину вектора (количество переменных, а не ${\sqrt {x^{2}+y^{2}+z^{2}}}$).

x <- seq(1,5,by=.5)                 # Создаём последовательность чисел
x                                  # Отображаем этот объект
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
> length(x)                        # Получаем длину объекта x
[1] 9

Функция last() возвращает последний элемент вектора.

Factors

• Функция factor() трансформирует вектор в factor. Также, factor может быть отсортирован при помощи опции ordered=T или функции ordered().
• Функция levels() возвращает уровни factor-а.
• Функция gl() генерирует factor-ы:
  • n — количество уровней;
  • k — количество повторений каждого factor-а;
  • length — общая длина factor-а;
  • labels — опциональный параметр присваивающий метки каждому уровню.

Смотрите также is.factor(), as.factor(), is.ordered() и as.ordered().

 
> factor(c("yes","no","yes","don't","don't","no","don't","no","no"))
[1] yes   no    yes   don't don't no    don't no    no   
Levels: don't no yes
> 
> factor(c("yes","no","yes","don't","don't","no","don't","no","no"), ordered = T)
[1] yes   no    yes   don't don't no    don't no    no   
Levels: don't < no < yes
> 
> ordered(c("yes","no","yes","don't","don't","no","don't","no","no"))
[1] yes   no    yes   don't don't no    don't no    no   
Levels: don't < no < yes
>
>  gl(n=2, k=2, length=10, labels = c("Male", "Female")) # Генерируем уровни factor-а
 [1] Male   Male   Female Female Male   Male   Female Female Male   Male  
Levels: Male Female

Матрицы

• Если вы хотите создать матрицу, то одной из возможностей является использование функции matrix(). Вы вводите вектора, набор строк или столбцов, и можете указать R как конкретно нужно интерпретировать данные (по умолчанию как столбцы). Вот два примера:

> matrix(data = NA, nrow = 5, ncol = 5, byrow = T)
     [,1] [,2] [,3] [,4] [,5]
[1,]   NA   NA   NA   NA   NA
[2,]   NA   NA   NA   NA   NA
[3,]   NA   NA   NA   NA   NA
[4,]   NA   NA   NA   NA   NA
[5,]   NA   NA   NA   NA   NA

> matrix(data = 1:15, nrow = 5, ncol = 5, byrow = T)
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    3    4    5
[2,]    6    7    8    9   10
[3,]   11   12   13   14   15
[4,]    1    2    3    4    5
[5,]    6    7    8    9   10

• Функции cbind() и rbind() комбинируют векторы в матрицы по столбцам или по строкам:

> v1 <- 1:5
> v2 <- 5:1
> v2
[1] 5 4 3 2 1
> cbind(v1,v2)
     v1 v2
[1,]  1  5
[2,]  2  4
[3,]  3  3
[4,]  4  2
[5,]  5  1

> rbind(v1,v2)
   [,1] [,2] [,3] [,4] [,5]
v1    1    2    3    4    5
v2    5    4    3    2    1

• Размерность матрицы может быть получена при помощи функции dim(). Иначе функции nrow() и ncol() возвращают, соответственно, количество строк и столбцов:

> dim(X)
[1] 5 5
> nrow(X)
[1] 5
> ncol(X)
[1] 5

• Функция t() транспонирует матрицу:

> X<-matrix(data = 1:15, nrow = 5, ncol = 5, byrow = T)
> t(X)
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11    1    6
[2,]    2    7   12    2    7
[3,]    3    8   13    3    8
[4,]    4    9   14    4    9
[5,]    5   10   15    5   10

Структуры

Структуры относят к "спискам переменных/векторов одинаковой длины". В представленном примере, создаётся структура из двух векторов, где каждый из пяти элементов. Первый вектор "v1" состоит из последовательности целых чисел от 1 до 5. Второй вектор "v2" состоит из логических значений.

> v1 = 1:5
> v2 = c(T,T,F,F,T)
> df = data.frame(v1,v2)
> print(df)
  v1    v2
1  1  TRUE
2  2  TRUE
3  3 FALSE
4  4 FALSE
5  5  TRUE

Структуры могут создаваться напрямую. В следующем примере, определение и наименование обоих векторов происходит непосредственно в списке аргументов.

> df = data.frame(foo=1:5,bar=c(T,T,F,F,T))
> print(df)
  foo   bar
1   1  TRUE
2   2  TRUE
3   3 FALSE
4   4 FALSE
5   5  TRUE

Массивы

Массивы состоят из n измерений, где каждое может быть вектором из объектов R одинакового типа. Одномерные массивы с одним элементом могут быть созданы следующим кодом:

> x = array(c(T,F),dim=c(1))
> print(x)
[1] TRUE

Одномерный (dim=c(1)) массив x создаётся из вектора с одним значением из c(T,F). Идентичный одномерный массив y может быть создан с обоими значениями из c(T,F):

> y = array(c(T,F),dim=c(2))
> print(y)
[1]  TRUE FALSE

Трёхмерный массив - 3 на 3 на 3 - может быть создан как показано ниже:

> z = array(1:27,dim=c(3,3,3))
> dim(z)
[1] 3 3 3
> print(z)
, , 1

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

, , 2

     [,1] [,2] [,3]
[1,]   10   13   16
[2,]   11   14   17
[3,]   12   15   18

, , 3

     [,1] [,2] [,3]
[1,]   19   22   25
[2,]   20   23   26
[3,]   21   24   27

Массивы в R используются похожим на другие языки образом: посредством индексирования целыми числами начиная с 1 (а не 0, как в C). Следующий код демонстрирует как можно получить третий элемент трёхмерного массива (то есть массив 3 на 3):

> z[,,3]
     [,1] [,2] [,3]
[1,]   19   22   25
[2,]   20   23   26
[3,]   21   24   27

Указание двух из трёх размерностей возвращает одномерный массив:

> z[,3,3]
[1] 25 26 27

Указание трёх из трёх размерностей возвращает элемент трёхмерного массива:

> z[3,3,3]
[1] 27

Возможна и более сложная адресация:

> z[,c(2,3),c(2,3)]
, , 1

     [,1] [,2]
[1,]   13   16
[2,]   14   17
[3,]   15   18

, , 2

     [,1] [,2]
[1,]   22   25
[2,]   23   26
[3,]   24   27

Массив должен быть симметричным по всем размерностям. Следующий код создаёт пару массивов 3 на 3:

> w = array(1:18,dim=c(3,3,2))
> print(w)
, , 1

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

, , 2

     [,1] [,2] [,3]
[1,]   10   13   16
[2,]   11   14   17
[3,]   12   15   18

Объекты векторов, из которых состоит массив, должны быть одинакового типа, но не обязательно числового:

> u = array(c(T,F),dim=c(3,3,2))
> print(u)
, , 1

      [,1]  [,2]  [,3]
[1,]  TRUE FALSE  TRUE
[2,] FALSE  TRUE FALSE
[3,]  TRUE FALSE  TRUE

, , 2

      [,1]  [,2]  [,3]
[1,] FALSE  TRUE FALSE
[2,]  TRUE FALSE  TRUE
[3,] FALSE  TRUE FALSE

Списки

Список — это коллекция объектов R разного типа. Функция list() создаёт список; unlist() трансформирует список в вектор.

> ret <- list()