Язык программирования 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-флеш диск.[1]

См. также[править]

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

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

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

> a <- 2
> a = 2
  • Аргументы передаются в круглых скобках.
  • Обычно, лучше использовать кавычки для имён, но это не всегда необходимо.
  • Функции можно просто комбинировать. Например, вы можете написать:
mean(rnorm(1000)^2)
  • «#» используется для комментариев:
# Это комментарий
5 + 7 # Это тоже комментарий
  • Команды отделяются точкой с запятой «;» или символом перевода каретки. Если вы хотите разместить в одной строке более одного выражения, то необходимо использовать разделитель «;».
a <- 1:10; mean(a);
  • Также вы можете разбить одно выражение на несколько строк кода.
  • R чувствителен к регистру: «a» и «A» являются двумя разными объектами.
  • Традиционно символ подчёркивания «_» не используется в именах. Зачастую лучше использовать символ точки «.». Следует избегать использования символа подчёркивания в качестве первого символа в имени объекта.

См. также[править]

Простые примеры[править]

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 даёт

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

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

q("no")

Типы данных[править]

Vectors (векторы) являются наиболее простыми из объектов R. Factors похожи на векторы, но с предопределённым набором уровней. Matrix (матрицы) похожи на векторы, но с специфическими инструкциями для вывода, чтобы напоминали матрицы из математики. Arrays (массивы) похожи на матрицы, но могут иметь размерность больше двух. List (список) является вектором для объектов R. Dataframe (структура) похожа на матрицу, но не требует чтобы все колонки были идентичны по типу. Структура является списком переменных/векторов одинаковой длины. Classes (классы) реализуются как objects (объекты) соответствующего типа данных (то есть класс — это тип данных для переменной, а сама переменная этого типа является объектом — экземпляром класса). Classes (классы) присоединяются к объектам как attribute (атрибуты). Все объекты в R имеют свой класс, тип и размерность.

> 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() вычисляет длину вектора (количество переменных, а не ).

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()

Ссылки[править]

  1. Portable R by Andrew Redd http://sourceforge.net/projects/rportable/(англ.)