Chapitre 2 vecteurs, listes, matrices, tableaux et data frames

Présentation au sujet: "Chapitre 2 vecteurs, listes, matrices, tableaux et data frames"— Transcription de la présentation:

1 Chapitre 2 vecteurs, listes, matrices, tableaux et data frames
Programmation en R

2 Vecteurs # En R, un VECTEUR est une collection ordonnée d'objets qui sont tous du même type (autrement, c'est une LISTE). # Ainsi, les vecteurs sont des objets qui peuvent être de type "integer", "double", "complex", "logical", "character", en fonction de la nature de leurs éléments. # La manière la plus simple de définir un vecteur est d'utiliser la fonction c() qui sigifie combine.

3 Vecteurs : fonction c c(12, 32.8, 47.5, -33.4) [1] v1 <- c(12, 32.8, 47.5, -33.4) v1 typeof(v1) [1] "double" # signifie vecteur de nombres réels

4 Vecteurs : fonction c v2 <- c("a", "e", "i", "o", "u", "y") v2 [1] "a" "e" "i" "o" "u" "y" typeof(v2) [1] "character" v3 <- c(T,F,F,T,F) v3 [1] TRUE FALSE FALSE TRUE FALSE typeof(v3) [1] "logical"

5 Vecteurs : fonction c # On a l'impression que les arguments de la fonctions c() sont des éléments, mais il faut se rappeler que des éléments ne sont que des vecteurs de taille 1. # Ainsi on peut utiliser la fonction c() avec comme arguments des vecteurs de tailles arbitraires. x <- c(1,2,3,4) y <- c(5,6,7) z <- c(x,y) # x et y sont des vecteurs de taille 4 et 3 z [1]

6 Vecteurs : fonction c # Dans un vecteur, par définition, tous les éléments doivent être de même type. # Ainsi, la fonction c() force tous les éléments à prendre un même type. # On a les relations de transtypages suivantes: logical -> integer -> double -> complex -> character

7 Vecteurs : fonction c c(T) # logical [1] TRUE c(T, as.integer(2), as.integer(3)) # integer [1] c(T, as.integer(2), as.integer(3), 12.57) # double [1] c(T, as.integer(2), as.integer(3), 12.57, 2+3i) # complex [1] i i i i i c(T, as.integer(2), as.integer(3), 12.57, 2+3i, "bab") # character [1] "TRUE" "2" "3" "12.57" "2+3i" "bab"

8 Vecteurs : fonction c # Le n-ième élément d'un vecteur v s'obtient par v[n]. # (les indices commencent à 1 et pas à 0). # Un sous-vecteur d'un vecteur v s'obtient par v[m:n]. # La longueur d'un vecteur v s'obtient par length(v). x <- c(2,4,3,7,1,8) x[2] [1] 4 x[3:5] [1] length(x) [1] 6 # (remarquer que ceci est un vecteur)

9 Vecteurs : fonction c # Si les indices sont "out of range", R décrète que les valeurs correspondantes sont "non available", notées NA. x <- c(2,4,3,7,1,8) x[9] [1] NA x[4:13] [1] NA NA NA NA NA NA NA

10 Vecteurs : opérateur « : »
# Pour créer un vecteur, on peut également utiliser l'opérateur ":". x <- 100:200 x [1] [13] [25] [37] [49] [61] [73] [85] [97]

11 Vecteurs : fonction seq
# Pour créer un vecteur, on peut également utiliser la fonction seq(from = ..., to = ..., by = ...), qui sigifie sequence. vec <- seq(12,37,2) vec [1] vec2 <- seq(from=21, to= 128, by=5) vec2 [1] [13]

12 Vecteurs : fonction seq
# Remarque: pour obtenir tout l'information sur une fonction, taper ?nom_fonction ?seq # on voit apparaître une description complète de la fonction, son utilisation, ses arguments, etc.

13 Vecteurs : fonction rep
# Pour créer un vecteur, on peut finalement utiliser la fonction rep(v, n), qui signifie replicate. # Cette fonction réplique le vecteur v n fois. rep(c("a", "b", "c"), 2) [1] "a" "b" "c" "a" "b" "c" rep(1:4, 3) [1] rep(seq(10, 0, -1), 3) [1] [14] [27] # Encore une fois, pour obtenir les infos de cette fct: ?rep

