Tutoriel sur la restructuration des données en R

La restructuration des données en R consiste à réagencer les lignes et les colonnes selon vos besoins, le plus souvent à partir d’un data frame en R pour effectuer des traitements à l’aide de fonctions comme "rbind()", "cbind()", etc.

Pendant ce processus, vous recomposez les données en lignes et colonnes. Restructurer, c’est organiser les données de manière précise afin de pouvoir les traiter ensuite.

Créer vos données

Créons un générateur de nombres aléatoires et des colonnes à concaténer dans un data frame. Ajoutons également un identifiant pour un usage ultérieur. "set.seed(123)" est utilisé pour produire des nombres aléatoires reproductibles, afin d’obtenir le même échantillon sur toutes les machines. Trois variables, colm1, colm2, colm3, sont créées. Grâce à "sample()", on génère des valeurs de 1 à 15 avec remise, ce qui peut engendrer des répétitions. Le data frame sert à stocker les données sous forme de tableau, et on y ajoute une colonne id, un numéro unique.

set.seed(123)
N <- 15
colm1  <- sample(1:15, N, replace=TRUE)
colm2  <- sample(1:15, N, replace=TRUE)
colm3  <- sample(1:15, N, replace=TRUE)
df_Temp <- data.frame(colm1, colm2,colm3)
df_Temp$id<-seq(nrow(df_Temp))
df_TempPropulsé par

Le code ci-dessus produit la sortie suivante : trois colonnes nommées "colm1", "colm2", "colm3" et une colonne id de 1 à 15. Les colonnes sont remplies de valeurs comprises entre 1 et 15 ; certaines se répètent, d’autres peuvent ne pas apparaître.

 colm1   colm2   colm3  id
  15      11     14     1
  15      5      3      2
  3       3      4      3
  14      11     14     4
  3       9      1      5
  10      12     11     6
  2       9      7      7
  6       9      5      8
  11      13     12     9
  5       3      15     10
  4       8      10     11
  14      10     13     12
  6       7      7      13
  9       10     9      14
 10       9      9      15 Propulsé par

Fonction cbind

Utilisation : permet de combiner par colonnes des vecteurs, des matrices et des data frames.
Paramètres : cbind(v1, v2) : v1, v2 peuvent être des vecteurs, des matrices ou des data frames.

Voyons un exemple d’assemblage en pratique.

On peut sélectionner id via "df_Temp[,4]", tandis que "df_Temp[,2]" sélectionne "colm2" de df_Temp. Ces deux sélections sont passées en paramètres à "cbind()" et stockées dans la variable "cbindexample". Ensuite, on peut renommer les colonnes avec "colnames()" en leur attribuant de nouvelles valeurs, par exemple "newid", "new_colm2".

cbindexample<-cbind(df_Temp[,4],df_Temp[,2])
colnames(cbindexample)<- c('newid','new_colm2')
cbindexamplePropulsé par

Le code ci-dessus montre comment lier deux colonnes (id et colm2) avec la fonction "cbind" pour créer un nouveau data frame. Les noms de colonnes ont été modifiés en "new_colm2" et "newid".

newid   new_colm2
1         11
2         5
3         3
4         11
5         9
6         12
7         9
8         9
9         13
10         3
11         8
12         10
13         7
14         10
15         9Propulsé par

Fonction rbind :

Utilisation : rbind permet de combiner par lignes des vecteurs, des matrices ou des data frames.
Paramètres : rbind(v1, v2) : v1, v2 peuvent être des vecteurs, des matrices ou des data frames.

Créons un nouveau vecteur nommé "new_vector" et combinons-le au data frame "cbindexample" (2 colonnes) à l’aide de "rbind" ; les deux sont concaténés et stockés dans "rbindexample".

new_vector<- c(16,15)
rbindexample<- rbind(cbindexample,new_vector)
rbindexamplePropulsé par

Le code ci-dessus ajoute une nouvelle ligne avec les valeurs 16 et 15 respectivement dans "newid" et "new_colm2".

newid    new_colm2
1        11
2        5
3        3
4        11
5        9
6        12
7        9
8        9
9        13
10       3
11       8
12       10
13       7
14       10
15       9
16       15Propulsé par

Fonction Melt :

