R Language
Trames de données

Syntaxe

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

• as.data.frame (x, row.names = NULL, optionnel = FALSE, ...) # fonction générique

• as.data.frame (x, ..., stringsAsFactors = default.stringsAsFactors ()) # Méthode S3 pour la classe 'character'

• as.data.frame (x, row.names = NULL, optionnel = FALSE, ..., stringsAsFactors = default.stringsAsFactors ()) # Méthode S3 pour la classe 'matrix'

• is.data.frame (x)

Créer un data.frame vide

Un data.frame est un type particulier de liste: il est rectangulaire . Chaque élément (colonne) de la liste a la même longueur et chaque ligne a un "nom de ligne". Chaque colonne a sa propre classe, mais la classe d'une colonne peut être différente de la classe d'une autre colonne (contrairement à une matrice où tous les éléments doivent avoir la même classe).

En principe, un data.frame pourrait ne pas avoir de lignes et pas de colonnes:

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

Mais c'est inhabituel. Il est plus courant qu'un data.frame ait beaucoup de colonnes et de nombreuses lignes. Voici un data.frame avec trois lignes et deux colonnes ( a est a classe numérique et b classe de caractères):

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

Pour que le fichier data.frame soit imprimé, nous devrons fournir des noms de lignes. Ici on utilise juste les chiffres 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

Maintenant, il devient évident que nous avons un data.frame avec 3 lignes et 2 colonnes. Vous pouvez vérifier cela en utilisant nrow() , ncol() et 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 fournit deux autres fonctions (en plus de structure() ) qui peuvent être utilisées pour créer un data.frame. Le premier est appelé intuitivement data.frame() . Il vérifie que les noms de colonnes que vous avez fournis sont valides, que les éléments de la liste ont tous la même longueur et fournit des noms de lignes générés automatiquement. Cela signifie que la sortie de data.frame() peut maintenant être exactement ce que vous attendez:

> 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

L'autre fonction s'appelle as.data.frame() . Cela peut être utilisé pour contraindre un objet qui n'est pas un data.frame à être un data.frame en l'exécutant via data.frame() . À titre d'exemple, considérons une matrice:

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

Et le résultat:

> 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

Sous-série de lignes et de colonnes à partir d'un bloc de données

Syntaxe d'accès aux lignes et aux colonnes: [ , [[ et $

Cette rubrique couvre la syntaxe la plus courante pour accéder à des lignes et colonnes spécifiques d'un bloc de données. Ceux-ci sont

• Comme une matrix avec des data[rows, columns] entre parenthèses data[rows, columns]
  • Utiliser des numéros de ligne et de colonne
  • Utilisation de noms de colonnes (et de lignes)
• Comme une list :
  • Avec des data[columns] entre parenthèses data[columns] pour obtenir un bloc de données
  • Avec des crochets doubles data[[one_column]] pour obtenir un vecteur
• Avec $ pour une seule colonne data$column_name

Nous utiliserons le mtcars données mtcars pour illustrer.

Comme une matrice: data[rows, columns]

Avec index numériques

En utilisant les mtcars trame de données mtcars , nous pouvons extraire des lignes et des colonnes en utilisant les crochets [] avec une virgule. Les indices avant la virgule sont des lignes:

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

De même, après la virgule sont des colonnes:

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

Comme indiqué ci-dessus, si des lignes ou des colonnes sont laissées en blanc, toutes seront sélectionnées. mtcars[1, ] indique la première ligne avec toutes les colonnes.

Avec des noms de colonnes (et de lignes)

Jusqu'à présent, ceci est identique à la manière dont les lignes et les colonnes des matrices sont accessibles. Avec data.frame s, la plupart du temps, il est préférable d'utiliser un nom de colonne pour un index de colonne. Ceci est fait en utilisant un character avec le nom de la colonne au lieu de numeric avec un numéro de colonne:

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

Bien que moins courants, les noms de lignes peuvent également être utilisés:

mtcars["Mazda Rx4", ]

Rangées et colonnes ensemble

Les arguments de ligne et de colonne peuvent être utilisés ensemble:

