R Language
Кадры данных

Синтаксис

• data.frame (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, strAsAsFactors = default.stringsAsFactors ())

• as.data.frame (x, row.names = NULL, optional = FALSE, ...) # общая функция

• as.data.frame (x, ..., stringsAsFactors = default.stringsAsFactors ()) # Метод S3 для символа класса '

• as.data.frame (x, row.names = NULL, optional = FALSE, ..., stringsAsFactors = default.stringsAsFactors ()) # Метод S3 для класса 'matrix'

• is.data.frame (х)

Создайте пустой файл data.frame

Data.frame - это особый вид списка: он прямоугольный . Каждый элемент (столбец) списка имеет одинаковую длину и где каждая строка имеет «имя строки». Каждый столбец имеет свой собственный класс, но класс одного столбца может отличаться от класса другого столбца (в отличие от матрицы, где все элементы должны иметь один и тот же класс).

В принципе, data.frame не может содержать строк и столбцов:

> structure(list(character()), class = "data.frame")
NULL
<0 rows> (or 0-length row.names)

Но это необычно. Для data.frame чаще встречается много столбцов и много строк. Вот кадр data.frame с тремя строками и двумя столбцами ( a - числовой класс, а b - класс символов):

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame")
[1] a b
<0 rows> (or 0-length row.names)

Для того, чтобы print.frame был напечатан, нам нужно будет указать некоторые имена строк. Здесь мы используем только числа 1: 3:

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame", row.names = 1:3)
  a b
1 1 a
2 2 b
3 3 c

Теперь становится очевидным, что у нас есть data.frame с 3 строками и 2 столбцами. Вы можете проверить это, используя nrow() , ncol() и dim() :

> x <- structure(list(a = numeric(3), b = character(3)), class = "data.frame", row.names = 1:3)
> nrow(x)
[1] 3
> ncol(x)
[1] 2
> dim(x)
[1] 3 2

R предоставляет две другие функции (помимо structure() ), которые можно использовать для создания data.frame. Первый называется интуитивно, data.frame() . Он проверяет, являются ли допустимые имена столбцов действительными, что элементы списка имеют одинаковую длину и поставляет некоторые автоматически сгенерированные имена строк. Это означает, что вывод data.frame() теперь может быть точно таким, какой вы ожидаете:

> str(data.frame("a a a" = numeric(3), "b-b-b" = character(3)))
'data.frame':   3 obs. of  2 variables:
 $ a.a.a: num  0 0 0
 $ b.b.b: Factor w/ 1 level "": 1 1 1

Другая функция называется as.data.frame() . Это можно использовать для принуждения объекта, который не является data.frame, в data.frame, запустив его через data.frame() . В качестве примера рассмотрим матрицу:

> m <- matrix(letters[1:9], nrow = 3)
> m
     [,1] [,2] [,3]
[1,] "a"  "d"  "g" 
[2,] "b"  "e"  "h" 
[3,] "c"  "f"  "i" 

И результат:

> as.data.frame(m)
  V1 V2 V3
1  a  d  g
2  b  e  h
3  c  f  i
> str(as.data.frame(m))
'data.frame':   3 obs. of  3 variables:
 $ V1: Factor w/ 3 levels "a","b","c": 1 2 3
 $ V2: Factor w/ 3 levels "d","e","f": 1 2 3
 $ V3: Factor w/ 3 levels "g","h","i": 1 2 3

Подстановка строк и столбцов из кадра данных

