Les objets R

R utilise des fonctions et des opérateurs qui agissent sur des objets, ceux-ci sont caractérisés par leur nom et leur contenu, mais aussi par des attributs. Ce sont les attributs d'un objet qui vont déterminer le comportement des fonctions sur cet objet (méthode générique).

Des méthodes génériques sont prédéfinies et peuvent être redéfinies pour des groupes de fonctions: Math, Math2, Ops, Summary et Complexe.

Pour connaître l'ensemble des méthodes génériques fourni par l'installation de base de R:

help('Math')

Un objet a deux attributs intrinsèques, son mode ou type et sa longueur. Il peut avoir des attributs spécifiques qui diffèrent selon le type de l'objet (dim,dimnames,class,...).

# Variables of differents types
my_numeric <- 42
my_character <- "42"
my_logical <- FALSE 
my_integer <- 5L

# Class de my_numeric
" mode et classe my_numeric"
mode(my_numeric)
typeof(my_numeric)
class(my_numeric)

' mode et classe my_numeric'

'numeric'

'double'

'numeric'

# Class de my_numeric
" mode et classe my_integer"
mode(my_integer)
typeof(my_integer)
class(my_integer)

' mode et classe my_integer'

'numeric'

'integer'

'integer'

xx <- my_numeric + my_integer
xx
mode(xx)
class(xx)

47

'numeric'

'numeric'

# Class de my_character
" mode et classe my_character"
mode(my_character)
typeof(my_character)
class(my_character)

' mode et classe my_character'

'character'

'character'

'character'

# my_character + 10  # argument non numérique pour un opérateur binaire
paste(my_character, "euros") # Concatène après conversion en caractères
b <- paste(my_character, 14)
b
mode(b)
class(b)

'42 euros'

'42 14'

'character'

'character'

# Class de my_logical
" mode et classe my_logical"
mode(my_logical)
class(my_logical)

' mode et classe my_logical'

'logical'

'logical'

# Longueur et classe d'un vecteur construit avec ":"
vec1 <- 1:4
class(vec1)
length(vec1)

'integer'

4

# Longueur et classe d'un vecteur construit avec la fonction "c()"
vec2 <- c(1,2,3,4,6)
class(vec2)
length(vec2)

'numeric'

5

# Longueur et classe d'un vecteur vide
vec3 <- c()
class(vec3)
length(vec3)

'NULL'

0

Les types de base dans R

Les principaux modes ou types d'objet dans R sont:

Les guillemets de part et d'autre d'un texte ( "texte") indique que c'est du type character

Attributs d'un objet - méthode générique

Pour comprendre l'utilité des attributs d'un objet, considérons une variable age qui prendrait les valeurs entières de 1 à 10 : une telle variable peut représenter une variable entière quantitative d'un groupe d'enfants de 1 à 10 ans, ou le codage d'une variable catégorielle, des classes d'ages d'une population d'individus de 20 à 80 ans.

Le traitement statistique de cette variable ne sera pas le même dans les deux cas : avec R, les attributs de l'objet donnent l'information nécessaire à la définition du traitement d'un objet. Plus généralement, l'action d'une fonction sur un objet va dépendre des attributs de celui-ci.

# Variable quantitative
age1 <- c(1:10)
mode(age1)
class(age1)
attributes(age1)
summary(age1)
print(age1)

'numeric'

'integer'

NULL



   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
   1.00    3.25    5.50    5.50    7.75   10.00


 [1]  1  2  3  4  5  6  7  8  9 10

# Variable catégorielle
age2 <- as.factor(age1)
mode(age2)
class(age2)
attributes(age2)
summary(age2)
print(age2)

'numeric'

'factor'

$levels
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  6. '6'
  7. '7'
  8. '8'
  9. '9'
  10. '10'
$class
'factor'
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
 [1] 1  2  3  4  5  6  7  8  9  10
Levels: 1 2 3 4 5 6 7 8 9 10

# fonction generique - objet de classe "matrix"
a <- 1:20
cmat1 <-matrix(a,ncol=5)
class(cmat1)
attributes(cmat1)
print(cmat1)

# L'impression depend des attributs 'class' et 'dim'
cmat2 <-matrix(a,ncol=4)
class(cmat2)
attributes(cmat2)
print(cmat2)

'matrix'

$dim =

  1. 4
  2. 5

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20

'matrix'

$dim =

  1. 5
  2. 4

     [,1] [,2] [,3] [,4]
[1,]    1    6   11   16
[2,]    2    7   12   17
[3,]    3    8   13   18
[4,]    4    9   14   19
[5,]    5   10   15   20

Tester/ concertir le mode d'un objet

Le résultat de ces fonctions est un booléen qui prend les valeurs TRUE et FALSE

Il faut rester prudent quant à la signification de ces conversions, R retourne toujours un résultat même si la conversion n'a pas de sens...

# Conversion "logical" en "numeric"
a <- TRUE
mode(a)
as.numeric(a)

'logical'

1

# Conversion "logical" en "character"
as.character(a)

'TRUE'

# Conversion "character" en "numeric"
b <- "3"
as.numeric(b)
6 + as.numeric(b)
6+b

3

9