14 Vecteurs : réaffectation
# Réaffectation. # On peut réaffecter les éléments d'un vecteur et ainsi le modifier. Cette propriété est importante! vec2[1:5] <- c(1,1,1,1,1) vec2 [1] [13] vec2[c(1,3,5,7)] <- c(1000,1000,1000,1000) [1] [11] [21]

15 Vecteurs : réaffectation
v <- c() # on part d'un vecteur vide v[5] <- "a" v [1] NA NA NA NA "a" v[6] < [1] NA NA NA NA "a" "151.3"

16 Vecteurs : suppression d’éléments
# Suppression d'éléments. # Pour supprimer des éléments, on utilise des indices négatifs. # Pour supprimer un élément, la syntaxe est v <- v[-i] # Pour supprimer (un ou) plusieurs élément, la syntaxe est v <- v[-c(i1,...,ik)] vec2 # on rappelle la valeur de vec2 [1] [10] [19]

17 Vecteurs : suppression d’éléments
vec2[-2] # suppression d'un élément, le 2ème [1] [10] [19] # Mais vec2 n'a pas changé vec2 [1] [10] [19] # Pour le faire changer, il faut faire une réaffectation vec2 <- vec2[-2]

18 Vecteurs : suppression d’éléments
vec2[-c(1,2,4,6)] # suppression de plusieurs éléments [1] [13] Mais vec2 n'a pas changé vec2 [1] [10] [19] # Pour le faire changer, il faut faire une réaffectation vec2 <- vec2[-c(1,2,4,6)]

19 Vecteurs : opérations # Opérations sur les vecteurs. # Les opérations sur les vecteurs s'effectuent composantes par composantes. a <- c(1,3,5,7) b <- c(2,4,6,8) a + b [1] a – b [1] a * b [1] a / b [1]

20 Vecteurs : opérations # Si les vecteurs ne sont pas de même taille, le plus petit des deux sera répété périodiquement de manière à atteindre la taille de l'autre, puis l'opération effectuée. 2 * a # le 2 devient [1] a + 5 # le 5 devient [1] x <- c(1,2,3,4,5) + c(10,20,10) # devient Warning message: In c(1, 2, 3, 4, 5) + c(10, 20, 10) : longer object length is not a multiple of shorter object length x [1]

21 Vecteurs : noms # Un grand intérêt de la plupart des structures de données en R est de pouvoir donner des noms à des éléments afin de pouvoir se référer à ceux-ci par leurs noms plutôt que par leurs indices. # On peut nommer les éléments d'un vecteur en utilisant la fonction names(). Les noms sont des chaînes de caractères. # On peut ensuite se référer aux éléments d'un vecteurs en utilisant le nom des éléments plutôt que leur indices.

22 Vecteurs : noms v <- 1:5 names(v) <- c("N1", "N2", "N3", "N4", "N5") v N1 N2 N3 N4 N v["N2"] N2 2 v[c("N1","N3","N4")] N1 N3 N

23 Vecteurs : noms # Réaffectation via les noms au lieu des indices. v[c("N1","N3")] <- c(100, 200) v N1 N2 N3 N4 N v["Nouvau nom"] < N1 N2 N3 N4 N5 Nouvau nom

24 Vecteurs : exemple # Exemple: on génère un vecteur de 10'000 nombres tirés aléatoirement selon une loi normale de moyenne 5.4 et de variance 7.8. On calcule la moyenne, la médiane, la déviation standard et la variance de cet échantillon. mon_echantillon = rnorm(10000, mean=5.4, sd=sqrt(7.8)) my_mean <- mean(mon_echantillon) my_mean [1] median(mon_echantillon) [1] my_sd <- sd(mon_echantillon) my_sd [1] var(mon_echantillon) [1]

25 Vecteurs : exemple # On imprime l'histogramme de cet échantillon ainsi que la densité de la loi normale dont provient l'échantillon. msd1 <- my_mean - my_sd msd2 <- my_mean + my_sd # histogramme hist(mon_echantillon, main = "Histogramme", breaks = 50, freq = FALSE, col = "aliceblue") # ligne verticales abline(v = c(my_mean, msd1, msd2), col = c("red","blue","blue"), lwd = c(2,2,2)) # densité normale curve(dnorm(x, mean = 5.4, sd = my_sd), col = "darkblue", lwd = 3, add = TRUE)

