Présentation de Rstudio

RStudio est une interface du logiciel R. Il comprend 4 fenêtres :

Vous devez créer un nouveau script R que vous nommerez “TP1.R”. Pensez à commenter chacune de vos lignes de commandes.

R est un super-calculateur

Il est possible d’effectuer des calculs très simples comme :

5*(-3.2)
## [1] -16
5^2
## [1] 25
5**2
## [1] 25
sin(2*pi/3)
## [1] 0.8660254
sqrt(3)/2
## [1] 0.8660254
log(exp(1))
## [1] 1
log(1)
## [1] 0

Affectations

x<-1
x
## [1] 1
2*x
## [1] 2
ch <- "Voici une chaîne"
ch
## [1] "Voici une chaîne"
(ch <- 'Voici une chaîne')
## [1] "Voici une chaîne"
(nb <- 101)
## [1] 101
(nb2 <- 101L)
## [1] 101
c(TRUE,FALSE,T,F)
## [1]  TRUE FALSE  TRUE FALSE
nb==nb2
## [1] TRUE
identical(nb,nb2)
## [1] FALSE
NA
## [1] NA
c(NaN,log(-1),0/0)
## Warning in log(-1): NaNs produced
## [1] NaN NaN NaN
c(Inf,1/0,-1/0)
## [1]  Inf  Inf -Inf
(a <- 1+2i)
## [1] 1+2i
rm(ch,nb,nb2,a)

Différents types de données

Vecteurs

On peut créer des vecteurs via la commande suivante

c(1,2,3,4,5)
## [1] 1 2 3 4 5
c(1:5)
## [1] 1 2 3 4 5
v <- c(1,3,2)
v
## [1] 1 3 2
logical(2)
## [1] FALSE FALSE
integer(1)
## [1] 0
numeric()
## numeric(0)
character(3)
## [1] "" "" ""
1:10
##  [1]  1  2  3  4  5  6  7  8  9 10
seq(1,10)
##  [1]  1  2  3  4  5  6  7  8  9 10
rep(2,3)
## [1] 2 2 2
rep(1:2,3)
## [1] 1 2 1 2 1 2
rep(1:2,2:3)
## [1] 1 1 2 2 2
rep(c("toto","tutu"),2:1)
## [1] "toto" "toto" "tutu"
paste(c("toto","tutu"),1:2)
## [1] "toto 1" "tutu 2"
paste(c("toto","tutu"),1:2,sep="")
## [1] "toto1" "tutu2"
paste(c("toto","tutu"),1:2,collapse=" & ")
## [1] "toto 1 & tutu 2"

On peut également effectuer des opérations sur les vecteurs :

x<-c(10:22)
y<-2*c(1:5)
z<-seq(0,20,1.3)
z[8]
## [1] 9.1
z[-8]
##  [1]  0.0  1.3  2.6  3.9  5.2  6.5  7.8 10.4 11.7 13.0 14.3 15.6 16.9 18.2
## [15] 19.5
z[1:8]
## [1] 0.0 1.3 2.6 3.9 5.2 6.5 7.8 9.1
z[-(1:8)]
## [1] 10.4 11.7 13.0 14.3 15.6 16.9 18.2 19.5
z[9:length(z)]
## [1] 10.4 11.7 13.0 14.3 15.6 16.9 18.2 19.5
z[c(2,6,14)]
## [1]  1.3  6.5 16.9
z[z>10]
## [1] 10.4 11.7 13.0 14.3 15.6 16.9 18.2 19.5
z[z>4 & z<15]
## [1]  5.2  6.5  7.8  9.1 10.4 11.7 13.0 14.3

Extraction dans un vecteur

v
## [1] 1 3 2
v[c(1,3)]
## [1] 1 2
v[v %in% c(1,2)]
## [1] 1 2
v %in% c(1,2)
## [1]  TRUE FALSE  TRUE
v[c(TRUE,FALSE,TRUE)]
## [1] 1 2

Listes

(l <- list(1:10,c("toto","titi")))
## [[1]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[2]]
## [1] "toto" "titi"
(l2 <- list(a=1:10,b=c("toto","titi")))
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $b
## [1] "toto" "titi"
c(l,l2)
## [[1]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[2]]
## [1] "toto" "titi"
## 
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $b
## [1] "toto" "titi"

Extraction dans une liste