Error in 6 + b: non-numeric argument to binary operator
Traceback:

Valeur manquante et valeurs spéciales

Pour savoir où se trouvent les données manquantes, on utilise la fonction is.na(x) qui retourne un booléen de même longueur que x.

Les fonctions de test associés:

# Sans donnees manquantes
v <- c(2,6,4,8,2,9,10)
v
mean(v)
summary(v)
  1. 2
  2. 6
  3. 4
  4. 8
  5. 2
  6. 9
  7. 10

5.85714285714286

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   3.000   6.000   5.857   8.500  10.000

# Avec donnees manquantes
vv <- c(2,6,4,8,2,NA,10)
mean(vv)
mean(vv,na.rm=TRUE)
summary(vv)

[1] NA

5.33333333333333

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
  2.000   2.500   5.000   5.333   7.500  10.000       1

# Valeurs spéciales
exp(1e10)

Inf

w <- c(log(-4),6,9)
w
mean(w)
mean(w,na.rm=TRUE)

Inf

Warning message in log(-4):
“NaNs produced”
  1. NaN
  2. 6
  3. 9

NaN

7.5

Principaux objets prédéfinis dans R

On distinguera les objets atomiques, d'un type unique et les objets hétérogènes composés de plusieurs composantes de mode et de longueurs différents.

Les vecteurs

Les attributs

Les vecteurs sont des objets atomiques avec deux attributs intrinséques le mode (mode()) et sa longueur (length()).

# Vecteur numerique
v1 <- c(3,6,7)
v1
mode(v)
length(v)
  1. 3
  2. 6
  3. 7

'numeric'

7

# Vecteur de caractères
v2 <- c("a","b","c","d")
v2
mode(v2)
length(v2)
  1. 'a'
  2. 'b'
  3. 'c'
  4. 'd'

'character'

4

Les constructeurs de vecteurs

Plusieurs constructeurs sont fournis par R.

Les vecteurs numériques

 x <- c(1,0,76) 
x
 x <- c(2,6,-1,c(3,4)) 
x
 y <- c(3,0,x)
y
class(y)
  1. 1
  2. 0
  3. 76
  1. 2
  2. 6
  3. -1
  4. 3
  5. 4
  1. 3
  2. 0
  3. 2
  4. 6
  5. -1
  6. 3
  7. 4

'numeric'

z <- 1:6
class(z)

'integer'

seq(1,6,by=0.5) 
seq(1,6,length=5)
  1. 1
  2. 1.5
  3. 2
  4. 2.5
  5. 3
  6. 3.5
  7. 4
  8. 4.5
  9. 5
  10. 5.5
  11. 6
  1. 1
  2. 2.25
  3. 3.5
  4. 4.75
  5. 6
rep(1,4) 
rep(c(1,2),each=3); rep(c(1,2),3)
  1. 1
  2. 1
  3. 1
  4. 1
  1. 1
  2. 1
  3. 1
  4. 2
  5. 2
  6. 2
  1. 1
  2. 2
  3. 1
  4. 2
  5. 1
  6. 2

mesures <- scan(n=4)

Les vecteurs de caractères

Il est possible de créer des vecteurs de caractères en utilisant les fonctions "c" et "rep".

x <- c("A","L","I","C","E") 
x
y <- rep("A",4)
y
  1. 'A'
  2. 'L'
  3. 'I'
  4. 'C'
  5. 'E'
  1. 'A'
  2. 'A'
  3. 'A'
  4. 'A'

Les vecteurs logiques

Les vecteurs booléens peuvent être générés par des opérateurs logiques.

n <- 10
a <- c(1>0,n > 15)
a
  1. TRUE
  2. FALSE

Les fonctions any et all

#
x <- c(-1,2,3,-7,5,0)
test <- x > 0
test
#
y <-(1+x^2)*(x>0) # TRUE : 1 ; FALSE : 0
y
# 
all(x>0) # TRUE si tous >0
# 
any(x>0) # TRUE siun des elements > 0
  1. FALSE
  2. TRUE
  3. TRUE
  4. FALSE
  5. TRUE
  6. FALSE
  1. 0
  2. 5
  3. 10
  4. 0
  5. 26
  6. 0

FALSE

TRUE

Manipulation de vecteurs

Sélection d'une partie d'un vecteur:

Elle s'opère avec l'opérateur de sélection "[]" et un vecteur de sélection qui peut être un vecteurs d'entiers positifs, négatifs ou de logiques:

v <- 1:100
v[6] # 6 ieme element
v[6:15] # les éléments de 6 à 15
v[c(3,3,1,5)] # 3 ieme, 3ieme et premier et cinquieme element
v[4:2] # 4 ieme, 3ieme, 2ieme
v[-(1:5)] # v sans ses 5 premiers elements
v[(v<5)]
v[v<15 & v>=4] # & signifie "et"