26 Vecteurs

27 Listes # En R, une LISTE est une collection ordonnée d'objets qui ne sont pas forcément tous du même type (contrairement aux vecteurs). Les listes sont de type "list". # Pour définir une liste, on utilise la fonction list(). list(3, 4.67, -8.12) [[1]] [1] 3 [[2]] [1] 4.67 [[3]] [1] typeof(list(3, 4.67, -8.12)) [1] "list"

28 Listes : fonction list l <- list(3, 4.67, "bonjour", TRUE, c(1,2,3)) l [[1]] [1] 3 [[2]] [1] 4.67 [[3]] [1] "bonjour" [[4]] [1] TRUE [[5]] [1] 1 2 3

29 Listes : fonction list # Il est important de remarquer qu'une liste est une collection de couples (indice, élément). # les indices sont entre double crochets et leur élément correspondant en dessous. list("a", "b", c(1,2,3)) [[1]] [1] "a" [[2]] [1] "b" [[3]] [1] 1 2 3

30 Listes : sous-listes # Découpage de listes en sous-listes. # Une sous-liste (ou tranche de liste) d'une liste l s'obtient par l[m:n] ou par l[c(n1,...,nk)] (les indices commencent à 1 et pas à 0). # La sous-liste formée par le seul n-ième élément d'une liste l s'obtient par l[n]. # Une sous-liste est donc à nouveau une collection de couples (indice, élément). # Les indices non-référencés sont complétés par des objets NULL # La longueur d'une liste s'obtient avec la fonction length().

31 Listes : sous-listes l2 <- list(3, 4, c(1,2,3)) l2[2:4] [[1]] [1] 4 [[2]] [1] [[3]] NULL l2[3] # ceci est une sous-liste, non un élément!

32 Listes : sous-listes l2[c(1,3)] [[1]] [1] 3 [[2]] [1] length(l2) # ceci est un vecteur

33 Listes : éléments # Accès aux éléments d'une liste. # Les éléments d'une liste s'obtiennent par le double crochet. # Le n-ième élément d'une liste l est donnée par l[[n]]. # Ainsi, on obtient bien un élément et non une sous-liste!

34 Listes : éléments l2[[1]] [1] 3 l2[[3]] [1] l2[[3]][2] # 2ème élément du vecteur l2[[3]] [1] 2

35 Listes : réaffectation de sous-listes
# Réaffectation et ajout de sous-listes ou d'éléments dans une liste. # On peut réaffecter une sous-liste d'une liste et ainsi la modifier. l2[1:2] <- list("a", "b") # Ici, la sous-liste l2[1:2] est modifiée l2 [[1]] [1] "a" [[2]] [1] "b" [[3]] [1] 1 2 3

36 Listes : réaffectation de sous-listes
# De manière similaire, on peut rajouter une sous-liste à une liste par réaffectation. l2[3:4] <- list("aa", "bb") # 3ème el. modifié, 4ème ajouté l2 [[1]] [1] "a" [[2]] [1] "b" [[3]] [1] "aa" [[4]] [1] "bb"

37 Listes : réaffectation d’éléments
# On peut également réaffecter un ou plusieurs éléments d'une liste et ainsi la modifier. l2[[2]] <- "bb" # Ici, seul l'élément l2[[2]] est modifié l2 [[1]] [1] "a" [[2]] [1] "bb" [[3]] [1] 1 2 3

38 Listes : réaffectation d’éléments
# De manière similaire, on peut ajouter ou rajouter des éléments à une liste grâce à une réaffectation. l3 <- list() l3[[1]] <- "100" l3[[3]] <- "bab" # on manque l'indice 2 l3 [[1]] [1] "100" [[2]] NULL [[3]] [1] "bab"