l2[[1]]   # élément de l2 par index
##  [1]  1  2  3  4  5  6  7  8  9 10
l2$a      # élément "a" de l2 (mode utilisateur)
##  [1]  1  2  3  4  5  6  7  8  9 10
l2[["a"]] # même chose (mode développeur)
##  [1]  1  2  3  4  5  6  7  8  9 10
clé<-"a"  # si clé variable contenant "a" (ou 1)
l2[[clé]] # permet l'extraction par variable
##  [1]  1  2  3  4  5  6  7  8  9 10
## ATTENTION!
l2$clé    # car clé pas élément de l2
## NULL
names(l2) # comme il est montré ici
## [1] "a" "b"

Extraction dans une sous liste

l2[1]
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
names(l2)
## [1] "a" "b"
l2[c(2,1)]
## $b
## [1] "toto" "titi"
## 
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
names(l2) # comme il est montré ici
## [1] "a" "b"

Matrices

A<-matrix(1:12,nrow=4,ncol=3,byrow=TRUE)
B<-matrix(1:12,nrow=4,ncol=3)
t(A)
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
A[2,3]
## [1] 6
A[,3]
## [1]  3  6  9 12
A[,c(1,3)]
##      [,1] [,2]
## [1,]    1    3
## [2,]    4    6
## [3,]    7    9
## [4,]   10   12
t(B)%*%A
##      [,1] [,2] [,3]
## [1,]   70   80   90
## [2,]  158  184  210
## [3,]  246  288  330

Auto-conversion vecteur

a <- c(TRUE,2L)
a
## [1] 1 2
class(a)
## [1] "integer"
a <- c(a,3)
a
## [1] 1 2 3
class(a)
## [1] "numeric"
a <- c(a,"quatre")
a
## [1] "1"      "2"      "3"      "quatre"
class(a)
## [1] "character"
rm(a)

Auto-conversion vector -> list

c(l,v) # équivalent à c(l,as.list(v))
## [[1]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[2]]
## [1] "toto" "titi"
## 
## [[3]]
## [1] 1
## 
## [[4]]
## [1] 3
## 
## [[5]]
## [1] 2
c(v,l) # équivalent à c(as.list(v),l)
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 3
## 
## [[3]]
## [1] 2
## 
## [[4]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[5]]
## [1] "toto" "titi"

Recycling

(1:8)[c(TRUE,FALSE)]
## [1] 1 3 5 7
(1:9)[c(TRUE,FALSE)]
## [1] 1 3 5 7 9
(1:8)[c(TRUE,FALSE,FALSE)]
## [1] 1 4 7
cbind(1:5,c(TRUE,FALSE,FALSE))
## Warning in cbind(1:5, c(TRUE, FALSE, FALSE)): number of rows of result is
## not a multiple of vector length (arg 2)
##      [,1] [,2]
## [1,]    1    1
## [2,]    2    0
## [3,]    3    0
## [4,]    4    1
## [5,]    5    0

Attention le reycling ne fonctionne pas sur les dataframes (cf. ci-dessous).

Tableau individus\(\times\)variables

Cette structure est très utilisée en statistique et se nomme data.frame sous R. C’est une matrice dont les lignes correspondent aux individus et les colonnes aux variables mesurées sur ces individus. Chaque colonne représente une variable dont tous les éléments sont du même type. Voici un exemple :

IMC <- data.frame(Sexe=c("H","F","H","F"),Taille=c(1.83,1.76,1.82,1.60),Poids=c(67,58,66,48),row.names=c("Pierre","Valérie","Paul","Virginie"))

Les facteurs (factor) et les variables ordinales (ordered)

Le logiciel permet d’organiser les chaînes de caractères au moyen de factor() :

x<-factor(c("bleu","vert","bleu","rouge","bleu","vert","vert"))
x
## [1] bleu  vert  bleu  rouge bleu  vert  vert 
## Levels: bleu rouge vert
levels(x) 
## [1] "bleu"  "rouge" "vert"
class(x)
## [1] "factor"

Il est possible de mettre des facteurs dans un data.frame. La fonction factor() est donc à utiliser pour stocker les variables qualitatives. Pour les variables ordinales, il est plutôt conseillé d’utiliser la fonction ordered():

