Introduction à R

L’objet de ce chapitre est de nous familiariser avec le logiciel R ainsi qu’avec l’interface RStudio
et d’illustrer les définitions et résultats des cours de probabilités et statistique. Ce n’est en aucun
cas un cours de programmation. L’interprétation des sorties est privilégiée.
R est un langage de programmation puissant et un environnement pour la statistique computa-
tionnelle et la visualisation graphique de données, avec beaucoup de fonctions de  base  et de
librairies/packages complémentaires. RStudio est un environnement de développement (IDE)
dédié à R qui est multiplateforme (Linux, Windows, Mac). Cet environnement permet de tra-
vailler avec R et ses graphiques de façon plus interactive.
Après avoir installé R et RStudio, on manipulera la boı̂te à outils R, on calculera des probabilités
(les confrontant au calcul théorique), on simulera des v.a. discrètes et continues, on illustrera
la Loi des Grands Nombres, le Théorème Central Limite... puis l’on fera des statistiques des-
criptives (représentation de données, méthode de regression, analyse univariée, bivariée...).

0.1 Installation, références

Installation : R et RStudio sont deux logiciels libres et gratuits, disponibles sur les systèmes
d’exploitation les plus courants. Pour les télécharger, il suffit d’aller aux adresses :
http ://cran.r-project.org/
http://www.rstudio.org
Il faut installer R avant d’installer RStudio.
Si vous rencontrez des difficultés, il y a des vidéos d’aide à l’installation sur youtube.

Bibliographie :
Il y a beaucoup de références sur internet (Google, youtube...)
Introduction la programmation en R, V. Goulet, qu’on peut télécharger gratuitement sur le
site du CRAN.
Statistiques avec R, Pierre-André Cornillon et al., 2012.
Le logiciel R, Pierre Lafaye de Micheaux, Rémy Drouilhet et Benoı̂t Liquet, 2014.

1
0.2 Premiers pas avec RStudio
Après avoir installé R et RStudio, l’application RStudio se lance en cliquant sur l’icône bleue
contenant un R en blanc au milieu. À son ouverture, l’interface présente 4 fenêtres :

– en bas, à gauche, la fenêtre  console  R qui permet d’utiliser R en mode interactif, à l’invite
>. On y tape et exécute les commandes.
Tapez >3+4 puis appuyez sur la touche Entrée et observez le résultat.
– en haut, à gauche, la fenêtre éditeur de texte. On peut y éditer des commandes qui seront
exécutées dans la fenêtre en dessous après avoir cliqué sur Run.
Par exemple, tapez sur la première ligne 3+4 puis cliquez sur Run et observez le résultat dans
la fenêtre en-dessous (et celle d’en haut à droite).
– en haut, à droite, la fenêtre Workspace/History où apparaitront les variables et les fonctions
qui ont été définies. La sous-fenêtre Workspace (Outils de l’Espace de Travail) contient toutes
les variables et fonctions que vous avez définies actuellement présentes dans l’espace de travail,
c’est à dire que R connaı̂t et que vous pouvez appeler. La sous-fenêtre History garde la liste
des commandes qui ont été exécutées par R.
– en bas à droite : la fenêtre de navigation qui permet d’accéder à divers outils : aux fichiers, aux
graphiques (Plots) produits par R, aux bibliothèques qui permettent d’enrichir R en nouvelles
fonctions, et à l’aide (Help).

Le manuel de référence de R est disponible directement sous R : il suffit de taper le nom de la

commande sur laquelle on veut des éclaircissements.
Par exemple, pour recevoir de l’aide sur une fonction spécifique, par exemple plot, faire
> help(plot) ou
> ?plot.
On peut aussi faire une recherche sur Google. Il y a une communaute active et beaucoup d’aide
en ligne.

Attention :
– RStudio distingue entre les lettres majuscules et minuscules.
– Deux commandes successives doivent être séparées par un point virgule, ou être sur deux
lignes distinctes.
– Les prédicats élémentaires sont ==, !=, <=, <, >=, et >. ( ! pour non)