39 Listes : suppression d’éléments
# Suppression d'éléments. On passe par la syntaxe qui concerne les sous- listes et non les éléments. # On utilise des indices négatif. # Pour supprimer un élément, la syntaxe est l <- l[-i] # Pour supprimer (un ou) plusieurs élément, la syntaxe est l <- l[-c(i1,...,ik)] l3 # on rappelle la valeur de l3 [[1]] [1] "100" [[2]] NULL [[3]] [1] "bab"

40 Listes : suppression d’éléments
l3[-2] # suppression d'un élément, le 2ème [[1]] [1] "100" [[2]] [1] "bab" # Mais l3 n'a pas changé... # Pour le faire changer, il faut faire une réaffectation l3 <- l3[-2] l3

41 Listes : suppression d’éléments
l3[-c(1,2)] # suppression de plusieurs éléments, tous p.ex. list() # liste vide # Mais l3 n'a pas changé l3 [[1]] [1] "100" [[2]] [1] "bab" # Pour la faire changer, il faut faire une réaffectation l3 <- l3[-c(1,2)]

42 Listes : noms # Comme pour les vecteur, un grand intérêt des listes est de pouvoir donner noms à leurs éléments afin de pouvoir référencer ceux-ci par leurs noms au lieu de leurs indices. # la syntaxe est list(nom1 = element1, nom2 = element2,...)

43 Listes : noms ma_liste <- list(New_York = c(1,2,3,4), Paris = c("a","b","c"), Londres = seq(1,200)) ma_liste $New_York [1] $Paris [1] "a" "b" "c" $Londres [1] [14]

44 Listes : sous-listes via les noms
# le découpage en sous-listes et l'accès aux éléments de la liste se fait alors de manière classique, mais en spécifiant les noms des élémets (entre guillemets) au lieu de leurs indices.

45 Listes : sous-listes via les noms
# Accès aux sous-listes. ma_liste["Paris"] $Paris [1] "a" "b" "c" ma_liste[c("Paris", "New_York")] $New_York [1]

46 Listes : sous-listes via les noms
# Réaffectation de sous-liste. ma_liste["Londres"] = list(1:5) ma_liste $New_York [1] $Paris [1] "a" "b" "c" $Londres [1]

47 Listes : éléments via les noms
# Accès aux éléments de la liste. # Manière classique, via le double crochet: ma_liste[["Paris"]] [1] "a" "b" "c" # Autre syntaxe importante: liste$nom_element ma_liste$Paris # Réaffectation des éléments d'une liste ma_liste[["Paris"]] <- c(1,1,1,1) [1] ma_liste$Paris <- c("a","b", "c")

48 Matrices # En R, une MATRICE est un objet qui correspond à l'extension du concept de vecteur en deux dimensions. # Ainsi, comme pour les vecteurs, les éléments d'une matrice sont tous du même type. # En R, les matrices sont en fait implémentés comme des vecteurs. # Les matrices sont donc des objets qui peuvent être de type "integer", "double", "complex", "logical", "character", etc., en fonction de la nature de leurs éléments. # Mais ce sont des objets de classe implicite "matrix". # Pour définir une matrice, on utilise la fonction matrix() (taper ?matrix pour obtenir les info sur cette fonction).

49 Matrices : fonction matrix
M <- matrix(data = 1:12, nrow = 4, ncol = 3, byrow = TRUE) M [,1] [,2] [,3] [1,] [2,] [3,] [4,] length(M) [1] 12 dim(M) [1] 4 3 typeof(M) [1] "integer" class(M) [1] "matrix"

50 Matrices : fonction matrix
# Lorsque les dimensions ne coïncident pas avec le nombre d'éléments, R répète le pattern des éléments jusqu'à remplir la matrice. M2 <- matrix(data = 1:9, nrow = 4, ncol = 3, byrow = TRUE) Warning message: In matrix(data = 1:9, nrow = 4, ncol = 3, byrow = TRUE) : data length [9] is not a sub-multiple or multiple of the number of rows [4] M2 [,1] [,2] [,3] [1,] [2,] [3,] [4,] 1 2 3

51 Matrices : éléments, lignes, colonnes
# Le (i,j)-ème élément d'une matrice M s'obtient par la syntaxe M[i,j]. # La i-ème ligne de M s'obtient par M[i,]. # La j-ème colonne de M s'obtient par M[,j]. M[2,3] [1] 6 M[2,] [1] M[,3] [1] M[c(1,3),] # 1ère et 3ème ligne [,1] [,2] [,3] [1,] [2,] 7 8 9