6

  1. 6
  2. 7
  3. 8
  4. 9
  5. 10
  6. 11
  7. 12
  8. 13
  9. 14
  10. 15
  1. 3
  2. 3
  3. 1
  4. 5
  1. 4
  2. 3
  3. 2
  1. 6
  2. 7
  3. 8
  4. 9
  5. 10
  6. 11
  7. 12
  8. 13
  9. 14
  10. 15
  11. 16
  12. 17
  13. 18
  14. 19
  15. 20
  16. 21
  17. 22
  18. 23
  19. 24
  20. 25
  21. 26
  22. 27
  23. 28
  24. 29
  25. 30
  26. 31
  27. 32
  28. 33
  29. 34
  30. 35
  31. 36
  32. 37
  33. 38
  34. 39
  35. 40
  36. 41
  37. 42
  38. 43
  39. 44
  40. 45
  41. 46
  42. 47
  43. 48
  44. 49
  45. 50
  46. 51
  47. 52
  48. 53
  49. 54
  50. 55
  51. 56
  52. 57
  53. 58
  54. 59
  55. 60
  56. 61
  57. 62
  58. 63
  59. 64
  60. 65
  61. 66
  62. 67
  63. 68
  64. 69
  65. 70
  66. 71
  67. 72
  68. 73
  69. 74
  70. 75
  71. 76
  72. 77
  73. 78
  74. 79
  75. 80
  76. 81
  77. 82
  78. 83
  79. 84
  80. 85
  81. 86
  82. 87
  83. 88
  84. 89
  85. 90
  86. 91
  87. 92
  88. 93
  89. 94
  90. 95
  91. 96
  92. 97
  93. 98
  94. 99
  95. 100
  1. 1
  2. 2
  3. 3
  4. 4
  1. 4
  2. 5
  3. 6
  4. 7
  5. 8
  6. 9
  7. 10
  8. 11
  9. 12
  10. 13
  11. 14
U <- c(FALSE,TRUE,FALSE,FALSE)
T <- c(23,28,21,32) ; xx <- c(45,67,32,1)
T[U]
xx[T>24]

28

  1. 67
  2. 1
# Quelques selections
x <- c(5,-6,4,NA,12,8,NA)
x
x[is.na(x)] <- 0 # les elements NA de x, reçoivent la valeur 0
x
  1. 5
  2. -6
  3. 4
  4. NA
  5. 12
  6. 8
  7. NA
  1. 5
  2. -6
  3. 4
  4. 0
  5. 12
  6. 8
  7. 0
y <- c(-4,5,8,2,-1,-10,12)
y
y[y<0] <- -y[y<0] #remplacement des elements negatifs par leur valeur absolue
y
  1. -4
  2. 5
  3. 8
  4. 2
  5. -1
  6. -10
  7. 12
  1. 4
  2. 5
  3. 8
  4. 2
  5. 1
  6. 10
  7. 12

La fonction which donne les indices associés à la valeur TRUE d'un objet logique (vecteur, array,...). 

x <- c(10:15,45:50,1:4)
which.min(x ) 
x[which.min(x )]
which(x==min(x)) 
(1:length(x))[x == min(x)]

13

1

13

13

Manipulation vecteur de caractères

help(paste)

paste(1:5)  # identique 
as.character(1:5) # identique 
paste("A",1:5,sep="_")
paste(c("X","Y"),1:4,"txt",sep=".")
paste(c("X","Y"),1:4,sep=".",collapse = "+")
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  1. 'A_1'
  2. 'A_2'
  3. 'A_3'
  4. 'A_4'
  5. 'A_5'
  1. 'X.1.txt'
  2. 'Y.2.txt'
  3. 'X.3.txt'
  4. 'Y.4.txt'

'X.1+Y.2+X.3+Y.4'

substr("formater",4,8)

'mater'

Matrices

Les matrices sont des objets atomiques de dimension 2 de classe "matrix"

Les attributs

Les attributs d'un objet "matrix" sont le mode, la longueur (length()), un attribut "dim" qui fournit le nombre de lignes et de colonnes et un attribut optionnel "dimnames", une liste qui contient le nom des lignes et des colonnes.

Constructeurs

Un constructeur utilisé pour construire un objet de type "matrix" est la fonction "matrix()".

m1 <- matrix(c(3,4,5,10,23,6,0,-1),ncol=4)
mode(m1)
length(m1)
class(m1)
attributes(m1)
dim(m1)

'numeric'

8

'matrix'

$dim =

  1. 2
  2. 4

  1. 2
  2. 4
# Le nombre de lignes est un diviseur du nombre d'elements
m2 <- matrix(1:8,nrow=4)
dim(m2)
m2
  1. 4
  2. 2
15
26
37
48
 
# Le nombre de lignes n'est pas un diviseur du nombre d'elements
m3 <- matrix(1:8,nrow=3)
dim(m3)
m3

Warning message in matrix(1:8, nrow = 3):
“data length [8] is not a sub-multiple or multiple of the number of rows [3]”
  1. 3
  2. 3
147
258
361
 
m <- matrix(1:8,nrow=2,byrow=TRUE) # stockage par ligne
dim(m)
m
  1. 2
  2. 4
1234
5678

Utilisation des fonctions rbind et cbind

rbind et cbind: Prend une suite d'arguments vectoriels, matriciels ou "data-frame" et les combine par colonnes ou par lignes respectivement.

Ce sont des fonctions génériques avec des méthodes implémentées pour d'autres classes R.