z <- ordered(c("Petit","Grand","Moyen","Grand","Moyen","Petit","Petit"),levels=c("Petit","Moyen","Grand")) 
class(z)
## [1] "ordered" "factor"
z
## [1] Petit Grand Moyen Grand Moyen Petit Petit
## Levels: Petit < Moyen < Grand

Fonctions sous R

Une fonction est un objet R, comme les vecteurs, les matrices, les tableaux de données. Il existe beaucoup de fonctions classiques que vous serez amenés à utiliser. Ainsi, la fonction c() permet de créer un vecteur.

c(1:5)
## [1] 1 2 3 4 5

Mes premières fonctions

Vous pouvez également créer vos propres fonctions. La syntaxe est la suivante

Hello <- function()
{
cat("Hello World","\n") 
}

Ensuite, vous pouvez exécuter cette fonction comme suit (ne pas oublier les parenthèses)

Hello()
## Hello World

On peut remarquer que la fontion précédente n’avait pas d’argument. La plupart du temps, les fonctions possèdent des arguments en entrée.

Bonjour <- function(x)
{
  cat("Bonjour",x,"\n") 
}
Bonjour("et bon TP")
## Bonjour et bon TP

Quelques fonctions usuelles

La fonction sample(x) permet de tirer aléatoirement parmi les éléments de x, avec ou sans remise. Ainsi, on peut simuler 10 lancers d’une pièce de monnaie comme suit (en considérant que les 1 sont des piles et les 0 des faces) :

sample(0:1,10,replace=T)
##  [1] 1 1 1 1 0 0 1 0 0 0

On peut également générer des nombres aléatoires entre 0 et 1 par la fonction runif :

runif(5)
## [1] 0.20057267 0.79795897 0.84881522 0.30646021 0.01538898

Une autre commande utile est replicate() qui permet de répéter une expression. On peut par exemple répéter 100 fois le lancement de 10 pièces de monnaie.

lancer <- function() sample(0:1,10,replace=T)
simu <- replicate(100,lancer())

La fonction apply() permet de retourner un vecteur obtennu en appliquant une fonction sur une matrice. On peut, dans l’exemple précédent, compre le nombre de piles obtenu par expérience.

(nb.pile<-apply(simu,MARGIN=2,FUN=sum))
##   [1] 6 5 7 6 3 7 3 4 4 5 7 4 5 7 7 9 6 5 6 2 5 5 5 7 2 5 6 7 4 6 6 5 5 2 4
##  [36] 3 7 4 8 5 5 7 5 5 4 5 4 5 4 3 4 7 2 6 5 7 6 5 3 6 5 8 7 7 5 8 5 7 4 5
##  [71] 5 4 7 7 6 4 3 4 3 3 3 3 7 3 4 2 5 4 5 6 4 6 3 6 4 6 4 4 7 4
table(nb.pile)
## nb.pile
##  2  3  4  5  6  7  8  9 
##  5 12 21 25 15 18  3  1
barplot(table(nb.pile)/100,main="Diagramme en baton des piles obtenus",xlab="Nombre de piles")

Exercices

TP : Etude sur l’indice de la masse corporelle

On dispose d’un échantillon de 10 enfants agés de 3 ou 4 ans lors de leur entrée en maternelle. Les données disponibles pour chaque enfant sont :

Prénom Erika Célia Eric Eve Paul Jean Adan Louis Jules Léo
Sexe F F G F G G G G G G
ZEP O O O O N O N O O O
Poids 16 14 13.5 15.4 16.5 16 17 14.8 17 16.7
An 3 3 3 4 3 4 3 3 4 3
Mois 5 10 5 0 8 0 11 9 1 3
Taille 100 97 95.5 101 100 98.5 103 98 101.5 100
  1. Choisissez la fonction R appropriée pour enregistrer les données de chacune des variables dans des vecteurs que vous nommerez Individus, Poids, Taille et Sexe.
  2. Calculez la moyenne des variables lorsque c’est possible.
  3. Calculer l’IMC des individus et regroupez les valeurs obtenues dans un vecteur nommé IMC sachant que \[ IMC= \displaystyle \frac{Poids (kg)}{Taille^2(m)} \]
  4. Regroupez ces variables dans la structure R qui vous paraît la plus adaptée.
  5. Utilisez l’aide en ligne de R afin d’obtenir des informations sur la fonction plot().
  6. Tracez le nuage de points du Poids en fonction de la Taille. Pensez à fournir un titre à votre graphique et à annoter vos axes.