52 Matrices : réaffectation
# Réaffectation d'éléments, lignes, colonnes. M[2,3] <- 100 M [,1] [,2] [,3] [1,] [2,] [3,] [4,] M[,3] <- c(1,1,1,1) # réaffectation de la 3ème colonne [1,] [2,] [3,] [4,]

53 Matrices : suppression lignes colonnes
# Suppression de lignes et de colonnes. # On utilise les indices négatifs. # Pour supprimer une ou plusieurs lignes, la syntaxe est M <- M[-i,] ou M <- M[-c(i1,...,ik),] # Pour supprimer une ou plusieurs colonnes, la syntaxe est M <- M[,-i] ou M <- M[,-c(i1,...,ik)] M # on rappelle la matrice M [,1] [,2] [,3] [1,] [2,] [3,] [4,]

54 Matrices : suppression lignes colonnes
# On supprime les première et troisième lignes M <- M[-c(1,3),] # avec la réaffectation, M change M [,1] [,2] [,3] [1,] [2,] # On supprime les première et troisième colonnes M <- M[,-c(1,3)] # avec la réaffectation, M change [1] 5 11 # Remarquer que la colonne restante est affichée horizontalement; un vecteur vertical n'existe pas en R.

55 Matrices : noms # Une fois de plus, on peut donner des noms aux lignes et colonnes afin de pouvoir se référer à celles-ci par leurs noms plutôt que par leus indices. # On utilise les fonctions rownames() et colnames(), ou dimnames(). M <- matrix(data = 1:6, nrow = 2, ncol = 3, byrow = TRUE) rownames(M) <- c("l1", "l2") colnames(M) <- c("c1", "c2", "c3") M c1 c2 c3 l l dimnames(M) <- list(c("ligne 1", "ligne 2"), c("col 1", "col 2", "col 3")) col 1 col 2 col 3 ligne ligne

56 Matrices : éléments via les noms
M["ligne 2", "col 3"] [1] 6 M["ligne 2",] col 1 col 2 col M[,"col 3"] ligne 1 ligne M[, c("col 1", "col 3")] # 1ère et 3ème colonne col 1 col 3 ligne ligne 2 4 6

57 Matrices : réaffectation via les noms
# Réaffectation via les noms au lieu des indices M["ligne 1", "col 3"] <- 47 M col 1 col 2 col 3 ligne ligne M["ligne 1",] <- c(3, 3, 3) ligne

58 Matrices : fonctions rbind et cbind
# On peut combiner les lignes et colonnes de plusieurs matrices en utilisant les fonctions rbind() et cbind(). # Pour cela, il faut que le nombre de colonnes ou lignes des matrices considérées soit égal. A <- matrix(c(1,1,1,2,2,2), nrow = 2, ncol = 3) B <- matrix(c(3,3), nrow = 2, ncol = 1) C <- matrix(c(4,4,4), nrow = 1, ncol = 3) cbind(A,B) # même nb de lignes, on peut combiner les col. [,1] [,2] [,3] [,4] [1,] [2,] rbind(A,C) # même nb de col., on peut combiner les lignes [,1] [,2] [,3] [1,] [2,] [3,] 4 4 4

59 Matrices : transposition
# On peut également transposer une matrice avec la fonction t(). A [,1] [,2] [,3] [1,] [2,] t(A) [,1] [,2] [1,] 1 1 [2,] 1 2 [3,] 2 2

60 Matrices : calcul matriciel
# Plus généralement, R est capable de faire du calcul matriciel avancé. On a entre autre les fonctions suivantes: # A * B # Element-wise multiplication # A %*% B # Matrix multiplication # A %o% B # Outer product. AB' # crossprod(A,B) # A'B and A'A respectively. # crossprod(A) # A'B and A'A respectively. # t(A) # Transpose # diag(x) # Creates diagonal matrix with elements of x # in the principal diagonal # diag(A) # Returns a vector containing the elements # of the principal diagonal # diag(k) # If k is a scalar, this creates a k x k # identity matrix.