0.3 Premières commandes R(Studio)

0.3.1 Objets de base
Un objet est désigné par son nom. Les objets de base sont :

2
– les vecteurs et matrices ;
– les  data frames  ;
– les listes.
Le contenu des objets peut être de différents types, les principaux étant :
– numérique (entier, réel, complexe) ;
– chaı̂ne de caractères ;
– booléen : TRUE, FALSE, NA (Not Available).

0.3.2 RStudio comme calculatrice

Depuis le prompt de R, >, vous pouvez exécuter toutes les commandes déjà disponibles et même
définir vos propres fonctions, mais avant d’en arriver là nous allons d’abord nous familiariser
avec les commandes de bases de R.
R peut être utilisé pour réaliser des opérations élémentaires : calculs de sommes, d’integrales,
calcul vectoriel, matriciel...
> 1+1 # donne la valeur de 1 + 1
[1] 2
Tout ce qui est tapé après # est juste un commentaire et ne sera pas interprété par R.
> pi # donne la valeur de π
√
> sqrt(2) # donne la valeur de 2 ; (sqrt pour  square root  : racine carrée )
> choose(4,2) # c’est la combinaison C42
[1] 6
> factorial(3) # c’est factorielle 3 = 3 !
[1] 6
> log(10) # donne la valeur du logarithme népérien de 10 ;
[1] 2.302585
Remarque : un nombre décimal est noté avec un point plutôt qu’avec une virgule (comme en
français).

0.3.3 Variables
Une variable est un nom donné à une valeur ou à un objet. C’est un outil essentiel pour accéder
aux données stockées dans la mémoire de R. Donner une valeur à une variable s’appelle affecter
la valeur à la variable.
La flèche < −, obtenue en tapant successivement le signe strictement inférieur < puis le signe
moins −, permet d’affecter un contenu à une variable. Par exemple :
> x <- 10 # cela veut dire x=10 : on affecte la valeur 10 à x
> x # on demande la valeur de x
[1] 10

3
Pour augmenter la valeur de x, on fait
> x <- x+5
> x # on demande la nouvelle valeur de x
[1] 15
> rm(x) # efface la valeur de x.
Une variable peut contenir un objet plus complexe comme un vecteur, une liste ou un data
frame.

0.3.4 Vecteurs
Un vecteur est une collection ordonnée d’objets du même type (valeurs numériques, chaı̂nes de
caractères...). Pour travailler avec R, tout est vecteur, même les scalaires qui sont considérés
comme des vecteurs de taille 1. Lorsque la réponse de R est
Un vecteur peut être à valeurs alphanumériques
>  ab 
[1]  ab 
ou à valeurs booléennes
> 0<1
[1] TRUE
> 0==1
[1] FALSE
• Pour créer un vecteur, on utilise la fonction c(), c comme concaténer.
> v1 <- c(1,2,4)
> v2 <- c(’’Anne’’, ’’Luc’’, ’’Tom’’)
Les commandes ci-dessus créent les vecteurs (1, 2, 4) et (”Anne”, ”Luc”, ”Tom”).
On peut aussi construire un vecteur numérique en utilisant la commande m:n.
> 1:20 # 1:20 veut dire la suite des entiers successifs de 1 à 20
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
> 5:-5
[1] 5 4 3 2 1 0 -1 -2 -3 -4 -5
Des vecteurs (ou suite) de nombres entiers successifs peuvent être créés de la manière suivante :
> v3 <- 1:5
> v3
[1] 1 2 3 4 5
> v4 <- 6:9
> v4
[1] 6 7 8 9
La longueur d’un vecteur est donnée par la fonction length()
On peut additionner deux vecteurs de même longueur, les multiplier coordonnée par coordonnée,
multiplier un vecteur par un scalaire...