mr <- rbind(c(1, 2, 3), c(4, 5, 6)) # chaque vecteur une ligne
mr
123
456
 
mc <- cbind(c(1, 2, 3), c(4, 5, 6)) # chaque vecteur une colonne
mc
14
25
36

Sélection d'éléments ou d'une partie de matrice

m <- matrix(1:12, ncol=4)
m
class(m)
1 4 7 10
2 5 8 11
3 6 9 12

'matrix'

a <- m[2,]
a
dim(a)
  1. 2
  2. 5
  3. 8
  4. 11
NULL

b <- m[,1]
b
class(a) #a n'est pas un objet de classe "matrix"
  1. 2
  2. 5
  3. 8
  4. 11
  1. 1
  2. 2
  3. 3

'integer'

m
a <-m[2,,drop=F]
class(a) # a est un objet de classe "matrix"
a
dim(a)
1 4 7 10
2 5 8 11
3 6 9 12

'matrix'

2 5 8 11
  1. 1
  2. 4
a <- m[,c(2,2,1)] # 2ieme, 2ieme, 1ere collonnes
m
a
1 4 7 10
2 5 8 11
3 6 9 12
441
552
663
 
m <- matrix(1:8, ncol=4)
m
a <- m[-1,] # m sans sa premiere ligne
class(a)
a
1357
2468

'integer'

  1. 2
  2. 4
  3. 6
  4. 8
m <- matrix(1:12, ncol=4)
m
a <- m[,-1] # m sans sa premiere ligne
a
class(a)
1 4 7 10
2 5 8 11
3 6 9 12
4 7 10
5 8 11
6 9 12

'matrix'

m <- matrix(1:8, ncol=4)
m
a <- m[1:2,-1] # 2 premieres lignes sans la 1ere colonne
a
class(a)
1357
2468
357
468

'matrix'

a <- m[-1,1:2] # 2 premieres colonnes sans la 1ere ligne
a
class(a)
  1. 2
  2. 4

'integer'

# 
m <- matrix(1:12, ncol=4)
m
a <- m[1:2,-1] # 2 premieres lignes sans la 1ere colonne
a
class(a)
1 4 7 10
2 5 8 11
3 6 9 12
4 7 10
5 8 11

'matrix'

a <- m[-1,1:2] # 2 premieres colonnes sans la 1ere ligne
a
class(a)
25
36

'matrix'

Calcul sur les matrices

A <- matrix(1:4,ncol=2)
A
B <- matrix(3:6,ncol=2,byrow=T) # optimise les acces memoire
B
A+B # somme él"ment par element
13
24
34
56
4 7
7 10
 
A*B # produit element par eement
312
1024
 
sin(A) # sinus element par element
exp(A) # exponentiellel element par element
0.8414710 0.1411200
0.9092974 -0.7568025
2.71828220.08554
7.38905654.59815

Opérateurs algébriques

Quelques fonctions algébriques sont disponibles dans l'installation de base de R. Pour connaître ce qui est disponible sur le sujet:

On a deux matrices X et Y

help.search("linear")

# produit de deux matrices
A <- matrix(1:4,ncol=2)
B <- matrix(c(5,7,6,8),ncol=2)
D <- A%*%t(B) # produit des matrices
D
class(D)
2331
3446

'matrix'

# Valeurs propres
eig <- eigen(D) # diagonalisation de D
eig
class(eig)
attributes(eig)
eig$values
class(eig$vectors)
eig$vectors[,1]
class(eig$values)
$values
  1. 68.9419801985891
  2. 0.0580198014109499
$vectors
-0.5593385-0.8038173
-0.8289393 0.5948762

'list'

$names =

  1. 'values'
  2. 'vectors'

  1. 68.9419801985891
  2. 0.0580198014109499

'matrix'

  1. -0.559338522317071
  2. -0.828939332793514

'numeric'

Opération sur les lignes et les colonnes (fonction apply)

A <- matrix(1:6,ncol=3)
ncol(A)
nrow(A)
dim(A)

3

2

  1. 2
  2. 3
A <- matrix(1:6,ncol=3)
A
apply(A,MARGIN=2,sum) # somme par colonne
135
246
  1. 3
  2. 7
  3. 11
apply(A,MARGIN=1,mean) # moyenne par ligne
  1. 3
  2. 4
mat1 <- matrix(1:8,ncol=4)
print(mat1)
mat2 <- matrix(1:12,ncol=4)
print(mat2)

     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

a <- rbind(mat1,mat2)
print(a)
class(a)

     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8
[3,]    1    4    7   10
[4,]    2    5    8   11
[5,]    3    6    9   12

'matrix'

Les facteurs

Les facteurs sont des vecteurs (objet atomique) permettant le traitement des données qualitatives.

Les attributs

Les attributs sont les deux attributes intrinsèques mode et length et l'attribut levels qui contient les modalités du facteur.

Les modalités du facteur peuvent être obtenues grâce à la fonction levels().

Les constructeurs

Trois fonctions permettent de créer des facteurs:

sexe <- factor(c("M","F","M","M","M","F"))
sexe
levels(sexe)
attributes(sexe)
mode(sexe)
typeof(sexe)
class(sexe)
summary(sexe)
  1. M
  2. F
  3. M
  4. M
  5. M
  6. F
  1. 'F'
  2. 'M'