61 Matrices : calcul matriciel
# solve(A, b) # Returns vector x s.t. b = Ax # i.e., A-1b # solve(A) # Inverse of A (A is a square matrix) # y <- eigen(A) # eignevalues and eigenvectors # y$val are the eigenvalues of A # y$vec are the eigenvectors of A # y <- svd(A) # Single value decomposition of A. # y$d = vector containing the # singular values of A # y$u = matrix with columns contain the # left singular vectors of A # y$v = matrix with columns contain the # right singular vectors of A

62 Exemple # Exemple: l'objet volcano est une matrice M de taille 87*61, où chaque point M[x,y] représente l'altitude du point de longitude x et latitude y. # Nous allons imprimer cette matrice pour avoir une idée de la topographie du volcan. class(volcano) [1] "matrix" nrow(volcano) [1] 87 ncol(volcano) [1] 61

63 Exemple x <- 10*(1:nrow(volcano)) y <- 10*(1:ncol(volcano)) filled.contour(x, y, volcano, color = terrain.colors, plot.title = title(main = "Topography of Maunga Whau", xlab = "Meters North", ylab = "Meters West"), plot.axes = { axis(1, seq(100, 800, by = 100)) axis(2, seq(100, 600, by = 100)) }, key.title = title(main = "Height\n(meters)"), key.axes = axis(4, seq(90, 190, by = 10)))

64 Exemple

65 Tableaux # En R, un TABLEAU est un objet qui, comme les matrices, correspond à l'extension du concept de vecteur, mais en plus de deux dimensions cette fois- ci. # Ainsi les éléments d'un tableau sont tous du même type. # En R, les tableaux sont en fait implémentés comme des vecteurs. # Les tableaux sont donc des objets qui peuvent être de type "integer", "double", "complex", "logical", "character", etc., en fonction de la nature de leurs éléments. # Mais ce sont des objets de classe implicite "array". # Pour définir un tableau, on utilise la fonction array() (taper ?array pour obtenir les info sur cette fonction). # Au-delà de 3 dimensions, les tableaux deviennent difficiles à manipuler.

66 Tableaux : fonction array
A <- array(1:24, dim = c(3, 4, 2)) A , , 1 [,1] [,2] [,3] [,4] [1,] [2,] [3,] , , 2 [1,] [2,] [3,]

67 Tableaux : fonction array
length(A) [1] 24 dim(A) [1] typeof(A) [1] "integer" class(A) [1] "array"

68 Tableaux : éléments, lignes, colonnes…
# On manipule les tableaux comme des matrices... A[3,3,2] [1] 21 A[3,3,] # visualiser le tableau pour comprendre [1] 9 21 A[,3,2] [1] A[3,,2] [1] A[2,,] [,1] [,2] [1,] 2 14 [2,] 5 17 [3,] 8 20 [4,] 11 23

69 Tableaux : réaffectation
A[3,4,2] <- 100 A , , 1 [,1] [,2] [,3] [,4] [1,] [2,] [3,] , , 2 [1,] [2,] [3,]

70 Tableaux : suppression
A <- A[,-c(2,3),] # on supprime les 2ème et 3ème colonnes A , , p1 c1 c4 l l l , , p2 c1 c4 l l l

71 Tableaux : suppression
A <- A[,,-2] # on supprime la 2ème couche de profondeur A c1 c4 l l l3 3 12

72 Tableaux : noms # On peut également donner des noms aux lignes, colonnes, profomdeurs, etc., avec la fonction dimnames(). # Les noms sont une listes de vecteurs; 1 vecteur par dimension. # On peut ensuite se référer et modifier les éléments, lignes, colonnes, profondeur, etc., en fonction de leurs noms au lieu de leurs indices.

73 Tableaux : noms A <- array(1:24, dim = c(3, 4, 2)) dimnames(A) <- list(c("l1", "l2", "l3"), c("c1", "c2", "c3", "c4"), c("p1", "p2")) A , , p1 c1 c2 c3 c4 l l l , , p2 l l l