4
> 1:3 + 1:3
[1] 2 4 6
> 1:3 + 3
[1] 4 5 6
> 1:3 * 1:3
[1] 1 4 9
> 1:3 * 3
[1] 3 6 9
• seq( ) : cette fonction permet de créer des suites arithmétiques
> seq(from = 0, to =9, by =3) # c’est la suite arithmétique de raison 3, partant de 0
(et allant jusqu’à 9).
[1] 0 3 6 9
> seq(0,1,length=11) # c’est la suite de nombres allant de 0 à 1, équidistants et compor-
tant 11 termes.
[1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
> seq(0,1,by=0.2) # c’est la suite arithmétique partant de 0 et de raison 0.2

• rep( ) : cette fonction permet de construire des suites (de nombres, de lettres, de booléens,...)
par répétition d’un même vecteur
> rep(1,5) # on répète 5 fois le chiffre 1
[1] 1 1 1 1 1
> rep(1:4,2) # on répète 2 fois les chiffres de 1 à 4
[1] 1 2 3 4 1 2 3 4
> rep(1:4, length=10) # on répète les chiffres de 1 à 4 jusqu’à avoir 10 chiffres au total
[1] 1 2 3 4 1 2 3 4 1 2
> rep(1:4, c(2,1,2,1)) # on écrit les chiffres de 1 à 4 en faisant 2 fois le 1er, 1 fois le
2ème, 2 fois le 3ème et 1 fois le 4ème
[1] 1 1 2 3 3 4

> x <- c(1,4)

> rep(x,3) # on répète 3 fois les chiffres 1 4
[1] 1 4 1 4 1 4
• [ ] Pour accéder à une coordonnée d’un vecteur, on utilise les crochets [ ]
> x <- c(1,4)
> x[3] # on demande la 3ème coordonnée de x
[1] 3
> x[x>4]] # obtenir, à partir de x, un nouveau vecteur ne contenant que les composantes
>4
> x[-2] # obtenir un vecteur y qui n’est autre que x auquel on a enlevé la 2ème coordonnée.
[1] 1 3 4 5
• sum : avec cette fonction, on peut faire la somme des coordonnées d’un vecteur. Par exemple,

5
> sum(1:5) # calcule la somme des entiers de 1 à 5
[1] 15
• cumsum(x) : cette fonction effectue la somme cumulée des coordonnées du vecteur x
> cumsum(1:5) # c’est 1 1+2 1+2+3 1+2+3+4 et 1+2+3+4+5
[1] 1 3 6 10 15

0.3.5 Matrices
On peut créer une matrice en R grâce à la commande matrix :
> M = matrix(data=0,nr=10,nc=5) # C’est une matrice dont tous les termes sont nuls, à 10
lignes et 5 colonnes.
nc ou ncol : nombre de colonnes
nr ou nrow : nombre de lignes
On accède à ses éléments grâce au crochet
> M[3,4]
[1] 0
On peut également créer une matrice à partir de ses vecteurs colonnes
> x1=c(1,2,3)
> x2=c(3,4,5)
> matrix(c(x1,x2),3,2)
C’est la matrice à 3 lignes et 2 colonnes, obtenue à partir des vecteurs x1 et x2 définis ci-dessus.

0.4 Lois de probabilité

R est un logiciel de statistique qui permet de manipuler simplement les lois de probabilité
classiques (loi binomiale, loi géométrique, loi normale, etc...). Pour chacune de ces lois, il est
possible d’obtenir, au moyen des préfixes, des fonctions qu’on a déjà croisées au cours de
probabilités.
rloi pour simulation ou tirages aléatoires de la loi
d les probabilités discrètes ou la fonction densité de la loi
p la fonction de répartition de la loi
q les quantiles de la loi.
Par exemple,
> rpois(10, 2.5)
renvoie dix nombres issus de tirages aléatoires (indépendants) suivant la loi Poisson de pa-
ramètre λ = 2.5.
> rnorm(10, mean=0, sd=2)
renvoie 10 tirages indépendants de la loi normale centrée et d’écart-type σ = 2.
mean désigne la moyenne
sd désigne l’écart-type ou (standard deviation)