$levels
  1. 'F'
  2. 'M'
$class
'factor'

'numeric'

'integer'

'factor'

F
2
M
4
niveau <- ordered(c("deb","deb","cha","moyen","cha"),levels=c("deb","moyen","cha"))
niveau
levels(niveau)
class(niveau)
  1. deb
  2. deb
  3. cha
  4. moyen
  5. cha
  1. 'deb'
  2. 'moyen'
  3. 'cha'
  1. 'ordered'
  2. 'factor'
# variable quantitative
salto <- c(1:5,7:3)
salto
class(salto)
summary(salto)
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 7
  7. 6
  8. 5
  9. 4
  10. 3

'integer'

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      1       3       4       4       5       7

# variable qualitative
salto.f <- as.factor(salto)
salto.f
class(salto.f)
summary(salto.f)
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 7
  7. 6
  8. 5
  9. 4
  10. 3

'factor'

1
1
2
1
3
2
4
2
5
2
6
1
7
1

Sélection

levels(salto.f)
nlevels(salto.f)
table(salto.f)
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  6. '6'
  7. '7'

7

salto.f
1 2 3 4 5 6 7 
1 1 2 2 2 1 1

Lorsque deux variables qualitatives sont traitées, on peut présenter les données sous deux formes: - par un tableau classique où une ligne représente un individu sur lequel est observées les deux variables en colonne. - par un tableau croisé, appelé aussi tableau de contingence qui donne l'effectif de chaque croisement des modalités.

Ce qui peut se généraliser à plus de deux variables qualitatives.

# Deux variables qualitatives "laine" et "tension" sur 10 individus
tension <- factor(c(rep("Faible",5),rep("Forte",5)))
tension
levels(tension)
  1. Faible
  2. Faible
  3. Faible
  4. Faible
  5. Faible
  6. Forte
  7. Forte
  8. Forte
  9. Forte
  10. Forte
  1. 'Faible'
  2. 'Forte'
laine  <- factor(c(rep("Mer",3),rep("Ang",3),rep("Tex",4)))
laine
levels(laine)
  1. Mer
  2. Mer
  3. Mer
  4. Ang
  5. Ang
  6. Ang
  7. Tex
  8. Tex
  9. Tex
  10. Tex
  1. 'Ang'
  2. 'Mer'
  3. 'Tex'
# On fusionne les deux variables dans le tableau don avec cbind
ls()
don <- cbind(tension,laine)
don
class(don)
summary(don)
  1. 'don'
  2. 'laine'
  3. 'tension'
tensionlaine
12
12
12
11
11
21
23
23
23
23

'matrix'

    tension        laine     
 Min.   :1.0   Min.   :1.00  
 1st Qu.:1.0   1st Qu.:1.25  
 Median :1.5   Median :2.00  
 Mean   :1.5   Mean   :2.10  
 3rd Qu.:2.0   3rd Qu.:3.00  
 Max.   :2.0   Max.   :3.00

don <- as.data.frame(don)  # cbind.data.frame
class(don)
attributes(don)
summary(don)
don$tension

'data.frame'

$names
  1. 'tension'
  2. 'laine'
$row.names
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
$class
'data.frame'
    tension        laine     
 Min.   :1.0   Min.   :1.00  
 1st Qu.:1.0   1st Qu.:1.25  
 Median :1.5   Median :2.00  
 Mean   :1.5   Mean   :2.10  
 3rd Qu.:2.0   3rd Qu.:3.00  
 Max.   :2.0   Max.   :3.00
  1. 1
  2. 1
  3. 1
  4. 1
  5. 1
  6. 2
  7. 2
  8. 2
  9. 2
  10. 2
# On fusionne les deux variables dans le tableau don avec cbind.data.frame
don2 <- cbind.data.frame(tension,laine)
don2
class(don2)
attributes(don2)
don2$tension
tensionlaine
FaibleMer
FaibleMer
FaibleMer
FaibleAng
FaibleAng
Forte Ang
Forte Tex
Forte Tex
Forte Tex
Forte Tex

'data.frame'

$names
  1. 'tension'
  2. 'laine'
$row.names
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
$class
'data.frame'
  1. Faible
  2. Faible
  3. Faible
  4. Faible
  5. Faible
  6. Forte
  7. Forte
  8. Forte
  9. Forte
  10. Forte

Observez la différences entre don et don2

On conserve don2

tabcroise <- table(don2$laine,don2$tension)
class(tabcroise)
tabcroise

'table'

      Faible Forte
  Ang      2     1
  Mer      3     0
  Tex      0     4

De nombreuses fonctions de R étant bâties sur l'hypothèse d'un tableau individiXvariables, il faut pouvoir effectuer l'opération inverse lorsque les données sont fournies sous forme de tableau de contingence.

tabframe <- as.data.frame(tabcroise)
tabframe
attributes(tabframe)
summary(tabframe)
# construire le tableau de donnees individusXvariables à partir de tabframe est possible
# petit exercice de programmation
Var1Var2Freq
Ang Faible2
Mer Faible3
Tex Faible0
Ang Forte 1
Mer Forte 0
Tex Forte 4
$names
  1. 'Var1'
  2. 'Var2'
  3. 'Freq'