74 Data frames # Les DATA FRAMES sont les structures de données les plus importantes en R. # Ce sont des tables de données rectangulaires où les éléments de sont pas obligés d'être tous du même type. # En général, les colonnes des data frames représentent différentes variables (quantitatives ou qualitatives) qui ont été mesurées; les lignes représentent les différentes observations, i.e., les mesures de ces différentes variables sur des "individus". # Les colonnes des data frames sont des vecteurs, tous de même dimension. Les éléments de chacun de ces vecteurs sont donc par définition de même type, mais les vecteurs peuvent être de type différents. # Les data frames sont des objets de type "list", mais de class implicite "data.frame".

75 Data frames : fonction data.frame
# Pour définir un data frame, on utilise la fonction data.frame() (taper ?data.frame pour obtenir les infos). n <- c(2, 3, 5) s <- c("aa", "bb", "cc") b <- c(TRUE, FALSE, TRUE) df <- data.frame(n, s, b) # chaque vecteur est une colonne du data frame df n s b 1 2 aa TRUE 2 3 bb FALSE 3 5 cc TRUE typeof(df) [1] "list" class(df) [1] "data.frame"

76 Data frames : fonction data.frame
# Si on a déjà une liste de vecteurs, on crée le data frame avec la fonction as.data.frame(). l <- list(n, s, b) df2 <- as.data.frame(l) df2 c c..aa....bb....cc.. c.TRUE..FALSE..TRUE. 1 2 aa TRUE 2 3 bb FALSE 3 5 cc TRUE

77 Data frames : noms # Comme d'habitude, on peut donner des noms aux lignes et colonnes du data frame. rownames(df) <- c("obs1", "obs2", "obs3") colnames(df) <- c("var1", "var2", "var3") df var1 var2 var3 obs1 2 aa TRUE obs2 3 bb FALSE obs3 5 cc TRUE

78 Data frames : noms # Les noms de colonnes peuvent être données directement lors de l'instanciation. df3 <- data.frame(var_1 = n, var_2 = s, var_3 = b) df3 var_1 var_2 var_3 1 2 aa TRUE 2 3 bb FALSE 3 5 cc TRUE nrow(df3) [1] 3 ncol(df3)

79 Data frames : réaffectation
# Tout ce qui concerne le référencement et la réaffectation fonctionne sur le modèle de ce qui a été présenté pour les listes et les tableaux. # En particulier, on insiste sur l’importance des fonctions rbind() et cbind() pour ajouter des lignes et colonnes à un data frame. # De plus, il existe une fonction très utile, la fonction subset(), permettant de sélectionner certaines lignes et colonnes d’une data frame.

80 Data frames : lignes # 1. Extraction de sous-data frame par ses lignes via le simple crochet. # On obtient des tranches de data frames qui sont des data frames plus petits. df[2,] var1 var2 var3 obs2 3 bb FALSE class(df[2,]) # on a bien un data frame [1] "data.frame" df[c(1,3),] var1 var2 var3 obs1 2 aa TRUE obs3 5 cc TRUE class(df[c(1,3),]) # on a bien un data frame

81 Data frames : lignes # On peut égaalement utiliser les noms de lignes. df["obs1",] var1 var2 var3 obs2 3 bb FALSE class(df["obs1",]) # on a bien un data frame [1] "data.frame"

82 Data frames : lignes # 2. Ajout de lignes dans un data frame: fonction rbind(). # La ou les lignes ajoutées doivent être un data frame. # Les types des éléments ajoutés doivent conïncider avec les colonnes du data frame. # Ajout d'une ligne: new_row <- data.frame(var1 = 7, var2 = "dd", var3 = FALSE) rbind(df, obs4 = new_row) var1 var2 var3 obs1 2 aa TRUE obs2 3 bb FALSE obs3 5 cc TRUE obs4 7 dd FALSE

83 Data frames : lignes # Ajout de plusieurs lignes: rbind(df, obs4 = data.frame(var1 = 7, var2 = "dd", var3 = FALSE), obs5 = data.frame(var1 = 9, var2 = "ee”, var3 = TRUE)) var1 var2 var3 obs1 2 aa TRUE obs2 3 bb FALSE obs3 5 cc TRUE obs4 7 dd FALSE obs5 9 ee TRUE