Importer des données

Importer des données depuis un fichier texte ASCII

On peut entrer à la main dans un fichier à l’aide de votre éditeur de texte préféré. Lorsque le nombre de données est important, il est préférable d’utiliser un tableur.

Il existe trois fonctions R principales à utiliser pour importer des données depuis un fichier texte :

  • read.table() : pour les jeux de données sous forme de tableaux.
  • read.ftable() : permet de lire les tableaux de contingence.
  • scan() : beaucoup plus flexible et puissant.

Commencer par télécharger le fichier Nutriage.

Importer avec read.table()

Cette instruction va lire les données présentes dans le fichier et les rapatrier sous la forme d’un data.frame :

donnees <- read.table(file="nutriage.txt",header=T,sep="\t",dec=".")
library(DT)
datatable(donnees, options = list(pageLength = 5))

Vous avez intérêt à utiliser la fonction file.choose() à la place du nom du fichier. Cette fonction va ouvrir une boite de dialogue, dans laquelle vous pourrez aller chercher votre fichier.

La fonction read.table() comprend de nombreux paramètres dont les plus utilisés sont :

  • file=chemin/vers/fichier : emplacement et nom du fichier à lire. file.choose() permet d’ouvrir une fenêtre de dialogue pour choisir le fichier.
  • header=TRUE : valeur logique indiquant si le fichier contient le nom des variables sur la première ligne.
  • sep=“\(\backslash t\)” : les valeurs sur chaque ligne sont séparées par ce caractère (“\(\backslash t\)” pour tabulation, " " pour un espace, “,” pour une virgule).
  • dec=“.” : séparateur décimal pour les nombres (“.” ou “,”).
  • row.names=1 : la première colonne du fichier contient le nom des individus. Si ce n’est pas le cas, il suffit d’omettre ce paramètre.

La fonction attach() permet d’avoir accès aux variables du data.frame directement en tapant leur nom.

attach(donnees)

Importer depuis RStudio

RStudio permet d’importer directement des données via le menu “Environment” puis l’onglet “Import Dataset”. Télécharger le fichier nommé “nutriage.txt” depuis l’intranet et créer sous R le dataframe associé à ce jeux de données, que vous nommerez “nutriage”. La description de ce jeu de données se trouve dans le fichier “nutriage.html”, que vous trouverez sur l’intranet.

Question : Combien y-a-t-il de variables ? Combien y-a-t-il d’invidus ?

Etude d’un jeu de données

Structuration des variables suivant leur type

En statistique, on classe les variables selon 4 catégories :

  • qualitatives nominales (sans ordre)
  • qualitatives ordinales (avec ordre)
  • quantitatives discrètes
  • quantitatives continues
Classification des variables statistiques

Classification des variables statistiques

Question : A partir de cette figure, classer toutes les variables du jeu de données nutriage ?

Par défaut, R considère toute variable à variable numérique comme étant quantitative. Pour changer le type d’une variable, vous utiliserez les fonctions suivantes :

  • Pour rendre la la variable qualitative nominale, on utilise pour cela la fonction as.factor().
  • Pour rendre la la variable qualitative ordinale, on utilise la fonction as.ordered().

Question : Pour toutes les variables qualitatives que vous avez identifiées, changer leurs types sous R.

De plus on utilise la fonction levels() pour recoder les modalités d’une variable qualitative. La fonction nlevels() donne le nombre de modalités de cette variable.

Question : Recoder les modalités des variables qualitatives en suivant le fichier explicatif “nutriage.html”.

Présentation synthétique des données

On dispose des mesures d’une ou plusieurs variables pour chacun des N individus. Le tableau donne les variables en colonne et les individus en ligne. Sous R, les données ainsi définies sont dans une structure appelée data.frame.

Tableau des effectifs ou des fréquences d’une variable qualitative

Pour connaître la distribution d’une variable dans notre échantillon, il est plus pratique de représenter un tableau de données individuelles sous une forme plus condensée, par exemple un tableau des effectifs ou des fréquences. On peut le faire sous R grâce à la commande table(). On se servira de la fonction length() pour donner le tableau des fréquences.

Question : Comment les personnes de cet échantillon utilisent les matières grasses pour cuisiner ?