$row.names
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
$class
'data.frame'
  Var1       Var2        Freq      
 Ang:2   Faible:3   Min.   :0.000  
 Mer:2   Forte :3   1st Qu.:0.250  
 Tex:2              Median :1.500  
                    Mean   :1.667  
                    3rd Qu.:2.750  
                    Max.   :4.000

Les liste

Les listes sont des objets hétérogènes. C'est un ensemble ordonné d'objets ou composantes qui n'ont pas toujours le même mode ou la même longueur.

Les listes sont des objets importants car toutes les fonctions qui retournent plusieurs objets le font sous la forme d'une liste.

Les attributs:

Les deux attributes intrinsèques mode et length et l'attribut supplémentaires names qui contient le nom des composantes de la liste.

Le nom des composantes peut être défini et obtenu par la fonctions names().

Constructeurs

La fonction list() permet de créer une liste:

vecteur <- c(2,10,by=2)
matrice <- matrix(1:8,ncol=2)
facteur <- factor(c("M","F","M","M","M","F"))
maListe <- list(vecteur,matrice,facteur)
mode(maListe)
length(maListe)
attributes(maListe)
names(maListe) <-c("vecteur","matrice","facteur")
attributes(maListe)
maListe

'list'

3

NULL

$names =

  1. 'vecteur'
  2. 'matrice'
  3. 'facteur'

$vecteur
1
2
2
10
by
2
$matrice
15
26
37
48
$facteur
  1. M
  2. F
  3. M
  4. M
  5. M
  6. F

Extraction d'une liste

Pour extraire une composante de la liste:

#maListe
d <-maListe[[2]]
d
class(d)
maListe[[2]][2,1] # l'element de la deuxieme ligne et premiere colonne de la composante "matrice"
15
26
37
48

'matrix'

2

attributes(maListe)
maListe$vecteur
maListe[["vecteur"]]

$names =

  1. 'vecteur'
  2. 'matrice'
  3. 'facteur'

1
2
2
10
by
2
1
2
2
10
by
2
a <- maListe[2]
class(a)
attributes(a)

'list'

$names = 'matrice'

b <- maListe[[2]]
class(b)

'matrix'

c <- maListe[c(1,3)]
c
class(c)
$vecteur
1
2
2
10
by
2
$facteur
  1. M
  2. F
  3. M
  4. M
  5. M
  6. F

'list'

Quelques fonctions sur les listes

x <- list(a = 1:10, beta = exp(-3:3),logic = c(TRUE,FALSE,FALSE,TRUE))
# Calcule la moyenne pour chaque element de la liste
xmean <-lapply(x, mean) # median for each list element
xmean
class(xmean)
xmean$a
xmean$beta
xmean$logic
$a
5.5
$beta
4.53512523476476
$logic
0.5

'list'

5.5

4.53512523476476

0.5

l1 <- list(a = 1:10, beta = exp(-3:3))
length(l1)
l2 <- list(ch=c("M","A","A"), re=seq(0,1,20))
length(l2)
ll <- c(l1,l2)
mode(ll)
length(ll)
class(ll)
names(l1) 
names(ll)

2

2

'list'

4

'list'

  1. 'a'
  2. 'beta'
  1. 'a'
  2. 'beta'
  3. 'ch'
  4. 're'

La liste dimnames

C'est un attribut optionnel d'un objet R à plusieurs dimensions(matrices, array,list,...) qui contient dans une liste les noms des éléments de chaque dimension.

# Cas d'une matrice
X <- matrix(1:12,nrow=4) # 4 lignes et 3 colonnes
nomligne <- c("l1","l2","l3","l4")
nomcol <- c("col1","col2","col3")
X
dimnames(X) <- list(nomligne,nomcol)
X
1 5 9
2 6 10
3 7 11
4 8 12
col1col2col3
l11 5 9
l22 6 10
l33 7 11
l44 8 12
 
X[c("l1","l4"),c("col2","col3")]
col2col3
l15 9
l48 12

Les data-frame

Un tableau de données est un ensemble de vecteurs rangés colonne par colonne. Chaque colonne du tableau data correspond à une variable, chaque ligne à un individu. Les variables peuvent être de type différent (numérique, booléen, character,...), elles sont de même longueur.

C'est ce même concept qu'on utilise dans les progiciels statistiques tels que SAS, BMDP, SPSS...

Les data-frame sont des listes particulières dont les composantes sont de même longueur mais dont les modes peuvent être différents.

Les tableaux de données usuels utiliséss en statistique sont considérés comme des data-frame.

Les attributs

Un data-frame a pour attributs son mode, sa longueur, le nom des variables (names), le nom des individus (row.names) et les dimensions du tableau (nombre de lignes, nombre de colonnes).

Pour accéder à la valeur de ces attributs, on utilise le caractère \$ et le nom de l'attribut.

La fonction dim() fournit les dimensions du tableau de données: le nombre d'observations et le nombre de variables.

La fonction dimnames() fournit le nom des dimensions du tableau de données: le nom des individus et le nom des variables.