6
> dpois(4, 2.5)
4
renvoie la valeur de IP(X = 4), c’est à dire e−2.5 2.5
4!
.
> dbinom(2, 8, 0.1)
renvoie IP(X = 2) pour X suivant la loi B(8, 0.1).
donc
> dbinom(x, 1, 0.1) renvoie IP(X = x) pour X de loi de Bernoulli de paramètre 0.1.
> dbinom(c(1,4), 8, 0.1)
renvoie IP(X = 1) + IP(X = 4) pour X suivant la loi B(8, 0.1).
> dexp(2, lambda=3)
renvoie f (2) où f (x) = 3e−3x (x > 0).
> dnorm(x, mean=0, sd=1)
2
renvoie la valeur fZ (x) = √12π e−x /2 .
> ppois(4, 2.5)
renvoie la valeur de FX (4) = IP(X ≤ 4) où X suit la loi de Poisson de paramètre 2.5.
> pnorm(x, mean=10, sd=1)
renvoie la probabilité IP(X ≤ x) où X suit la loi N (10, 1).
> pnorm(x, mean=0, sd=1) n’est autre que IP(Z ≤ x) donnée par la table de la loi normale.
Parmi les lois connues :
binom pour la loi binomiale
pois pour la loi de Poisson
geom pour la loi géométrique
exp pour la loi exponentielle
norm pour la loi normale
unif pour la loi uniforme continue
Exercice : Le nombre de voitures qui passent par heure à une petite route suit une loi de
Poisson de moyenne 5.
1) Calculer la probabilité qu’aucune voiture ne passe pendant une heure.
> dpois(0, 5)
[1] 0.006737847
2) Calculer la probabilité qu’au moins 3 voitures passent.
C’est IP(X ≥ 3) = 1 − IP(X ≤ 2) :
> 1-ppois(2, 5).
[1] 0.875348
Exercice : (re)faire l’exercice 47 de l’envoi 3.

0.4.1 Représentation graphique

Pour représenter graphiquement la loi d’une v.a. discrète, on utilise la commande
– > plot(x) pour une série de points

7
– > barplot(x) pour un graphique en barres
– > pie(table(x)) (pie = tarte en anglais) pour un diagramme en camembert
Par exemple :
> x=0:5
> plot(dpois(x,1)) (pour les points)
donne la distribution de probabilité (ou loi) d’une variable de Poisson de paramètre 1 entre
x=0 et x=5.
> barplot(dpois(x,1)) (idem mais avec des barres)

Variante : la commande plot accepte plusieurs options

> plot(x, dpois(x,1), xlim=c(0,6), ylim=c(0,0.5))
donne la distribution ci-dessus avec x entre 0 et 6 et y entre 0 et 0.5.
xlim et ylim sont les limites des axes des x et y
on peut aussi ajouter un type pour le type de graphique
’l’ pour les lignes
’s’ pour  en escalier 
’p’ pour les points
’h’ pour traits verticaux
Essayez par exemple
> plot(dpois(x,1), xlim=c(0,6), ylim=c(0,0.5), type=’h’)
ou ’s’... modifier xlim et ylim...

> curve(dnorm, xlim=c(-4,4), ylim=c(0,0.5))

(curve ou plot) donne le graphe de la fonction densité de la loi N (0, 1).
> curve(dnorm(x, 2, 1), xlim=c(-4,4), ylim=c(0,0.3))
donne le graphe de la fonction densité de la loi N (2, 1). Dans l’exemple ci-dessus, il était
sous-entendu qu’on prenait la loi N (0, 1).
Prenez diverses valeurs de σ et voyez comment évolue l’allure de la courbe.
Question : comment représenter la fonction de répartition (sans recourir à stepfun) ?
plot(ppois(x,1), type=’s’)
est celui de la loi de Poisson de paramètre 1.
Exercice :
1) Essayez avec d’autres lois.
2) Comparer les courbes des fonctions de répartition d’une loi binomiale B(100, 0.01) et d’une
loi de Poisson de paramètre 1 (= 100 × 0.01).
3) Comparer > dbinom(x, 100, 0.01) et > dpois(x, 1) pour x allant par exemple de 0 à
10.
4) Observation : lien avec un théorème limite...
5) Tapez (dans la fenêtre éditeur, puis sélectionnez les 2 lignes ci-dessous et cliquez sur run) :