Question : Combien de personnes mangent quotiennement de la viande ?

Tableau de données regroupées en classes d’une variable quantitative

On peut représenter un tableau de données individuelles quantitatives en regroupant les valeurs par intervalle. Par exemple, on peut se servir de la fonction hist() en spécifiant le vecteur des bornes des classes dans son paramètre breaks.

res<-hist(taille,plot=F)
nn<-as.character(res$breaks)
x<-as.table(res$counts)
dimnames(x)<-list(paste(nn[-length(nn)],nn[-1],sep="-"))
x
## 140-145 145-150 150-155 155-160 160-165 165-170 170-175 175-180 180-185 
##       1       7      37      50      46      31      27      17       4 
## 185-190 
##       6

Question : Combien y-a-t-il d’individus dont la taille est dans l’intervalle ]155,160] ?

Tableaux croisant deux variables qualitatives

Tableau de contingence

On peut utiliser la fonction table() pour obtenir le tableau de contingence de deux variables

matable<-table(sexe,situation)
matable
##     situation
## sexe  1  2  3
##    1 20 63  2
##    2 78 56  7

Question : Dans cet échantillon de 226 individus, quel est le pourcentage d’hommes vivant en couple ?

On peut ajouter les marges en utilisant la fonction addmargins().

matable_complete <- addmargins(matable)
matable_complete
##      situation
## sexe    1   2   3 Sum
##   1    20  63   2  85
##   2    78  56   7 141
##   Sum  98 119   9 226

Question : Parmi les hommes, quel est le pourcentage d’homme vivant en couple ?

Résumés numériques

Tous les exemples donnés seront effectués sur la variable taille. Les résumés numériques ne peuvent être calculés en présence de données manquantes (NA). Si cela est nécessaire, il est possible d’utiliser la fonction na.omit() pour les retirer lors du calcul.

x<-na.omit(taille)

Résumés de position d’une distribution d’une variable quantitative

La médiane

La médiane d’une série statistique est la valeur \(m_e\) de la variable \(X\) qui partage cette série statistique en deux parties (inférieure et supérieure à \(m_e\)) de même effectif. Cette quantité ne se calcule pas sur des variables purement qualitatives.

La fonction R est median() et s’applique uniquement sur des valeurs numériques.

median(taille)
## [1] 163

Question : Combien d’invidus mesurent strictement moins que la médiane et combien mesurent strictement plus que la médiane ?

La moyenne

Elle se calcule uniquement sur des variables quantitatives via la fonction mean().

mean(taille)
## [1] 163.9602

Question : Quelle est la moyenne de la variable taille ? La comparer à la médiane.

Les fractiles

Le fractile d’ordre p (0<p<1) est la valeur \(q_p\) qui coupe l’échantillon en deux portions, l’une ayant un nombre d’éléments (inférieurs à \(q_p\)) égal à \(p\%\) du nombre total d’éléments et l’autre à \((1-p)\%\) étant supérieurs à \(q_p\). Il ne se calcule pas pour des variables purement qualitatives. Si on prend \(p=0.5\), on retrouve la définition de la médiane.

En R, la fonction quantile() (avec le paramètre probs) permet de donner les fractiles de la variable.

quantile(taille,probs=c(0.1,0.25,0.77))
## 10% 25% 77% 
## 153 157 171

En créant 3 vecteurs, vous donnerez 3 sorties pour la variable taille :

  • 1er et 9ème déciles
  • 1er, 2ème et 3ème quartiles
  • tous les déciles

La fonction summary() appliquée sur un vecteur de données quantitatives permet de calculer le minimum, le maximum, la moyenne et les trois quartiles.

summary(age)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   65.00   70.00   74.00   74.48   78.00   91.00

Question : Donner les principaux résumés numériques pour la variable age.

Résumé de dispersion autour de la moyenne d’une distribution

Ces résumés peuvent être calculés uniquement pour des variables quantitatives. Les principales sont :

  • Variance \(\sigma^2\) de la population. Attention, la fonction var() du logiciel R renvoie une estimation non biaisée de la variance.
  • l’écart type est la racine carrée de la variance.
  • Coefficient de variation \(c_v=\frac{\sigma}{\mu}\)

Reprogrammer les fonctions variance, écart-type, et coefficient de variation d’une population (qu’on nommera var.pop, sd.pop et co.pop).