R Language
Trames de données
Recherche…
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 desdata[rows, columns]
entre parenthèsesdata[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èsesdata[columns]
pour obtenir un bloc de données - Avec des crochets doubles
data[[one_column]]
pour obtenir un vecteur
- Avec des
- Avec
$
pour une seule colonnedata$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]
Des crochets simples comme une liste ou des crochets simples comme une matrice 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