Синтаксис для доступа к строкам и столбцам: [ , [[ , и $

В этом разделе рассматривается наиболее распространенный синтаксис для доступа к определенным строкам и столбцам фрейма данных. Это

• Подобно matrix с одиночными скобками data[rows, columns]
  • Использование номеров строк и столбцов
  • Использование имен столбцов (и строк)
• Как list :
  • С помощью отдельных скобок data[columns] для получения кадра данных
  • С двойными скобками data[[one_column]] чтобы получить вектор
• С $ для одного столбца data$column_name

Для иллюстрации мы будем использовать встроенный mtcars данных mtcars .

Как и матрица: data[rows, columns]

С числовыми индексами

Используя встроенные mtcars фрейма mtcars , мы можем извлекать строки и столбцы, используя [] скобки с включенной запятой. Индексами перед запятой являются строки:

# get the first row
mtcars[1, ]
# get the first five rows
mtcars[1:5, ]

Аналогично, после запятой столбцы:

# get the first column
mtcars[, 1]
# get the first, third and fifth columns:
mtcars[, c(1, 3, 5)]

Как показано выше, если строки или столбцы оставлены пустыми, все будут выбраны. mtcars[1, ] указывает первую строку со всеми столбцами.

С именами столбцов (и строк)

Пока это идентично тому, как доступны строки и столбцы матриц. При использовании data.frame s большую часть времени предпочтительно использовать имя столбца для индекса столбца. Это делается с помощью character с именем столбца вместо numeric с номером столбца:

# get the mpg column
mtcars[, "mpg"]
# get the mpg, cyl, and disp columns
mtcars[, c("mpg", "cyl", "disp")]

Хотя реже, имена строк также могут быть использованы:

mtcars["Mazda Rx4", ]

Строки и столбцы вместе

Аргументы строки и столбца могут использоваться вместе:

# first four rows of the mpg column
mtcars[1:4, "mpg"]

# 2nd and 5th row of the mpg, cyl, and disp columns
mtcars[c(2, 5), c("mpg", "cyl", "disp")]

Предупреждение о размерах:

При использовании этих методов, если вы извлекаете несколько столбцов, вы получите обратный кадр данных. Однако, если вы извлекаете один столбец, вы получите вектор, а не фрейм данных по умолчанию.

## multiple columns returns a data frame
class(mtcars[, c("mpg", "cyl")])
# [1] "data.frame"
## single column returns a vector
class(mtcars[, "mpg"])
# [1] "numeric"

Существует два пути. Один из них - рассматривать кадр данных как список (см. Ниже), а другой - добавить аргумент drop = FALSE . Это говорит R, чтобы не «удалить неиспользуемые измерения»:

class(mtcars[, "mpg", drop = FALSE])
# [1] "data.frame"

Обратите внимание, что матрицы работают одинаково - по умолчанию один столбец или строка будет вектором, но если вы укажете drop = FALSE вы можете сохранить его как одностоечную или однострочную матрицу.

Как список

Кадры данных по существу представляют собой list s, т. Е. Они представляют собой список векторов столбцов (все они должны иметь одинаковую длину). Списки могут быть подмножеством с использованием отдельных скобок [ для вспомогательного списка или двойных скобок [[ для одного элемента.

С отдельными скобками data[columns]

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

mtcars["mpg"]
mtcars[c("mpg", "cyl", "disp")]
my_columns <- c("mpg", "cyl", "hp")
mtcars[my_columns]

Разница между data[columns] и data[, columns] заключается в том, что при обработке data.frame в виде list (без запятой в скобках) возвращенный объект будет data.frame . Если вы используете запятую для обработки data.frame как в matrix то выбор одного столбца возвращает вектор, но выбор нескольких столбцов вернет data.frame .

## When selecting a single column
## like a list will return a data frame
class(mtcars["mpg"])
# [1] "data.frame"
## like a matrix will return a vector
class(mtcars[, "mpg"])
# [1] "numeric"

С двойными скобками data[[one_column]]

Чтобы извлечь один столбец в качестве вектора при обработке вашего data.frame в виде list , вы можете использовать двойные скобки [[ . Это будет работать только для одного столбца за раз.

# extract a single column by name as a vector 
mtcars[["mpg"]]

# extract a single column by name as a data frame (as above)
mtcars["mpg"]

Использование $ для доступа к столбцам

Один столбец можно извлечь с помощью магического ярлыка $ без использования имени столбца:

# get the column "mpg"
mtcars$mpg

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

Недостатки $ для доступа к столбцам

$ Может быть удобным ярлыком, особенно если вы работаете в среде (например, RStudio), которая в этом случае автоматически завершит имя столбца. Тем не менее, у $ есть и недостатки: он использует нестандартную оценку, чтобы избежать необходимости в котировках, что означает, что она не будет работать, если имя столбца будет храниться в переменной.

my_column <- "mpg"
# the below will not work
mtcars$my_column
# but these will work
mtcars[, my_column]  # vector
mtcars[my_column]    # one-column data frame
mtcars[[my_column]]  # vector

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

Также обратите внимание, что поведение по умолчанию заключается в использовании частичного соответствия только при извлечении из рекурсивных объектов (кроме окружений) на $

# give you the values of "mpg" column 
# as "mtcars" has only one column having name starting with "m"
mtcars$m 
# will give you "NULL" 
# as "mtcars" has more than one columns having name starting with "d"
mtcars$d

Расширенное индексирование: отрицательные и логические индексы

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

Отрицательные индексы опускают элементы

mtcars[1, ]   # first row
mtcars[ -1, ] # everything but the first row
mtcars[-(1:10), ] # everything except the first 10 rows

Логические векторы указывают на конкретные элементы, которые

Мы можем использовать условие, такое как < чтобы генерировать логический вектор и извлекать только строки, которые удовлетворяют условию:

# logical vector indicating TRUE when a row has mpg less than 15
# FALSE when a row has mpg >= 15
test <- mtcars$mpg < 15 

# extract these rows from the data frame 
mtcars[test, ]

Мы также можем обойти шаг сохранения промежуточной переменной

# extract all columns for rows where the value of cyl is 4.
mtcars[mtcars$cyl == 4, ]
# extract the cyl, mpg, and hp columns where the value of cyl is 4
mtcars[mtcars$cyl == 4, c("cyl", "mpg", "hp")]

Удобные функции для манипулирования data.frames

Некоторые удобные функции для манипулирования data.frames - это subset() , transform() , with() и within() .

подмножество

Функция subset() позволяет вам подмножество data.frame более удобным способом (подмножество также работает с другими классами):

subset(mtcars, subset = cyl == 6, select = c("mpg", "hp"))
                mpg  hp
Mazda RX4      21.0 110
Mazda RX4 Wag  21.0 110
Hornet 4 Drive 21.4 110
Valiant        18.1 105
Merc 280       19.2 123
Merc 280C      17.8 123
Ferrari Dino   19.7 175

В приведенном выше коде мы запрашиваем только строки, в которых cyl == 6 и для столбцов mpg и hp . Вы можете добиться того же результата, используя [] со следующим кодом:

mtcars[mtcars$cyl == 6, c("mpg", "hp")]

преобразование

Функция transform() является удобной функцией для изменения столбцов внутри data.frame . Например, следующий код добавляет другой столбец с именем mpg2 с результатом mpg^2 в mtcars data.frame :

mtcars <- transform(mtcars, mpg2 = mpg^2)

с и внутри

И with() и within() позволяют оценивать выражения внутри среды data.frame , позволяя несколько более чистый синтаксис, сохраняя при этом использование некоторых $ или [] .

Например, если вы хотите создать, изменить и / или удалить несколько столбцов в airquality data.frame :

aq <- within(airquality, {     
    lOzone <- log(Ozone) # creates new column
    Month <- factor(month.abb[Month]) # changes Month Column
    cTemp <- round((Temp - 32) * 5/9, 1) # creates new column
    S.cT <- Solar.R / cTemp  # creates new column
    rm(Day, Temp) # removes columns
})

Вступление

Кадры данных, скорее всего, представляют собой структуру данных, которую вы больше всего будете использовать в своих анализах. Кадр данных представляет собой особый вид списка, в котором хранятся векторы одинаковой длины разных классов. Вы создаете кадры данных, используя функцию data.frame . Пример ниже показывает это, комбинируя числовой и символьный вектор в кадре данных. Он использует оператор : который создаст вектор, содержащий все целые числа от 1 до 3.

df1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
df1
##   x y
## 1 1 a
## 2 2 b
## 3 3 c
class(df1)
## [1] "data.frame"

Объекты фрейма данных не печатаются с кавычками, поэтому класс столбцов не всегда очевиден.

df2 <- data.frame(x = c("1", "2", "3"), y = c("a", "b", "c"))
df2
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

Без дальнейшего изучения столбцы «x» в df1 и df2 не могут быть дифференцированы. Функция str может использоваться для описания объектов с большей детализацией, чем класс.

str(df1)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3
str(df2)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: Factor w/ 3 levels "1","2","3": 1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3

Здесь вы видите, что df1 является data.frame и имеет 3 наблюдения из 2 переменных, «x» и «y». Затем вам сообщают, что «x» имеет целое число типа данных (не важно для этого класса, но для наших целей оно ведет себя как числовое), а «y» - это фактор с тремя уровнями (другой класс данных, который мы не обсуждаем). Важно отметить, что по умолчанию кадры данных заставляют персонажей влиять на факторы. Поведение по умолчанию может быть изменено с помощью параметра stringsAsFactors :

df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)
str(df3)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: chr  "a" "b" "c"

Теперь столбец «y» является символом. Как упоминалось выше, каждый «столбец» кадра данных должен иметь одинаковую длину. Попытка создать data.frame из векторов разной длины приведет к ошибке. (Попробуйте запустить data.frame(x = 1:3, y = 1:4) чтобы увидеть полученную ошибку.)

В качестве тестовых примеров для кадров данных некоторые данные предоставляются R по умолчанию. Один из них - радужная оболочка, загружается следующим образом:

mydataframe <- iris
str(mydataframe)

Преобразование данных, хранящихся в списке, в один кадр данных с использованием do.call

Если у вас есть данные, хранящиеся в списке, и вы хотите преобразовать этот список в кадр do.call функция do.call - это простой способ достичь этого. Однако важно, чтобы все элементы списка имели одинаковую длину, чтобы предотвратить непреднамеренную рециркуляцию значений.

dataList  <- list(1:3,4:6,7:9)  
dataList
# [[1]]
# [1] 1 2 3
#
# [[2]]
# [1] 4 5 6
#
# [[3]]
# [1] 7 8 9

dataframe <- data.frame(do.call(rbind, dataList))
dataframe
#   X1 X2 X3
# 1  1  2  3
# 2  4  5  6
# 3  7  8  9 

Он также работает, если ваш список состоит из самих фреймов данных.

dataframeList  <- list(data.frame(a = 1:2, b = 1:2, c = 1:2), 
                       data.frame(a = 3:4, b = 3:4, c = 3:4))
dataframeList
# [[1]]
#   a b c
# 1 1 1 1
# 2 2 2 2

# [[2]]
#   a b c
# 1 3 3 3
# 2 4 4 4

dataframe      <- do.call(rbind, dataframeList)
dataframe
#   a b c
# 1 1 1 1
# 2 2 2 2
# 3 3 3 3
# 4 4 4 4

Преобразование всех столбцов в data.frame в класс символов

Общая задача состоит в том, чтобы преобразовать все столбцы класса data.frame в класс символов для удобства манипуляции, например, в случае отправки данных. Кадров в СУБД или слияния data.frames, содержащих факторы, в которых уровни могут различаться между входными данными. ,

Лучшее время для этого - когда считываются данные - почти все методы ввода, которые создают кадры данных, имеют stringsAsFactors параметровAsFactors, которые могут быть установлены в FALSE .

Если данные уже созданы, столбцы факторов могут быть преобразованы в столбцы символов, как показано ниже.

bob <- data.frame(jobs = c("scientist", "analyst"), 
                  pay  = c(160000, 100000), age = c(30, 25))
str(bob)

'data.frame':    2 obs. of  3 variables:
 $ jobs: Factor w/ 2 levels "analyst","scientist": 2 1
 $ pay : num  160000 100000
 $ age : num  30 25

# Convert *all columns* to character
bob[] <- lapply(bob, as.character)
str(bob)

    'data.frame':    2 obs. of  3 variables:
 $ jobs: chr  "scientist" "analyst"
 $ pay : chr  "160000" "1e+05"
 $ age : chr  "30" "25"

# Convert only factor columns to character
bob[] <- lapply(bob, function(x) {
    if is.factor(x) x <- as.character(x)
    return(x)
})

Подмножество строк по значениям столбцов

Встроенные функции могут подмножать rows с columns , отвечающими условиям.

df <- data.frame(item = c(1:10),
                 price_Elasticity = c(-0.57667, 0.03205, -0.04904, 0.10342, 0.04029, 
                                       0.0742, 0.1669, 0.0313, 0.22204, 0.06158),
                 total_Margin = c(-145062, 98671, 20576, -56382, 207623, 43463, 1235, 
                                   34521, 146553, -74516))

Чтобы найти rows с price_Elasticity > 0 :

df[df$price_Elasticity > 0, ]

   item price_Elasticity total_Margin
2     2          0.03205        98671
4     4          0.10342       -56382
5     5          0.04029       207623
6     6          0.07420        43463
7     7          0.16690         1235
8     8          0.03130        34521
9     9          0.22204       146553
10   10          0.06158       -74516

подмножество на основе price_Elasticity > 0 и total_Margin > 0 :

df[df$price_Elasticity > 0 & df$total_Margin > 0, ]

  item price_Elasticity total_Margin
2    2          0.03205        98671
5    5          0.04029       207623
6    6          0.07420        43463
7    7          0.16690         1235
8    8          0.03130        34521
9    9          0.22204       146553