La fonction str() fournit l'ensemble des informations sur les variables du data-frame en argument.

Les constructeurs

Les principales manières de construire un data-frame est d'utiliser une des fonctions:

n <- 5
vec1 <- 1:n
vec2 <- c("a","f","s","o","p")
df <- data.frame(nomVar1=vec1,nomVar2=vec2)
df
nomVar1nomVar2
1a
2f
3s
4o
5p
 
str(df)
class(df)
length(df) # nombre de variables
dim(df) # dimension du tableau de donnees

'data.frame':   5 obs. of  2 variables:
 $ nomVar1: int  1 2 3 4 5
 $ nomVar2: Factor w/ 5 levels "a","f","o","p",..: 1 2 5 3 4

'data.frame'

2

  1. 5
  2. 2
dimnames(df)
dimnames(df)[[1]] # noms des lignes
dimnames(df)[[2]] # noms des colonnes
    1. '1'
    2. '2'
    3. '3'
    4. '4'
    5. '5'
    1. 'nomVar1'
    2. 'nomVar2'
  1. '1'
  2. '2'
  3. '3'
  4. '4'
  5. '5'
  1. 'nomVar1'
  2. 'nomVar2'
mtcars <- read.csv("data/mtcars.csv",header=TRUE,sep=",",dec=".")
class(mtcars)
dim(mtcars)
dimnames(mtcars)

'data.frame'

  1. 32
  2. 11
    1. '1'
    2. '2'
    3. '3'
    4. '4'
    5. '5'
    6. '6'
    7. '7'
    8. '8'
    9. '9'
    10. '10'
    11. '11'
    12. '12'
    13. '13'
    14. '14'
    15. '15'
    16. '16'
    17. '17'
    18. '18'
    19. '19'
    20. '20'
    21. '21'
    22. '22'
    23. '23'
    24. '24'
    25. '25'
    26. '26'
    27. '27'
    28. '28'
    29. '29'
    30. '30'
    31. '31'
    32. '32'
    1. 'mpg'
    2. 'cyl'
    3. 'disp'
    4. 'hp'
    5. 'drat'
    6. 'wt'
    7. 'qsec'
    8. 'vs'
    9. 'am'
    10. 'gear'
    11. 'carb'
mtcars2 <- read.table("data/mtcars.csv",header=TRUE,sep=",")
class(mtcars2)
dim(mtcars2)
dimnames(mtcars2)

'data.frame'

  1. 32
  2. 11
    1. '1'
    2. '2'
    3. '3'
    4. '4'
    5. '5'
    6. '6'
    7. '7'
    8. '8'
    9. '9'
    10. '10'
    11. '11'
    12. '12'
    13. '13'
    14. '14'
    15. '15'
    16. '16'
    17. '17'
    18. '18'
    19. '19'
    20. '20'
    21. '21'
    22. '22'
    23. '23'
    24. '24'
    25. '25'
    26. '26'
    27. '27'
    28. '28'
    29. '29'
    30. '30'
    31. '31'
    32. '32'
    1. 'mpg'
    2. 'cyl'
    3. 'disp'
    4. 'hp'
    5. 'drat'
    6. 'wt'
    7. 'qsec'
    8. 'vs'
    9. 'am'
    10. 'gear'
    11. 'carb'

Fonctions utiles dans un data-frame

Extraction

Pour extraire les composantes des data-frame, on peut utiliser les méthodes pour les listes ou pour les matrices.

# une variable du data-frame
names(mtcars)  # noms des variables
#str(mtcars)
mtcars$mpg      # affichage du contenu de la variable mtg par son nom
  1. 'mpg'
  2. 'cyl'
  3. 'disp'
  4. 'hp'
  5. 'drat'
  6. 'wt'
  7. 'qsec'
  8. 'vs'
  9. 'am'
  10. 'gear'
  11. 'carb'
  1. 21
  2. 21
  3. 22.8
  4. 21.4
  5. 18.7
  6. 18.1
  7. 14.3
  8. 24.4
  9. 22.8
  10. 19.2
  11. 17.8
  12. 16.4
  13. 17.3
  14. 15.2
  15. 10.4
  16. 10.4
  17. 14.7
  18. 32.4
  19. 30.4
  20. 33.9
  21. 21.5
  22. 15.5
  23. 15.2
  24. 13.3
  25. 19.2
  26. 27.3
  27. 26
  28. 30.4
  29. 15.8
  30. 19.7
  31. 15
  32. 21.4
mtcars[[1]] # affichage du contenu de la variable mtg par son numéro d'ordre dans le data-frame
  1. 21
  2. 21
  3. 22.8
  4. 21.4
  5. 18.7
  6. 18.1
  7. 14.3
  8. 24.4
  9. 22.8
  10. 19.2
  11. 17.8
  12. 16.4
  13. 17.3
  14. 15.2
  15. 10.4
  16. 10.4
  17. 14.7
  18. 32.4
  19. 30.4
  20. 33.9
  21. 21.5
  22. 15.5
  23. 15.2
  24. 13.3
  25. 19.2
  26. 27.3
  27. 26
  28. 30.4
  29. 15.8
  30. 19.7
  31. 15
  32. 21.4

