Data Frames et Facteurs

Facteurs

Facteur : type de vecteur qui code pour une propriété qualititative (attribut nominal) qui est codé en interne par un numéro et non par la chaîne de caractère représentant sa valeur. Exemple :
fac <- factor(c("rouge", "vert", "rouge", "bleu", "vert"))

On peut connaître les différentes possibilités de valeur d'un facteur avec levels :
levels(fac) donne "bleu" "rouge" "vert"
Ce sont les valeurs possibles, même si le facteur ne les utilise pas toutes (par exemple levels(fac[1]) donne les mêmes 3 valeurs.

On peut imposer l'ordre des facteurs, quand le premier facteur a une importance particulière :

pour donner l'ordre exact des facteurs : fac <- factor(c("rouge", "vert", "rouge", "bleu", "vert"), levels = c("vert", "rouge", "bleu"))
pour préciser après coup le premier facteur : relevel(fac, "bleu") indique que bleu doit être le premier niveau.

Mise à jour des niveaux : quand on extrait un sous-facteur, certains niveaux peuvent avoir disparu. On peut alors utiliser factor pour éliminer ces niveaux qui ne sont plus représentés :
fac2 <- fac[1:3]; fac2 <- factor(fac2); levels(fac2) donne "rouge" "vert"

Boucle sur les valeurs d'un facteur :
Si fac <- factor(c("a", "b", "a", "c"))

Attention : ne pas faire for (v in unique(fac)) {print(v)} : va imprimer des numéros (cf codage interne !).
Faire : for (v in levels(fac)) {print(v)}.

Génération d'un vecteur de facteurs :
gl(3, 2, 6, labels = c("rouge", "orange", "vert")) : génère un vecteur de facteurs pouvant prendre 3 valeurs, chaque valeur étant répétée 2 fois pour une longueur total de 6.

Génération d'un vecteur de facteurs d'interactions :
Si fac1 <- factor(c("a", "b", "a")); fac2 <- factor(c("B", "A", "C", "B", "C", "B")), alors interaction(fac1, fac2) donne le vecteur de facteurs a.B b.A a.C a.B b.C a.B pris parmi tous les niveaux possibles (levels(interaction(fac1, fac2)) vaut "a.A" "b.A" "a.B" "b.B" "a.C" "b.C")

Transformation de valeurs numériques en niveaux : cut(seq(0, 5, 0.2), breaks = 5) remplace les valeurs de la séquence par l'un des 5 intervalles auquel chaque valeur appartient.

Recodage d'une variable nominale pour remplacer par exemple tous les A par des x et tous les B par des y, grâce au package doBy (non installé par défaut) :

Pour une variable de type caractère :

library(doBy)
v <- c("A", "B", "A", "B", "B", "A", "B", "B", "B", "B")
recodeVar(v, c("A", "B"), c("x", "y"))

donne :

 [1] "x" "y" "x" "y" "y" "x" "y" "y" "y" "y"

Pour une variable de type facteur :

library(doBy)
v <- factor(c("A", "B", "A", "B", "B", "A", "B", "B", "B", "B"))
recodeVar(v, c("A", "B"), c("x", "y"))

donne :

 [1] x y x y y x y y y y
Levels: x y

On peut aussi recoder en valeurs numériques :

library(doBy)
v <- c("A", "B", "A", "B", "B", "A", "B", "B", "B", "B")
recodeVar(v, c("A", "B"), c(1.2, 3.4))

donne :

 [1] 1.2 3.4 1.2 3.4 3.4 1.2 3.4 3.4 3.4 3.4

Dataframes

Data frame : sorte de matrice où chaque colonne peut avoir son type (contrairement à une matrice dont tous les éléments doivent avoir le même type). Les colonnes représentent les variables et les lignes les individus.

Création d'un dataframe :fr <- data.frame(age = c(15,20), nom = c("pierre", "jean"), row.names = c("I1", "I2")). Les noms des colonnes sont alors age et nom, et les noms des lignes sont I1 et I2. Préciser le nom des lignes est optionnel (row.names optionnel). Attention : par défaut, le type d'une colonne avec des chaînes de caractère est factor :

fr$nom donne
```
pierre jean
Levels: jean pierre
  
```
class(fr$nom) donne factor

Pour empêcher que le type des colonnes de type caractère soit factor, il faut faire :
fr <- data.frame(age = c(15,20), nom = c("pierre", "jean"), stringsAsFactors = FALSE)

fr$nom donne
```
"pierre" "jean"
  
```
class(fr$nom) donne character

On peut référencer les colonne d'un dataframe par le nom de la colonne pour par son numéro :

fr[, 1] : donne 15 20.
fr[, "age"] : donne 15 20.
fr$age : donne 15 20.

Accès aux nom des lignes et des colonnes :

Accès au noms des lignes : row.names(fr) ou même rownames(fr) en lecture et écriture.
Accès au noms des colonnes : colnames(fr) ou même names(fr) en lecture et écriture.

Récupération d'une seule ligne ou d'une seule colonne :

fr[, 1] ou fr[, "age"] : une colonne renvoie un vecteur (toutes les valeurs sont du même type).
fr[1,] : une ligne renvoie un data.frame (car toutes les valeurs ne sont pas nécessairement du même type).

Récupération de plusieurs lignes ou plusieurs colonnes :

fr[1:10, ] : récupère les 10 premières lignes.
fr[, 1:10] : récupère les 10 premières colonnes.
fr <- fr[1:10, ] : attention, si le dataframe avait moins de 10 lignes, R rajoute des lignes avec des NA sans rien dire !

cbind et rbind : comme avec les matrices,

cbind(fr1, fr2) : si fr1 et fr2 ont même nombre de lignes, crée un frame avec les colonnes de fr1 et les colonnes de fr2 (réunion de variables pour les mêmes individus).
rbind(fr1, fr2) : si fr1 et fr2 ont même nombre de colonnes et ont les mêmes noms de colonnes, crée un frame avec les lignes de fr1 et de fr2 (réunion d'individus partageant les mêmes noms de variables).

Rajout d'une colonne à un dataframe :

rajout d'une colonne avec un nom en dur : fr <- data.frame(col1 = c(1, 2)); fr$col2 <- c(3, 4)
rajout d'une colonne dont le nom est dans une variable : fr <- data.frame(col1 = c(1, 2)); x <- "col2"; fr[, x] <- c(3, 4)

Pour éliminer une colonne d'un dataframe, par exemple la colonne col1 du dataframe fr : fr$col1 <- NULL

summary : fait un résumé sur chaque variable (chaque colonne du frame).

attach/detach :

attach(fr) : permet alors d'utiliser les noms de colonnes de fr comme si c'étaient des variables directement accessibles (i.e. nom au lieu de fr$nom).
detach(fr) : réverse l'effet de attach.

Création d'un dataframe qui est le produit cartésien de vecteurs ou facteurs :

fr <- expand.grid(letters = factor(c("a", "b", "a")), digits = c(3, 1)) donne :

  letters digits
1       a      3
2       b      3
3       a      3
4       a      1
5       b      1
6       a      1

On peut utiliser expand.grid avec plus de 2 vecteurs ou facteurs.

Renvoi des lignes de début ou de fin d'un data frame :

head(fr) : renvoie les 6 premières lignes d'un frame.
head(fr, 10) : renvoie les 10 premières lignes d'un frame.
tail(fr) : renvoie les 6 dernières lignes d'un frame.
tail(fr, 10) : renvoie les 10 dernières lignes d'un frame.

programmer en R, tutoriel R, graphes en R