# 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")]

Un avertissement sur les dimensions:

En utilisant ces méthodes, si vous extrayez plusieurs colonnes, vous obtiendrez un bloc de données. Cependant, si vous extrayez une seule colonne, vous obtiendrez un vecteur, pas un bloc de données sous les options par défaut.

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

Il y a deux façons de contourner cela. L'une consiste à traiter le bloc de données sous la forme d'une liste (voir ci-dessous), l'autre consiste à ajouter un argument drop = FALSE . Cela indique à R de ne pas "supprimer les dimensions inutilisées":

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

Notez que les matrices fonctionnent de la même manière - par défaut, une seule colonne ou une seule ligne sera un vecteur, mais si vous spécifiez drop = FALSE vous pouvez le conserver en tant que matrice à une colonne ou à une ligne.

Comme une liste

Les trames de données sont essentiellement des list , c'est-à-dire qu'elles constituent une liste de vecteurs de colonne (que tous doivent avoir la même longueur). Les listes peuvent être regroupées en utilisant des crochets simples [ pour une sous-liste ou des doubles crochets [[ pour un seul élément.

Avec des data[columns] entre parenthèses data[columns]

Lorsque vous utilisez des crochets simples et aucune virgule, vous obtenez une colonne car les blocs de données sont des listes de colonnes.

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

La différence entre data[columns] et data[, columns] est que lors du traitement du data.frame tant que list (pas de virgule entre parenthèses), l'objet retourné sera un data.frame . Si vous utilisez une virgule pour traiter le data.frame comme une matrix alors sélectionner une seule colonne renverra un vecteur mais sélectionner plusieurs colonnes renverra un 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"

Avec des data[[one_column]] doubles crochets data[[one_column]]

Pour extraire une seule colonne en tant que vecteur lors du traitement de votre data.frame tant que list , vous pouvez utiliser des doubles crochets [[ . Cela ne fonctionnera que pour une seule colonne à la fois.

# 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"]

Utiliser $ pour accéder aux colonnes

Une seule colonne peut être extraite en utilisant le raccourci magique $ sans utiliser de nom de colonne entre guillemets:

# get the column "mpg"
mtcars$mpg

Les colonnes accessibles par $ seront toujours des vecteurs, pas des trames de données.

Inconvénients de $ pour accéder aux colonnes

Le $ peut être un raccourci pratique, surtout si vous travaillez dans un environnement (tel que RStudio) qui va automatiquement compléter le nom de la colonne dans ce cas. Cependant, $ a aussi des inconvénients: il utilise une évaluation non standard pour éviter le besoin de devis, ce qui signifie que cela ne fonctionnera pas si votre nom de colonne est stocké dans une variable.

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

En raison de ces préoccupations, $ est mieux utilisé dans les sessions R interactives lorsque les noms de vos colonnes sont constants. Pour une utilisation par programme , par exemple en écrivant une fonction généralisable qui sera utilisée sur différents ensembles de données avec des noms de colonnes différents, $ devrait être évité.

Notez également que le comportement par défaut consiste à utiliser une correspondance partielle uniquement lors de l'extraction d'objets récursifs (à l'exception des environnements) par $

# 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

Indexation avancée: indices négatifs et logiques

Chaque fois que nous avons la possibilité d'utiliser des nombres pour un index, nous pouvons également utiliser des nombres négatifs pour omettre certains indices ou un vecteur booléen (logique) pour indiquer exactement quels éléments conserver.

Les indices négatifs omettent des éléments

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

Les vecteurs logiques indiquent des éléments spécifiques à conserver

Nous pouvons utiliser une condition telle que < pour générer un vecteur logique et extraire uniquement les lignes correspondant à la condition:

# 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, ]

Nous pouvons également éviter l'étape de sauvegarde de la variable intermédiaire

# 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")]

Fonctions de commodité pour manipuler data.frames

Certaines fonctions pratiques pour manipuler data.frames sont subset() , transform() , with() et within() .

sous-ensemble

La fonction subset() vous permet de sous- data.frame un data.frame de manière plus pratique (sous-ensemble fonctionne également avec d'autres classes):

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

Dans le code ci-dessus, nous demandons uniquement les lignes dans lesquelles cyl == 6 et pour les colonnes mpg et hp . Vous pouvez obtenir le même résultat en utilisant [] avec le code suivant:

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

transformer

La fonction transform() est une fonction pratique pour changer les colonnes dans un data.frame . Par exemple, le code suivant ajoute une autre colonne nommée mpg2 avec le résultat de mpg^2 au mtcars data.frame :

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

avec et dans

Les deux with() et within() vous permettent d'évaluer les expressions à l'intérieur de l'environnement data.frame , permettant une syntaxe un peu plus nette, vous évitant ainsi l'utilisation de $ ou [] .

Par exemple, si vous souhaitez créer, modifier et / ou supprimer plusieurs colonnes dans le 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
})

introduction

Les blocs de données sont probablement la structure de données que vous utiliserez le plus dans vos analyses. Un bloc de données est un type spécial de liste qui stocke des vecteurs de même longueur de différentes classes. Vous créez des trames de données en utilisant la fonction data.frame . L'exemple ci-dessous le montre en combinant un vecteur numérique et un vecteur de caractères dans un bloc de données. Il utilise le : opérateur, qui va créer un vecteur contenant tous les entiers de 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"

Les objets de bloc de données n'impriment pas avec des guillemets, de sorte que la classe des colonnes n'est pas toujours évidente.

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

Sans autre étude, les colonnes "x" de df1 et df2 ne peuvent pas être différenciées. La fonction str peut être utilisée pour décrire des objets avec plus de détails que la classe.

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

Ici, vous voyez que df1 est un data.frame et a 3 observations de 2 variables, "x" et "y". On vous dit alors que "x" a le type entier de données (pas important pour cette classe, mais pour notre propos il se comporte comme un numérique) et "y" est un facteur à trois niveaux (une autre classe de données dont nous ne parlons pas). Il est important de noter que, par défaut, les blocs de données contraignent les caractères à des facteurs. Le comportement par défaut peut être modifié avec le paramètre 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"

Maintenant, la colonne "y" est un caractère. Comme mentionné ci-dessus, chaque "colonne" d'un bloc de données doit avoir la même longueur. Essayer de créer un fichier data.fr à partir de vecteurs de différentes longueurs entraînera une erreur. (Essayez d'exécuter data.frame(x = 1:3, y = 1:4) pour voir l'erreur qui en résulte.)

Comme cas de test pour les trames de données, certaines données sont fournies par défaut par R. L'un d'eux est l'iris, chargé comme suit:

mydataframe <- iris
str(mydataframe)

Convertir des données stockées dans une liste en un seul bloc de données à l'aide de do.call

Si vos données sont stockées dans une liste et que vous souhaitez convertir cette liste en do.call données, la fonction do.call est un moyen simple d'y parvenir. Cependant, il est important que tous les éléments de la liste aient la même longueur afin d'empêcher le recyclage involontaire des valeurs.

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 

Cela fonctionne également si votre liste est constituée de trames de données elle-même.

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

Convertir toutes les colonnes d'un data.frame en classe de caractères

Une tâche commune consiste à convertir toutes les colonnes d'un data.frame en classe de caractères pour faciliter la manipulation, par exemple dans le cas de l'envoi de data.frames à un SGBDR ou de la fusion de data.frames contenant des facteurs dont les niveaux peuvent différer. .

Le meilleur moment pour cela est lorsque les données sont lues - presque toutes les méthodes de saisie qui créent des trames de données ont des options stringsAsFactors qui peuvent être définies sur FALSE .

Si les données ont déjà été créées, les colonnes de facteurs peuvent être converties en colonnes de caractères, comme indiqué ci-dessous.

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

Sous-classement des lignes par valeurs de colonne

Les fonctions intégrées peuvent sous-définir des rows avec des columns répondant aux conditions.

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

Pour rechercher des rows avec 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

sous-ensemble basé sur price_Elasticity > 0 et 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