Utilisation : la fonction Melt convertit un objet en format « fondu », c’est-à-dire qu’elle prend plusieurs colonnes et les transforme en une seule colonne.
Paramètres : melt(data, …, na.rm=FALSE/TRUE, value.name="value")
data : l’entrée à « faire fondre ».
... : paramètres passés à/depuis d’autres fonctions.
na.rm : convertit des valeurs manquantes explicites en manquantes implicites.
value.name : nom de la colonne où stocker les valeurs.
Voici un exemple où l’on « fait fondre » les données à l’aide de la variable id pour obtenir une colonne avec le nom de variable et la valeur :

Importons la bibliothèque "reshape2" via "library()" et utilisons melt pour rassembler les colonnes colm1, colm2, colm3 de "df_Temp" en une seule colonne "variable" en s’appuyant sur la colonne "id".

library(reshape2)
molted=melt(df_Temp,id.vars=c("id"))
moltedPropulsé par

id    variable value
1    colm1    15
2    colm1     15
3    colm1     3
4    colm1     14
5    colm1     3
6    colm1     10
7    colm1     2
8    colm1     6
9    colm1     11
10    colm1     5
11    colm1     4
12    colm1     14
13    colm1     6
14    colm1     9
15    colm1     10
1    colm2     11
2    colm2     5
3    colm2     3
4    colm2     11
5    colm2     9
6    colm2     12
7    colm2     9
8    colm2     9
9    colm2     13
10    colm2     3
11    colm2     8
12    colm2     10
13    colm2     7
14    colm2     10
15    colm2     9
1    colm3     14
2    colm3     3
3    colm3     4
4    colm3     14
5    colm3     1
6    colm3     11
7    colm3     7
8    colm3     5
9    colm3     12
10    colm3     15
11    colm3     10
12    colm3     13
13    colm3     7
14    colm3     9
15    colm3     9Propulsé par

La sortie montre que, lorsque vous « faites fondre » colm1, colm2 et colm3 selon la variable id, elles sont combinées dans une seule colonne nommée "variable" et leurs valeurs se trouvent dans "value".

Fonction Dcast :

Utilisation : à partir d’un jeu de données fondu, vous pouvez revenir au format d’origine avec cette fonction.
Paramètres : dcast(data, id_variable~value)
data : données « fondues » à reconvertir en format d’origine.
id_variable : une ou plusieurs colonnes utilisées pour faire fondre d’autres colonnes en une seule.
~ : après ce signe, on place les valeurs ou la nouvelle colonne fondue du jeu de données fondu.

Voici le code où "reshape2" est importé avec "library()" ; "dcast()" prend en premier paramètre les données issues de "melt()" et reconstruit le tableau avec "id" et la nouvelle colonne fondue après le "~".

library(reshape2)
dcast(molted,id~variable)Propulsé par

id    colm1    colm2    colm3
1        15        11        14
2        15        5         3
3        3        3         4
4        14        11       14
5        3        9         1
6        10        12        11
7        2         9         7
8        6        9         5
9       11        13        12
10       5        3        15
11       4        8        10
12       14        10        13
13       6        7        7
14       9        10        9
15      10        9        9Propulsé par

On constate que les données fondues via "melt()" retrouvent leur forme initiale : trois colonnes avec leurs valeurs respectives, et id dans une colonne séparée.

Fonction de transposition :

Utilisation : permet d’échanger lignes et colonnes.
Paramètres : t(data). "data" est le data frame à transposer.

Transformons les lignes en colonnes et inversement avec la fonction de transposition. Il suffit d’utiliser "t(df_Temp)" comme ci-dessous.

trans <- t(df_Temp)
transPropulsé par

Le code ci-dessus produit la sortie suivante :

colm1    15    15    3    14    3    10    2    6    11    5    4    14    6    9    10
colm2    11    5    3    11    9    12    9    9    13    3    8    10    7    10    9
colm3    14    3    4    14    1    11    7    5    12    15    10    13    7    9    9
id    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15Propulsé par

On voit que le data frame, initialement composé de 15 lignes et 4 colonnes, est converti en 15 colonnes et 3 lignes après transposition.

Félicitations

Félicitations, vous êtes arrivé au terme de ce tutoriel !

Dans ce tutoriel, vous avez passé en revue différentes fonctions de R comme "rbind()", "cbind()", ainsi que "Melt()", "Dcast()", et enfin la fonction de transposition.

Pour aller plus loin avec R, suivez le cours Introduction to R de DataCamp et consultez notre guide d’initiation aux packages R.

Références :
Fonctions Melt