84 Data frames : colonnes # 3. Extraction de sous-data frame par ses colonnes via le simple crochet. # On obtient des tranches de data frames qui sont des data frames plus petits. df[,2] [1] aa bb cc Levels: aa bb cc class(df[,2]) # on n'a plus un data frame, c'est subtil! [1] "factor" df[,c(1,3)] var1 var3 obs1 2 TRUE obs2 3 FALSE obs3 5 TRUE class(df[,c(1,3)]) # on a bien un data frame [1] "data.frame"

85 Data frames : colonnes # On peut égaalement utiliser les noms de colonnes. df[,c("var1", "var3")] var1 var3 obs1 2 TRUE obs2 3 FALSE obs3 5 TRUE class(df[,c("var1", "var3")]) # on a bien un data frame [1] "data.frame"

86 Data frames : colonnes # 4. Extraction d'un vecteur colonne d'un data frame via le double crochet ou la syntaxe nom_data.frame$nom_colonne. # On obtient un vecteur et non un sous-data frame. # Cette syntaxe ne marche que pour les colonnes et pas les lignes! df[[3]] [1] TRUE FALSE TRUE class(df[[3]]) # vecteur booléen, pas un data frame [1] "logical" df[["var1"]] [1] df$var1

87 Data frames : colonnes # 5. Ajout de colonnes dans un data frame: fonction cbind(). # La ou les colonnes ajoutées doivent être un data frame. # Les data frames qu'on combine doivent possèder le même nombre de lignes. df_prim <- data.frame(var_4 = c(1,1,1), var_5 = c(2,2,2)) cbind(df,df_prim) var1 var2 var3 var_4 var_5 obs1 2 aa TRUE 1 2 obs2 3 bb FALSE 1 2 obs3 5 cc TRUE 1 2

88 Data frames : fonction edit
# 6. On peut manuellement éditer un data frame grâce à la fonction edit() df_modifie <- edit(df) df_modifie var1 var2 var3 obs1 2 aaaaa TRUE obs2 3 bbbb FALSE obs3 5 cccc TRUE

89 Data frames : fonction subset
# 7. Il existe une manière importante pour sélectionner certaines lignes et colonnes d'une data frame. # On utilise la fonction subset(). # Pour sélectionner certaines colonnes, utiliser l'attribut select: # - subset(dfrm, select = colname) ou encore # - subset(dfrm, select = c(colname1,..., colnameN)) # Pour sélectionner certaines lignes, utiliser l'attribut subset # (même nom que la fonction): # - subset(dfrm, subset = (logical expression)) # où l'expression logique sert à filtrer certaines lignes # On peut bien entendu combiner les deux syntaxes en une seule: # - subset(dfrm, select = ..., subset = ...)

90 Data frames : fonction subset
# Exemple: # R contient des data frames prédéfinis avec certaines librairies. library(ggplot2) # librairie graphique # diamonds est un data frame qui rapporte les données de 54'000 diamants. my_df <- diamonds dim(my_df) [1] head(my_df) # impression du début du data frame carat cut color clarity depth table price x y z ...

91 Data frames : fonction subset
# A. Sélection de sous-data frame par ses colonnes: # - Une seule colonne my_df_1 <- subset(my_df, select = price) dim(my_df_1) head(my_df_1) price

92 Data frames : fonction subset
# - Plusieurs colonnes, en gardant certaines colonnes my_df_2 <- subset(my_df, select = c(carat, cut, price)) head(my_df_2) carat cut price Ideal Premium Good Premium Good Very Good 336

93 Data frames : fonction subset
# - Plusieurs colonnes, en enlevant certaines colonnes # on enlève les 1ère, 2ème, 3ème et 7ème colonnes my_df_3 <- subset(my_df, select = colnames(my_df)[c(-1,-2,-3,-7)]) head(my_df_3) clarity depth table x y z 1 SI SI VS VS SI VVS

94 Data frames : fonction subset
# B. Sélection de sous-data frame par ses lignes: # - en utilisant une expression logique de filtrage my_df_4 <- subset(my_df, subset = (price >= 330 & cut == "Ideal")) head(my_df_4) carat cut color clarity depth table price x y z Ideal J VS Ideal J SI Ideal I SI Ideal I SI Ideal I SI Ideal J SI