Les types de données en R

Avant de commencer l’introduction et de découvrir les différents types de données en R, configurons rapidement l’environnement R à la fois dans le terminal et dans Jupyter Notebook.

La commande suivante s’adresse à macOS et va installer R dans votre terminal.

brew install r --build-from-source

Pour vérifier que l’installation a bien réussi, tapez simplement R (majuscule) dans le terminal pour entrer dans une session R, comme ci-dessous.

Pour l’installation sur d’autres systèmes d’exploitation, consultez ce tutoriel.

Ajoutons maintenant le langage R comme noyau dans Jupyter Notebook. Assurez-vous que Jupyter Notebook est déjà installé sur votre machine.

Ouvrez votre terminal, lancez une session R et exécutez les deux commandes ci-dessous pour ajouter le noyau R à Jupyter Notebook.

install.packages('IRkernel')
IRkernel::installspec()

Une fois ces deux commandes exécutées avec succès, lancez Jupyter depuis le terminal et ouvrez un notebook avec le noyau R comme ci-dessous :

Vous êtes prêt à écrire votre premier code R dans Jupyter Notebook.

Introduction

Pour tirer pleinement parti de R, il est essentiel de connaître et comprendre les différents types et structures de données disponibles et leur fonctionnement. Ils jouent un rôle central dans la plupart des problèmes — en particulier en apprentissage automatique, où les données sont au cœur de tout.

Dans un langage de programmation, nous avons généralement besoin de variables pour stocker des informations — entier, caractère, nombre à virgule, booléen, etc. Le type d’une variable dépend du type d’information qu’elle contient. Si vous lui assignez un entier, son type sera int. Les variables ne sont que des emplacements mémoire réservés où les valeurs sont stockées. Dès que vous créez une variable, un espace mémoire lui est alloué.

Selon le type de données d’une variable, le système d’exploitation alloue une certaine quantité de mémoire. Par exemple, en R, une variable contenant un entier réserve 4 octets, et 1 octet pour un caractère.

Dans des langages comme C, C++ ou Java, les variables sont déclarées avec un type ; en Python et en R, les variables sont des objets. Les objets sont des structures de données munies d’attributs et de méthodes applicables à ces attributs.

Il existe différents types d’objets R (structures de données) que nous aborderons dans ce tutoriel :

• Vecteurs

• Listes

• Matrices

• Tableaux (arrays)

• Facteurs

• Data frames

Commençons par quelques types de base sur lesquels reposent les objets R : numérique (Numeric), entier (Integer), caractère (Character), facteur (Factor) et logique (Logical).

• Numeric : les nombres comportant une décimale ou étant des fractions ont le type numeric.

num <- 1.2
print(num)

[1] 1.2

Vous pouvez vérifier le type de a avec la fonction class().

class(num)

'numeric'

• Integer : les nombres sans partie décimale ont le type integer. Pour créer un entier, utilisez explicitement as.integer() en lui passant la variable en argument.

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'

• Character : comme son nom l’indique, une lettre ou une chaîne de lettres/chiffres entre guillemets est de type character. Cela peut être des lettres ou des chiffres.

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'

• Logical : une variable qui ne peut prendre que TRUE ou FALSE (booléen) est dite logique.

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'

• Factor : ce type sert à représenter des variables qualitatives (couleurs, bien & mal, notes de films/cours, etc.). Très utile en modélisation statistique.

Pour cela, utilisez la fonction c(), qui renvoie un vecteur (unidimensionnel) en combinant les éléments.

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

Le facteur fac comporte trois niveaux : good, bad et ugly, vérifiables avec levels. Le type de ces niveaux est character.

levels(fac)

1. 'bad'
2. 'good'
3. 'ugly'

nlevels(fac)

3

class(levels(fac))

'character'

Avant d’aller plus loin, voici deux conseils utiles :

• R est sensible à la casse. Tous les objets définis ci-dessus doivent être appelés exactement de la même façon (majuscules/minuscules), comme dans l’exemple ci-dessous.

Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:

• En R, vous pouvez lister toutes les variables/objets définis dans votre environnement de travail avec ls(), comme ci-dessous.

ls()

1. 'char'
2. 'int'
3. 'num'

Listes

Contrairement aux vecteurs, une liste peut contenir des éléments de divers types et représente une collection ordonnée de valeurs. Elle peut inclure des vecteurs, fonctions, matrices et même d’autres listes (listes imbriquées).

Les listes en R sont indexées à partir de 1.

Voyons un exemple simple avec trois types de données différents stockés dans une même liste.

lis1 <- 1:5  # Vecteur entier
lis1

1. 1
2. 2
3. 3
4. 4
5. 5

lis2 <- factor(1:5)  # Vecteur facteur
lis2

1. 1
2. 2
3. 3
4. 4
5. 5

lis3 <- letters[1:5]  # Vecteur caractère
lis3

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

combined_list <- list(lis1, lis2, lis3)

combined_list

1. 1. 1
   2. 2
   3. 3
   4. 4
   5. 5
   1. 1
   2. 2
   3. 3
   4. 4
   5. 5
2. Niveaux :

   1. '1'
   2. '2'
   3. '3'
   4. '4'
   5. '5'
   1. 'a'
   2. 'b'
   3. 'c'
   4. 'd'
   5. 'e'

Accédons à chaque vecteur séparément. Pour cela, utilisez les doubles crochets puisque les trois vecteurs sont au même niveau dans la liste. python combined_list[[1]]