Pour en savoir plus Gestion des données avec R (Christophe Lalanne & Bruno Falissard -MOOC "Introduction à la statistique avec R").

Les fonctions

Une fonction permet d'effectuer un certain nombre d'instructions R.

L'implémentation de R de base fournit un grand nombre de fonctions prédéfinies (mean, max, ...). Voir help("Math").

Une nouvelle fonction est créée par une construction de la forme :

fun.name<-function( *arglist* ) {
    bloc d'instructions
    }

Une fonction est un objet R qui devra appartenir au workspace de la session pour être utilisée. 

help("Math")

rm(list=ls()) # on efface tous les objets de l'espace de travail

# Si la fonction "som" est dans un script R stocké dans le fichier somme.R
ls()
source("somme.R")
# La fonction "som" est un objet de l'espace de travail
ls() 
som(6)

'som'

21

# La fonction "som" n'est pas un objet de l'espace de travail
rm(som)
ls() 
som(6)

Error in eval(expr, envir, enclos): could not find function "som"
Traceback:

"avant"
ls()
som <- function(n){
    result <- sum(1:n)
    return(result)
}
"apres"
ls()
som(3)  # appel a la fonction

'avant'

'apres'

'som'

6

Les arguments d'une fonction

mafonction <- function(a = 1, b = 2, c) {
    resultat <- c(a, b, c)
    names(resultat) <- c("a", "b", "c")
    return(resultat) }
mafonction(6,7,8)

# Valeur par défaut pour b
mafonction(10,c="string")
a
'10'
b
'2'
c
'string'
# Valeur par défaut pour a
mafonction(b=10,c="string")
a
'1'
b
'10'
c
'string'
mafonction(10,"string")

Error in mafonction(10, "string"): argument "c" is missing, with no default
Traceback:


1. mafonction(10, "string")

args(mafonction)

function (a = 1, b = 2, c) 
NULL
# arguments par défaut de la fonction plot
args(plot.default)

function (x, y = NULL, type = "p", xlim = NULL, ylim = NULL, 
    log = "", main = NULL, sub = NULL, xlab = NULL, ylab = NULL, 
    ann = par("ann"), axes = TRUE, frame.plot = axes, panel.first = NULL, 
    panel.last = NULL, asp = NA, ...) 
NULL

La simple consultation de la liste des arguments remplace parfois avantageusement la lecture de la documentation.

body(mafonction)

{
    resultat <- c(a, b, c)
    names(resultat) <- c("a", "b", "c")
    return(resultat)
}

mafonction # args() + body()

function (a = 1, b = 2, c) 
{
    resultat <- c(a, b, c)
    names(resultat) <- c("a", "b", "c")
    return(resultat)
}

L'argument "..."

Par exemple, une fonction graphique de haut niveau transmettra l'argument point-point-point à des fonctions graphiques de bas niveau pour traitement.

# Utilisation de l'argument "..."
f <- function(x, y, ...) {
    plot.default(x = x, y = y, ...)
    abline(coef = lm(y ~ x)$coef)
}
f(1:10, 1:10)

png

Comme nous avons transmis l'argument point-point-point à plot.default(), tout ce que plot.default() sait faire, notre fonction f() sait le faire également.

f(1:10, 1:10, main = "Titre de ce graphique", pch = 19,col = "blue", las = 1, 
  panel.first = grid(col = "pink",lty = "solid"))

png

Plusieurs résultats à une même fonction

Le résultat sera fourni sous forme d'une liste.

Considérons une fonction avec deux arguments en entrée: facteur et facteur2, deux variables qualitatives.

Cette fonction (mafonc) renvoie le tableau de contingence et le vecteur de caractères des niveaux de facteur1 et facteurs2 pour lesquels l'effectif est conjointement nul.

# Definition de la fonction
mafonc <- function(facteur1,facteur2) {
    res1 <-table(facteur1,facteur2)  # tableau de contingence
    selection <- which(res1 == 0,arr.ind=TRUE)
    res2 <- matrix("",nrow=nrow(selection),ncol=2)
    res2[,1] <- levels(facteur1)[selection[,1]]
    res2[,2] <- levels(facteur2)[selection[,2]]
    # deux objets à retourner, utilisation d'une liste
    return(list(tab=res1,niveau=res2))}


# Appel de la fonction
tension <- factor(c(rep("Faible",5),rep("Forte",5)))
laine <- factor(c(rep("Mer",3),rep("Ang",3),rep("Tex",4)))
#
res <- mafonc(tension,laine)
class(res)
res$tab
res$niveau

'list'

        facteur2
facteur1 Ang Mer Tex
  Faible   2   3   0
  Forte    1   0   4
Forte Mer
FaibleTex

Portée des variables

rm(list=ls())
mavariable <- 1
ls()
#
# la variable "ma variable" est définie à l'extérieur et à l'intérieur de la fonction
mafonction1 <- function() {
    mavariable <- 5
    print(mavariable)
} 
#
mafonction1()
mavariable
#

'mavariable'

[1] 5

1

# la variable "ma variable" est définie uniquement à l'extérieur
mafonction2 <- function() {
    print(mavariable)
}
mafonction2()

[1] 1