8
plot(-4:4, dbinom(-4:4, 100, 0.01), type=’h’, ylim=c(0,0.4))
curve(dnorm(x,1, 0.99), -4, 4, col=3, add=TRUE)
add TRUE veut dire : sur le même graphique
Que dit le résultat théorique ?
6) Tapez
plot(0:50, pbinom(0:50, 50, 0.4))
curve(pnorm(x, 20, sqrt(12)), 0, 50, col = "red", add = TRUE)
Cela compare deux courbes sur un même graphique : la courbe de la fonction de répartition
d’une loi binomiale de paramètres 50 et 0.4 (le cours nous dit√ qu’on peut approcher cette loi
par une loi normale N (20, σ 2 = 12)) et celle de la loi N (20, 12).

0.5 Simulation
0.5.1 La commande sample
• L’utilisation de base est sample(x) où x est un vecteur numérique ou chaı̂ne de caractères.
sample(x) renvoie un vecteur dont les éléments correspondent au tirage d’un élément de x sans
remise. Cela revient à permuter aléatoirement les éléments de x.
> sample(1:4) # c’est une permutation des coordonnées du vecteur
[1] 3 2 1 4
ou encore
> x=1:5
> sample(x)
[1] 5 1 3 4 2
> sample(c(1,2,4)) # c’est une permulation des coordonnées du vecteur (1,2,4)
[1] 2 4 1

Avec size : size veut dire nombre de tirages effectués. Par défaut, ce sera la longueur de x.
> sample(1:4, size= 1) # faire un tirage entre 1 et 4
[1] 3
sample(1:4, size=2) # faire 2 tirages entre 1 et 4
[1] 2 4
S’il n’y a que 2 arguments dans sample, alors on peut ne pas écrire size, c’est implicite.
> sample(1:4, 1)
est la même commande que
> sample(1:4, size= 1)

> sample(1:3, size = 2, replace = TRUE)

replace veut dire que le tirage a lieu avec remise.
Donc on effectue 2 tirages avec remise de nombres entre 1 et 3.
> sample(1:3, size = 2, replace = TRUE, prob = c(0.25, 0.2, o.55))

9
cela veut dire que l’on effectue 2 tirages avec remise selon la loi de probabilité (0.25, 0.2, 0.55).
Si l’on ne spécifie pas cette loi, alors la loi uniforme est sous-entendue.
Exercice : Écrire une commande qui renvoie le résultat
– d’un lancer de dé à 6 faces :
sample(1:6, 1)
– de 2 lancers de dé à 6 faces :
sample(1:6, 2)
– de la somme des résultats d’un lancer de 2 dés :
x<- sample(1:6, 2)
sum(x)

0.5.2 Simuler avec des lois prédéfinies

Pour simuler des lois implémentées dans R, il faut utiliser rloi avec un ou plusieurs paramètres.
> rpois(5, 2)
simule n = 5 variables aléatoires indépendantes suivant la loi de Poisson de paramètre 2.
x<- rpois(5,2)
renvoie 5 valeurs de la loi de P(2).
> hist(x)
représente l’histogramme
variante : > hist(x, breaks=5) avec 5 classes aux amplitudes identiques
> x<- rnorm(10, 1, 2)
> x
renvoie 10 nombres issus de 10 tirages indépendants de la loi normale N (1, 2).
Faites
> hist(x)
Comment évolue cet histogramme lorsque le nombre de tirages croı̂t ?
Exercice : 1) Simuler n = 100 v.a. de loi de Poisson de paramètre 1.
x<- rpois(100, 1)
2) Calculer la somme des Xi divisée par 100
y<- sum(x)/100
y
3) Vérifier que le résultat est proche de 1, qui est la moyenne de la loi de Poisson.
4) Essayez d’autres variables... augmentez n.. C’est la loi des grands nombres.

10