1. 1
2. 2
3. 3
4. 4
5. 5

python combined_list[[2]]

1. 1
2. 2
3. 3
4. 4
5. 5

combined_list[[3]]

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

Essayons maintenant d’accéder au cinquième élément du troisième vecteur, qui renvoie la lettre e.

combined_list[[3]][5]

'e'

Terminons en aplatissant la liste. À noter : comme combined_list mélange des types character et numeric, le type character est prioritaire et le type de la liste aplatie devient character.

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '1'
7. '2'
8. '3'
9. '4'
10. '5'
11. 'a'
12. 'b'
13. 'c'
14. 'd'
15. 'e'

length(flat_list)

15

Vecteurs

Un vecteur est un objet qui stocke plusieurs valeurs du même type. Un même vecteur ne peut pas mélanger entier et caractère. Par exemple, pour stocker la note totale de 100 étudiants, plutôt que de créer 100 variables, créez un vecteur de longueur 100 qui contiendra toutes les notes.

On crée un vecteur avec la fonction c(), qui combine les éléments et renvoie un tableau unidimensionnel.

Créons un vecteur marks de type numeric pour cinq étudiants.

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

Vérifions la longueur du vecteur, qui correspond au nombre d’éléments.

length(marks)

5

Accédons maintenant à un élément par son index.

marks[4]

40

marks[5]

65

marks[6] # renvoie NA car il n’y a pas de sixième élément

<NA>

• Tranchage (slicing) : comme en Python, vous pouvez trancher en R.

  Accédons aux éléments du deuxième au cinquième par tranchage.

marks[2:5]

1. 65
2. 90
3. 40
4. 65

Créons maintenant un vecteur de type character, de manière analogue à un numérique.

char_vector <- c("a", "b", "c")
print(char_vector)

[1] "a" "b" "c"

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]

1. 'a'
2. 'b'
3. 'c'

Si vous créez un vecteur mêlant numériques et caractères, les nombres seront convertis en type caractère.

char_num_vec <- c(1,2, "a")

char_num_vec

1. '1'
2. '2'
3. 'a'

class(char_num_vec)

'character'

Créons un vecteur de 1024 valeurs numériques grâce à la notation de séquence.

vec <- c(1:1024)

Accédons ensuite à l’élément du milieu et au dernier. Pour cela, utilisez length.

vec[length(vec)]

1024

vec[length(vec)/2]

512

• Comment créer un vecteur de nombres impairs ?

Utilisez la fonction seq, qui prend trois paramètres : début, fin et pas.

seq(1,10, by = 2)

1. 1
2. 3
3. 5
4. 7
5. 9

Matrice

Comme un vecteur, une matrice stocke des valeurs du même type, mais elle est bidimensionnelle.

La syntaxe pour définir une matrice est :

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE indique que la matrice est remplie par lignes. byrow=FALSE la remplit par colonnes (par défaut).

Définissons rapidement une matrice M de dimension 2×3.

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Utilisons le tranchage pour extraire des éléments par lignes et colonnes.

M[1:2,1:2] # la première dimension sélectionne les deux lignes, la seconde les 1re et 2e colonnes

DataFrame

Contrairement à une matrice, les data frames sont une forme plus générale et tabulaire. Les colonnes peuvent avoir des types différents : la première en caractère, la seconde en entier, la troisième en logique, etc.

Les variables (ou features) sont en colonnes — l’en-tête — et les observations en lignes, la première valeur étant le nom de ligne, suivie des données — les lignes de données.

On crée un DataFrame avec la fonction data.frame().

Les DataFrames sont très utilisés pour lire des fichiers CSV/texte. Au-delà de l’import, vous les utiliserez aussi en apprentissage automatique, surtout pour les données numériques. Ils sont précieux pour comprendre les données, les transformer, tracer et visualiser.

Créons un jeu de données factice et explorons quelques fonctions propres aux data frames.

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # nombre de lignes du data frame dataset

3

ncol(dataset) # nombre de colonnes du data frame dataset

5

df1 = rbind(dataset, dataset) # concaténation par lignes (row bind)

df1

df2 = cbind(dataset, dataset) # concaténation par colonnes (column bind)

df2

Voyons la fonction head, très utile quand vous avez des millions d’enregistrements et que vous ne souhaitez afficher que les premières lignes. La fonction tail affiche, elle, les dernières lignes.

head(df1,3) # ici seules trois lignes seront affichées

str(dataset) # renvoie la classe/le type de données pour chaque colonne

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

Regardons maintenant la fonction summary(), très pratique pour une vue statistique d’ensemble. Comme ci-dessous, elle découpe vos données en quartiles, ce qui donne une intuition sur la distribution, et indique aussi s’il y a des valeurs manquantes.

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000  

Conclusion

Félicitations, vous êtes allé au bout du tutoriel.

C’était un excellent point de départ pour les débutants curieux d’apprendre R. Pour vous exercer, explorez d’autres fonctions utiles propres à chaque type de données.

Beaucoup de sujets R restent à découvrir, comme les conditionnelles et le contrôle de flux, les utilitaires R, et surtout le Machine Learning avec R. Nous les couvrirons dans de prochains tutoriels — restez à l’écoute !

N’hésitez pas à poser vos questions sur ce tutoriel dans les commentaires ci-dessous.

Pour aller plus loin avec R, suivez le cours Intermediate R de DataCamp et lisez le tutoriel Introduction aux data frames en R.