Objectif
Les objectifs de cette séance sont
Le logiciel R sous licence GNU est facile à installer à partir de la page du CRAN (ou d’un site miroir). Le CRAN contient toutes les ressources nécessaires à l’utilisateur de R, débutant ou expérimenté : fichiers d’installation, mises à jour, librairies, FAQ, newsletter, documentation… R est un logiciel très utilisé dans la communauté statistique.
Dans sa structure, R est un langage de programmation d’une syntaxe voisine à celle du langage C et capable de manipuler des objets complexes sous forme de matrice, scalaire, vecteur, liste, facteur et aussi data frame. Il dispose également d’une très riche librairie de quasiment toutes les procédures et méthodes statistiques de la littérature. Plus précisément, toutes les recherches récentes sont d’abord développées et diffusées à l’aide de ce logiciel par la communauté scientifique.
Nous allons utiliser RStudio durant les TP d’Analyse de Données. RStudio n’est pas qu’une interface graphique pour R, il s’agit d’un environnement de développement intégré, proposant des outils et facilite l’écriture de scripts et l’utilisation de R. La version gratuite de RStudio étant déjà très riche en fonctionnalités, elle est suffisante pour les enseignements. Elle est disponible pour Linux, Windows et MacOS.
Sur les ordinateurs en salle TP, sous linux,
rstudioSi vous souhaitez travailler sur votre propre ordinateur, installez tout d’abord la dernière version du logiciel R (voir CRAN) puis installez la version gratuite de Rstudio adaptée à votre OS.
A chaque ouverture de RStudio, l’écran est découpé en quatre grandes zones :
En bas à gauche c’est la Console, on peut y lire
au lancement la version de R que RStudio a chargé. Après le texte
d’entrée, la ligne commence par > qui est l’invite de
commande. RStudio est prêt à recevoir votre première commande. On peut
se servir de R comme d’une calculatrice. Vous pouvez par exemple taper
> 2+3 et taper Entrée. Le résultat apparait
alors dans la console.
En haut à droite, on peut voir dans Environnement la liste des objets et fonctions créés au fur et à mesure du travail. On a également accès à l’historique des commandes dans History.
En bas à droite, on trouve plusieurs onglets :
En haut à gauche, c’est la zone d’Edition pour gérer les scripts, les executer, ….
Lorsque vous quittez RStudio, on vous demande si vous souhaiter
sauvegarder l’environnement de travail. Si vous y répondez
favorablement, un fichier de sauvegarde .RData est
enregistré dans le répertoire courant.
En allant dans File -> New File ou en cliquant sur la
flèche à côté de l’icone de New File (en haut à gauche),
RStudio propose de nombreux types de document. Vous pouvez noter que
l’on peut utiliser RStudio également pour faire du python, du C++, …
Nous allons ici ne parler que de quelques types de fichiers que l’on
utilisera par la suite.
Pour créer un script R, il suffit de sélectionner
R Script. Ce script peut être enregistré à tout moment dans
un fichier avec l’extension ” .R” (ex. monScript.R) dans le
répertoire courant en cliquant sur l’icône de disquette ou par
File->Save. Vous pouvez l’ouvrir à tout moment grâce au
menu File –> Open file..., à l’icône dossier ou en
double cliquant sur le fichier monScript.R. Il est également
possible d’executer un script directement depuis la console grâce à la
commande source("monScript.R").
On peut également créer des documents de type rapport, slides, … contenant du texte, du code, des images, des formules mathématiques en latex, ….
à l’aide de RMarkdown en sélectionnant
R markdown .... Le document créé sera sauvegardé avec
l’extension ” .Rmd”. On reviendra plus précisément sur les possibilités
offertes par Rmarkdown et les commandes principales pour débuter la
rédaction d’un rapport dans la section suivante.
à l’aide de quarto en sélectionnant
Quarto Document ... ou Quarto Presentation ...
pour la création de présentation, rapports, … Par exemple les slides du
cours d’Analyse de Données ont été générés en quarto. La syntaxe est
assez proche de celle de Rmarkdown.
Pour pouvoir récupérer des données, maîtriser la sauvegarde des
scripts, des résultats, … il est important de connaitre le répertoire de
travail c’est-à-dire le répertoire sous lequel les divers résultats
seront sauvegardés par défaut. Ce dernier s’obtient à l’aide de la
commande > getwd().
Pour changer de répertoire de travail, on peut
setwd() dans la Console. A noter
que R ne reconnaît que le caractère “/” pour spécifier le chemin d’accès
d’un répertoire (même sous Windows).Session -> Set Working Directory -> Choose Directory.Exercice :
Créer un dossier de travail pour ce TP dans votre home (en dehors de RStudio!) Dans RStudio, placez-vous dans ce dossier de travail pour le TP.
R est un logiciel libre, il s’enrichit grâce au développement de librairies par la communauté. La plupart des extensions sont développées et maintenues par la communauté des utilisateurs de R, et diffusées via le CRAN (Comprehensive R Archive Network). On peut également trouver des packages déposés sur github par exemple.
A la première ouverture de RStudio sur les ordinateurs de salle TP,
un dossier R/libs est créé dans votre home
pour l’installation des librairies.
Pour installer une librairie disponible sur le CRAN, vous avez plusieurs manières de le faire, dont
Tools-> Install Packages ... ,
sélectionner un site miroir du CRAN et demander la librairie
souhaitéeinstall.packages() directement
dans la console en précisant la librairie souhaitéeToutes les librairies ne sont pas chargées automatiquement au
lancement de R. Pour charger une librairie, on utilise la commande
library().
Exercice :
- Installez la librairie corrplot
- Chargez la librairie corrplot
On peut à tout moment faire appel à l’aide intégrée de R (et surtout
avant d’appeler l’enseignant-e !) pour avoir les détails comme les
arguments d’une fonction. On peut accéder à l’aide pour une fonction (ex
pour la fonction plot) en passant le nom de la fonction dans
help() (ex > help(plot)) ou en utilisant le
raccourci > ?plot. Ces deux commandes permettent
d’afficher une page de description (en anglais) de la fonction, ses
paramètres, son résultat, d’exemples, … Dans RStudio, les pages d’aide
en ligne s’ouvriront par défaut dans la zone en bas à droite, sous
l’onglet Help. Un clic sur l’icône en forme de maison
vous affichera la page d’accueil de l’aide. Vous pouvez aussi taper
directement le nom de la fonction recherchée dans la zone de recherche
dans l’onglet Help.
Exercice :
Accédez à l’aide de la fonction
rnorm
L’extension Rmarkdown permet de créer des
documents dans différents formats (html, pdf, docx, slides, …) qui
contiennent du texte, du code (en R mais pas que!), les résultats, … Par
exemple, les sujets de TP de ce cours sont rédigés en Rmarkdown.
Vous devrez également rédiger le rapport de votre projet en Rmarkdown.
Nous allons donner ici des éléments de base pour la création de
documents avec Rmarkdown. Pour plus de détails, vous pouvez consulter
l’aide mémoire de Rmarkdown (accessible via
Help -> Cheatsheets -> Rmarkdown Cheat Sheet) et le
livre en ligne R Markdown: The Definitive Guide de Y. Xie, J. J.
Allaire, G. Grolemund.
Un document Rmarkdown est un fichier enregistré avec l’extension
.Rmd. Pour créer un nouveau document, allez dans
File-> NewFile-> Rmarkdown... (ou cliquez sur l’icone
nouveau document et choisissez Rmarkdown).
Exercice :
Créez un nouveau document Rmarkdown au format pdf avec le titre et l’auteur de votre choix. Vous pouvez constater qu’un nouveau document prérempli vient de s’ouvrir dans RStudio. Nous allons maintenant détailler le contenu de ce document.
Un document Rmarkdown débute toujours par l’en-tête
qui est encadré par 3 tirets ---. Cet en-tête contient au
moins les métadonnées du document suivantes : le titre, l’auteur, la
date, le format de sortie (output). On peut préciser des
options au document final en ajoutant des sous-options à droite du
output. Il est également possible de spécifier des options
différentes selon les formats. Voici une liste avec quelques éléments
:
number_section : true permet de numéroter les
sectionshighlight permet de spécifier le style syntaxique (par
ex default, tango, pygments,
kate, …).cssfig_width, fig_height,
fig_caption, dev, ….bib avec l’option bibliographyOn a ensuite le corps du document qui peut contenir
$ ... $)Vous pouvez compiler à tout moment le document Rmarkdown en cliquant
sur le bouton Knit. Un onglet R Markdown s’ouvre alors dans
la même zone que l’onglet Console pour indiquer la progression
de la compilation et les messages d’erreur éventuels. Une fois la
compilation effectuée, le document obtenu s’ouvre et vous pouvez admirer
le rendu.
Remarque: Pour la compilation d’un document en pdf, il est nécessaire d’avoir installé un compilateur de Latex sur son ordinateur.
Exercice :
Modifiez les options dans l’en-tête de votre fichier Rmarkdown puis compilez le document pour constater l’impact sur le document généré.
Le texte d’un document Rmarkdown est régi par le langage markdown.
Regardez les quelques éléments de syntaxe et de mise en forme disponible
ici ou consulter l’aide mémoire de Rmarkdown
(accessible via
Help -> Cheatsheets -> Rmarkdown Cheat Sheet).
Remarque: Si vous avez organisé votre document avec
des sections / sous-sections en faisant débuter une ligne par un ou
plusieurs #, alors vous pouvez cliquer sur l’icone
Outline à droite de la barre d’outils associée au fichier R
Markdown pour visualiser la table des matières générée automatiquement
qui vous permet de naviguer facilement dans le document.
Pour insérer du code dans un document Rmarkdown, on utilise des blocs
appelés chunk. Pour cela, il suffit de cliquer sur
l’icone d’insertion d’un chunk dans la barre d’outils d’un document
Rmarkdown. Il est possible d’insérer un chunk de code R mais pas
seulement (par exemple on peut insérer du code Python). Pour du code R,
un chunk de la forme \(\textrm{```{r} ....
```}\) s’insère alors dans le document. On peut alors saisir du
code R dans ce chunk. On peut ajouter un nom à un bloc et préciser des
options dans les accolades {r nomdubloc, ....}, par
exemple
Ces options peuvent être modifiées manuellement ou en utilisant l’interface graphique (en cliquant sur l’icone d’engrenage situé en haut à droite de chaque bloc).
Exercice :
- Ajoutez
# Titre 1avant## RMarkdown- Modifiez
{r cars}en{r cars, eval=F}- Compilez le document pour voir les différences
De manière générale, il est recommandé de
Pour la suite du TP, récupérez sur moodle le document “TP1-InitR.Rmd”, sauvegardez-le dans votre dossier de travail et ouvre-le dans RStudio. C’est le document .Rmd qui a généré cet énoncé de TP et que vous allez compléter dans la suite.
Sous R, les éléments de base sont des objets : des données (vecteurs,
matrices, …), des fonctions, des graphiques, … Ces objets se
différencient par leur mode décrivant leur contenu, et leur classe
décrivant leur structure. Les classes d’objets les plus courantes sont :
vector, matrix, array, factor, data.frame, list. On
peut avoir des vecteurs, matrices, tableaux, … de mode
null (objet vide), logical (TRUE,
FALSE, NA), numeric, complex,
character. Par contre les listes et les tableaux
peuvent être composés d’éléments hétérogènes. On utilise la commande
class() pour connaître la classe d’un objet et
str()pour connaitre la nature des éléments composant
l’objet.
Nous allons dans ce TP présenter certains de ces objets, les opérations et manipulations basiques que l’on peut faire, …
Remarque : On stocke un objet dans une variable a à l’aide
de a<- ... ou a= .... Pour lister les
variables actuellement disponibles dans la session de travail, on
utilise la fonction ls(). Pour effacer une ou plusieurs
variables, on utilise la fonction rm(). La commande
rm(list=ls()) permet d’effacer toutes les variables en
mémoire.
Les opérations élémentaires sur les scalaires sont
*,-, +, /,
^.
Executez les commandes suivantes. Vous chercherez en particulier à bien identifier les différents types de données :
2 + 2
exp(10)
a = log(2)
a
b = cos(10)
b
a - b
a * b
d <- 2 < 3
d
dd <- FALSE
dd - d
dd + d
e <- "toto"
class(e)
str(e)is.xxx()/as.xxx()Pour tester si un objet obj est de type xxx, on
utilise la commande is.xxx(obj). On peut aussi contraindre
si possible l’objet obj au type xxx avec la commande
as.xxx(obj).
a = 4.3
is.numeric(a)[1] TRUEis.complex(a)[1] FALSEis.character(a)[1] FALSEas.character(a)[1] "4.3"b <- "toto"
is.numeric(b)[1] FALSEas.list(b)[[1]]
[1] "toto"Pour obtenir des valeurs arrondies sur des valeurs numériques, vous
pouvez utiliser l’une des commandes suivantes round(),
ceiling(), floor(), trunc() ou
signif() (voir l’aide ?round). Comparez les
codes suivantes:
a = 1.3579
floor(a)[1] 1ceiling(a)[1] 2round(a, digits = 2)[1] 1.36signif(a, digits = 2)[1] 1.4is.integer(floor(a))[1] FALSEis.numeric(floor(a))[1] TRUEEn R, un booléen est représenté par TRUE ou FALSE.
Les opérations logiques, <, >,
<=, >=, != (différent),
== (égal) retournent TRUE ou FALSE. On
peut définir plusieurs conditions à remplir avec les opérateurs
& (ET) et | (OU).
Attention, R considère que le booléen FALSE vaut \(0\) et le booléen TRUE vaut \(1\). Il est donc capable d’évaluer
TRUE + 5 bien qu’en toute logique, cela n’a aucun sens!
Voici quelques exemples de manipulation des booléens pour comprendre :
a = 3
b = 6
a <= b[1] TRUEa != b[1] TRUE(b - 3 == a) & (b >= a)[1] TRUE(b == a) | (b >= a)[1] TRUEUn vecteur est un ensemble ordonné d’éléments de même nature
(numérique, logique ou alphanumérique). La création d’un vecteur peut se
faire par la commande c(e1,e2,...). On peut également
générer une séquence avec la commande seq(a,b,t) où \(a\) est le premier terme, le dernier terme
est \(\leq b\) et le pas est \(t\). Pour créer un vecteur constitué de
l’élément \(x\) répété \(n\) fois, on utilise la commande
rep(x,n).
On donne ici quelques exemples à tester sous R pour vous familiariser
avec les vecteurs. En particulier, vous pouvez découvrir des fonctions
utiles avec les vecteurs comme length(),
sum(), sort(), … , les opérations usuelles,
l’extraction d’éléments d’un vecteur, …
c(...)d <- c(2, 3, 5, 8, 4, 6)
d[1] 2 3 5 8 4 6is.vector(d)[1] TRUEc(2, 5, "toto")[1] "2" "5" "toto"1:10 [1] 1 2 3 4 5 6 7 8 9 10seq(...)seq(1, 10) [1] 1 2 3 4 5 6 7 8 9 10seq(from = 1, to = 20, by = 2) [1] 1 3 5 7 9 11 13 15 17 19seq(1, 20, by = 5)[1] 1 6 11 16seq(1, 20, length = 5)[1] 1.00 5.75 10.50 15.25 20.00rep(...)rep(5, times = 10) [1] 5 5 5 5 5 5 5 5 5 5rep(c(1, 2), 3)[1] 1 2 1 2 1 2rep(c(1, 2), each = 3)[1] 1 1 1 2 2 2d[1] 2 3 5 8 4 6d[2][1] 3d[2:3][1] 3 5d[c(1, 3, 6)][1] 2 5 6d[-3][1] 2 3 8 4 6d[-(1:2)][1] 5 8 4 6Additionner ou soustraire un scalaire d’un vecteur
d + 4[1] 6 7 9 12 8 10d - 4[1] -2 -1 1 4 0 2Multiplier ou diviser un vecteur par un scalaire
2 * d[1] 4 6 10 16 8 12d/3[1] 0.6666667 1.0000000 1.6666667 2.6666667 1.3333333 2.0000000Multiplier/ diviser deux vecteurs terme à terme
e <- rep(2, 6)
d * e[1] 4 6 10 16 8 12d/e[1] 1.0 1.5 2.5 4.0 2.0 3.0d = c(2, 3, 5, 8, 4, 6)
d[1] 2 3 5 8 4 6Longueur d’un vecteur
length(d)[1] 6Somme des termes d’un vecteur numérique
sum(d)[1] 28Somme des termes cumulés d’un vecteur numérique
cumsum(d)[1] 2 5 10 18 22 28Différence des termes successifs d’un vecteur numérique
diff(d)[1] 1 2 3 -4 2Vérifier si d est un vecteur
is.vector(d)[1] TRUEAutres fonctions intéressantes avec les vecteurs :
abs(), sort(), order(),
which(), …
a <- c(3, -1, 5, 2, -7, 3, 9)
abs(a)[1] 3 1 5 2 7 3 9sort(a)[1] -7 -1 2 3 3 5 9order(a)[1] 5 2 4 1 6 3 7which(a < 0)[1] 2 5On peut appliquer une fonction à tous les éléments d’un vecteur facilement.
cos(a)[1] -0.9899925 0.5403023 0.2836622 -0.4161468 0.7539023 -0.9899925 -0.9111303Construire
- le vecteur \(a\) constitué des entiers pairs jusqu’à 30
- le vecteur \(b\) contenant 6 chiffres compris entre 4 et 30 avec un intervalle constant.
- le vecteur \(c\) contenant la somme des éléments de \(b\), la longueur de \(a\) et 5 fois le chiffre 3.
Extraire du vecteur \(c\) le
- le quatrième élément
- tous les éléments sauf le quatrième
- tous les éléments supérieurs à 10
# A COMPLETER POUR REPONDRE A L'EXERCICEComme les vecteurs, les matrices sont de mode quelconque mais ne
contiennent que des éléments de même nature. Pour créer une matrice, on
utilise la commande matrix(vec,nrow=n,ncol=p) où
vec est le vecteur contenant les éléments de la matrice de
taille \(n\) par \(p\), qui seront rangés en colonne sauf si
l’option byrow=T est utilisée.
On donne ici quelques exemples à tester sous R pour vous familiariser
avec les matrices. En particulier, vous pouvez découvrir des fonctions
utiles avec les matrices comme dim(), t(),
cbind(), rbind()… , les opérations usuelles
dont la différence entre A*B et A%*%B,
l’extraction d’éléments d’une matrice, …
matrix()A = matrix(1:15, ncol = 5)
A [,1] [,2] [,3] [,4] [,5]
[1,] 1 4 7 10 13
[2,] 2 5 8 11 14
[3,] 3 6 9 12 15B = matrix(1:15, nc = 5, byrow = T)
B2 = B
B2[1, 1] = "toto"
B2 [,1] [,2] [,3] [,4] [,5]
[1,] "toto" "2" "3" "4" "5"
[2,] "6" "7" "8" "9" "10"
[3,] "11" "12" "13" "14" "15"rownames(A) = c(paste("ligne", 1:3, sep = ""))
A [,1] [,2] [,3] [,4] [,5]
ligne1 1 4 7 10 13
ligne2 2 5 8 11 14
ligne3 3 6 9 12 15A [,1] [,2] [,3] [,4] [,5]
ligne1 1 4 7 10 13
ligne2 2 5 8 11 14
ligne3 3 6 9 12 15A[1, 3]ligne1
7 A[, 2]ligne1 ligne2 ligne3
4 5 6 A[2, ][1] 2 5 8 11 14A[1:3, c(2, 5)] [,1] [,2]
ligne1 4 13
ligne2 5 14
ligne3 6 15A[1:3, -c(2, 5)] [,1] [,2] [,3]
ligne1 1 7 10
ligne2 2 8 11
ligne3 3 9 12cbind() / rbind()Pour concaténer deux matrices, on peut utiliser les fonctions
rbind() ou cbind().
A [,1] [,2] [,3] [,4] [,5]
ligne1 1 4 7 10 13
ligne2 2 5 8 11 14
ligne3 3 6 9 12 15B [,1] [,2] [,3] [,4] [,5]
[1,] 1 2 3 4 5
[2,] 6 7 8 9 10
[3,] 11 12 13 14 15cbind(A, B) [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
ligne1 1 4 7 10 13 1 2 3 4 5
ligne2 2 5 8 11 14 6 7 8 9 10
ligne3 3 6 9 12 15 11 12 13 14 15rbind(A, B) [,1] [,2] [,3] [,4] [,5]
ligne1 1 4 7 10 13
ligne2 2 5 8 11 14
ligne3 3 6 9 12 15
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15Dimension d’une matrice
dim(A)[1] 3 5Nombre de lignes et de colonnes
nrow(A)[1] 3ncol(A)[1] 5Transposée et déterminant d’une matrice
t(A) ligne1 ligne2 ligne3
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
[5,] 13 14 15det(A[, 3:5])[1] 0Matrice diagonale et diagonale d’une matrice
diag(A)[1] 1 5 9diag(1:5) [,1] [,2] [,3] [,4] [,5]
[1,] 1 0 0 0 0
[2,] 0 2 0 0 0
[3,] 0 0 3 0 0
[4,] 0 0 0 4 0
[5,] 0 0 0 0 5Matrice de booléens
A > 5 [,1] [,2] [,3] [,4] [,5]
ligne1 FALSE FALSE TRUE TRUE TRUE
ligne2 FALSE FALSE TRUE TRUE TRUE
ligne3 FALSE TRUE TRUE TRUE TRUEA[A < 5] <- 0
A [,1] [,2] [,3] [,4] [,5]
ligne1 0 0 7 10 13
ligne2 0 5 8 11 14
ligne3 0 6 9 12 15Quelques autres fonctions sur les matrices
colSums(A)[1] 0 11 24 33 42apply(A, 2, sum)[1] 0 11 24 33 42rowSums(A)ligne1 ligne2 ligne3
30 38 42 apply(A, 1, sum)ligne1 ligne2 ligne3
30 38 42 rowMeans(A)ligne1 ligne2 ligne3
6.0 7.6 8.4 apply(A, 1, mean)ligne1 ligne2 ligne3
6.0 7.6 8.4 apply(A, 1, max)ligne1 ligne2 ligne3
13 14 15 Remarque : on reverra dans la section Programmation la fonction apply() qui
permet en particulier d’éviter les boucles for.
Attention à la multiplication matricielle %*% et la
multiplication terme à terme *!
Opérations terme à terme de 2 matrices
A + B [,1] [,2] [,3] [,4] [,5]
ligne1 1 2 10 14 18
ligne2 6 12 16 20 24
ligne3 11 18 22 26 30A * B [,1] [,2] [,3] [,4] [,5]
ligne1 0 0 21 40 65
ligne2 0 35 64 99 140
ligne3 0 72 117 168 225Multiplication de matrices
t(B) %*% A [,1] [,2] [,3] [,4] [,5]
[1,] 0 96 154 208 262
[2,] 0 107 178 241 304
[3,] 0 118 202 274 346
[4,] 0 129 226 307 388
[5,] 0 140 250 340 430Multiplication par un scalaire
5 * A [,1] [,2] [,3] [,4] [,5]
ligne1 0 0 35 50 65
ligne2 0 25 40 55 70
ligne3 0 30 45 60 75
- Créer la matrice \(A=\left(\begin{array}{c c c } 3 & 3 & 3\\ 4 & 4 & 4\\ 5 & 5 & 5\end{array}\right).\)
- Ajouter 2 à tous les éléments de \(A\).
- Créer la matrice \(B\) en ajoutant la ligne \((1,2,3)\) à \(A\), puis la colonne \((1,1,1,1)'\). Déterminer la dimension de \(B\).
- Extraire de \(B\) la sous-matrice \(C\) composée des deux premières colonnes et des deux dernières lignes. Calculer la transposée et le déterminant de \(C\).
# A COMPLETER POUR REPONDRE A L'EXERCICEUne liste est une collection ordonnée d’objets qui peuvent être de
nature différente. Les listes sont en particulier utilisées par
certaines fonctions (cf section Programmation)
pour renvoyer des résultats complexes sous forme d’un seul objet. On
utilise la fonction list(nom1=el1,nom2=el2,...)
(l’utilisation des noms étant facultative) pour générer une liste. On
peut accéder à chaque élément de la liste à l’aide de son index entre
double crochets [[...]], ou par son nom précédé du signe
$.
list(...)x = list("toto", 1:8)
x[[1]]
[1] "toto"
[[2]]
[1] 1 2 3 4 5 6 7 8Création d’une liste avec des noms aux éléments
y = list(matrice = matrix(1:15, ncol = 5), vecteur = seq(1, 20, by = 5), texte = "toto",
scalaire = 8)
y$matrice
[,1] [,2] [,3] [,4] [,5]
[1,] 1 4 7 10 13
[2,] 2 5 8 11 14
[3,] 3 6 9 12 15
$vecteur
[1] 1 6 11 16
$texte
[1] "toto"
$scalaire
[1] 8Extraction d’un élément par son numéro
x[[1]][1] "toto"Attention, cette commande n’est pas possible:
x[[1]] + 1par contre celle-ci est possible
x[[2]] + 10[1] 11 12 13 14 15 16 17 18y[[1]] [,1] [,2] [,3] [,4] [,5]
[1,] 1 4 7 10 13
[2,] 2 5 8 11 14
[3,] 3 6 9 12 15y$matrice [,1] [,2] [,3] [,4] [,5]
[1,] 1 4 7 10 13
[2,] 2 5 8 11 14
[3,] 3 6 9 12 15y$vec[1] 1 6 11 16y[c("texte", "scalaire")]$texte
[1] "toto"
$scalaire
[1] 8names(y)[1] "matrice" "vecteur" "texte" "scalaire"length(y)[1] 4length(y$vecteur)[1] 4cos(y$scal) + y[[2]][1][1] 0.8545summary(y) Length Class Mode
matrice 15 -none- numeric
vecteur 4 -none- numeric
texte 1 -none- character
scalaire 1 -none- numeric
- Créer une liste contenant le nom de trois matières, les notes de 5 élèves pour chacune de ces matières, l’âge des 5 élèves et la filière (PO) d’appartenance de ces 5 élèves.
- Récupérer les notes du 4ème élève
- Créer une matrice contenant les notes et l’âge des 5 élèves.
# A COMPLETER POUR REPONDRE A L'EXERCICESous R, un data.frame est analogue à une matrice mais le contenu des
colonnes peut être ici hétérogène. Un tableau de données est un ensemble
de vecteurs rangés colonne par colonne, chaque colonne correspondant à
une variable, chaque ligne à un individu. En particulier, lors d’études
statistiques, les données à étudier sont souvent représentées par un
data.frame sous R. Pour créer un tableau de données, on peut regrouper
des variables de même longueur à l’aide de la commande
data.frame(nom1=var1,nom2=var2,...). On peut par exemple
transformer une matrice en un tableau de données en utilisant la
commande as.data.frame(mat).
On donne ici quelques exemples à tester sous R pour vous familiariser
avec les data.frames. En particulier, vous pouvez découvrir des
fonctions utiles dont summary() et head().
data.frame()# Création du data.frame H
taille = runif(12, 150, 180)
masse = runif(12, 50, 90)
sexe = rep(c("M", "F", "F", "M"), 3)
H = data.frame(taille, masse, sexe)
H taille masse sexe
1 159.1421 66.88895 M
2 174.3444 69.15921 F
3 171.4166 67.13989 F
4 176.8689 63.04042 M
5 171.3922 81.89926 M
6 165.7481 87.59690 F
7 152.4223 76.71279 F
8 168.1355 57.94457 M
9 153.0398 71.91566 M
10 178.3689 65.47261 F
11 153.0043 68.86331 F
12 174.3904 53.54047 Mclass(H)[1] "data.frame"summary()/head()La fonction summary() permet de résumer le contenu des
différentes colonnes d’un data.frame.
summary(H) taille masse sexe
Min. :152.4 Min. :53.54 Length:12
1st Qu.:157.6 1st Qu.:64.86 Class :character
Median :169.8 Median :68.00 Mode :character
Mean :166.5 Mean :69.18
3rd Qu.:174.4 3rd Qu.:73.11
Max. :178.4 Max. :87.60 La fonction head() permet de visualiser les premières
lignes d’un data.frame
head(H) taille masse sexe
1 159.1421 66.88895 M
2 174.3444 69.15921 F
3 171.4166 67.13989 F
4 176.8689 63.04042 M
5 171.3922 81.89926 M
6 165.7481 87.59690 FAu travers de ces quelques commandes, vous pouvez voir les analogies entre data.frame, list et matrix mais restez prudent sur la nature de l’objet que vous manipulez!
H[1, ] taille masse sexe
1 159.1421 66.88895 MH$taille [1] 159.1421 174.3444 171.4166 176.8689 171.3922 165.7481 152.4223 168.1355
[9] 153.0398 178.3689 153.0043 174.3904H$sexe [1] "M" "F" "F" "M" "M" "F" "F" "M" "M" "F" "F" "M"is.data.frame(H)[1] TRUEis.matrix(H)[1] FALSEMH = as.matrix(H)
MH taille masse sexe
[1,] "159.1421" "66.88895" "M"
[2,] "174.3444" "69.15921" "F"
[3,] "171.4166" "67.13989" "F"
[4,] "176.8689" "63.04042" "M"
[5,] "171.3922" "81.89926" "M"
[6,] "165.7481" "87.59690" "F"
[7,] "152.4223" "76.71279" "F"
[8,] "168.1355" "57.94457" "M"
[9,] "153.0398" "71.91566" "M"
[10,] "178.3689" "65.47261" "F"
[11,] "153.0043" "68.86331" "F"
[12,] "174.3904" "53.54047" "M" summary(MH) taille masse sexe
Length:12 Length:12 Length:12
Class :character Class :character Class :character
Mode :character Mode :character Mode :character as.list(H)$taille
[1] 159.1421 174.3444 171.4166 176.8689 171.3922 165.7481 152.4223 168.1355
[9] 153.0398 178.3689 153.0043 174.3904
$masse
[1] 66.88895 69.15921 67.13989 63.04042 81.89926 87.59690 76.71279 57.94457
[9] 71.91566 65.47261 68.86331 53.54047
$sexe
[1] "M" "F" "F" "M" "M" "F" "F" "M" "M" "F" "F" "M"On reprend le data.frame \(H\).
- Extraire la masse des individus dont la taille est supérieure à 160.
- Extraire la masse et le sexe de ces mêmes individus.
- Extraire la taille des individus de sexe masculin dont la masse est inférieure à 80 (c’est possible en une seule ligne avec
&).
# A COMPLETER POUR REPONDRE A L'EXERCICER contient de base des fonctions dédiées aux graphiques. Les
fonctions graphiques principales comme plot() ouvrent une
nouvelle fenêtre à l’execution. Les fonctions graphiques secondaires
permettent d’ajouter des éléments à un graphique. Une présentation
succinte des graphiques de base avec R est disponible ici (tutoriel “Premiers Graphiques”).
Maintenant il est plus usuel d’utiliser la librairie
ggplot2 pour faire des graphiques sous R. On découvrira les
graphiques avec ggplot dans le TP2.
Cette partie est consacrée à la création des fonctions, les
instructions de contrôle, la syntaxe des itérations et la fonction
apply() (et ses dérivées).
Il est possible sous R de construire ses propres fonctions. De manière générale, la définition d’une nouvelle fonction passe par l’expression suivante :
nomfonction=function(arg1[=exp1],arg2[=exp2],...){
bloc d instructions
sortie = ...
return(sortie)
}Les accolades signalent le début et la fin du code source de la fonction, les crochets indiquent le caractère facultatif des valeurs par défaut des arguments. L’objet sortie contient le ou les résultats retournés par la fonction, on peut en particulier utiliser une liste pour retourner plusieurs résultats.
Voici quelques exemples :
MaFonction = function(x) {
x + 2
}
MaFonction(3)[1] 5Fonction2 = function(a, b = 7) {
a + b
}
Fonction2(2, b = 3)[1] 5Fonction2(5)[1] 12Fonction retournant le périmètre et la surface d’un cercle à partir de son rayon :
CalculsCercle = function(r) {
p = 2 * pi * r
s = pi * r * r
resultats = list(perimetre = p, surface = s)
return(resultats)
}
res = CalculsCercle(3)
res$perimetre
[1] 18.84956
$surface
[1] 28.27433res$surf[1] 28.27433La syntaxe if(condition){instructions} permet de
calculer les instructions uniquement si la condition est vraie. Le code
if(condition){ A }else { B } calcule les instructions A si
la condition est vraie et les instructions B sinon. On peut également
utiliser ifelse.
Dans l’exemple suivant, les deux commandes sont équivalentes :
if (x > 0) {
y = x * log(x)
} else {
y = 0
}
y = ifelse(x > 0, x * log(x), 0)On utilise les boucles pour exécuter plusieurs fois une instruction ou un bloc d’instructions. Les trois types de boucle sont :
for(var in seq){ commandes }while(cond){ commandes }repeat { commandes ; if (cond) break }Pour illustrer les trois types de boucles, on a codé de trois façons
différentes la somme des éléments d’un vecteur x ce qui
correspond à la fonction sum() de R.
# Exemple boucle for
somme1 = function(x) {
t = 0
for (i in 1:length(x)) {
t = t + x[i]
}
return(t)
}
x = seq(1:10)
somme1(x)[1] 55sum(x)[1] 55# Exemple boucle while
somme2 = function(x) {
t = 0
i = 1
while (i <= length(x)) {
t = t + x[i]
i = i + 1
}
return(t)
}
somme2(x)[1] 55# Exemple repeat
somme3 = function(x) {
t = 0
i = 1
repeat {
t = t + x[i]
i = i + 1
if (i > length(x))
break
}
return(t)
}
somme3(x)[1] 55Exercice :
- Écrire une fonction ma.var qui calcule la variance empirique corrigée pour un vecteur \(x = (x_1, . . . , x_n)\). Quelle est la variance de la variable “Taille” dans le data.frame \(H\) ? Comparez avec la fonction prédéfinie
var().- Écrire une fonction qui calcule les \(n\) premiers termes de la suite de Fibonacci (\(u_1=0, u_2=1, \forall n>2, u_n=u_{n-1}+u_{n-2}\))
# A COMPLETER POUR REPONDRE A L'EXERCICEapply()
et ses variantesIl est recommandé d’éviter les boucles très chronophages. On peut
utiliser pour cela la fonction apply() et ses variantes
sapply(), lapply(), tapply() sur
des vecteurs ou matrices.
La fonction apply() permet d’appliquer la même fonction
FUN sur toutes les lignes (MARGIN=1) ou les colonnes
(MARGIN=2) d’une matrice MAT :
apply(MAT , MARGIN, FUN).
Les fonctions lapply() et sapply()
calculent la même fonction sur tous les éléments d’un vecteur ou d’une
liste. La commande lapply(X,FUN, ARG.COMMUN) permet
d’appliquer la fonction FUN à tous les éléments du vecteur ou
de la liste X. Les valeurs de X sont affectées au
premier argument de la fonction FUN. Si la fonction
FUN a plusieurs paramètres d’entrée, ils sont spécifiés dans
ARG.COMMUN. Cette fonction retourne le résultat sous la forme
de listes. sapply() est une fonction similaire à
lapply() mais le résultat est retourné sous forme de
vecteurs, si possible.
La fonction tapply() applique une fonction FUN
sur les sous-groupes d’un vecteur X définis par une variable de
type factor GRP : tapply(X,GRP,FUN,...).
Voici quelques exemples :
data(iris)
head(iris) Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1 5.1 3.5 1.4 0.2 setosa
2 4.9 3.0 1.4 0.2 setosa
3 4.7 3.2 1.3 0.2 setosa
4 4.6 3.1 1.5 0.2 setosa
5 5.0 3.6 1.4 0.2 setosa
6 5.4 3.9 1.7 0.4 setosaapply(iris[, 1:4], 2, sum)Sepal.Length Sepal.Width Petal.Length Petal.Width
876.5 458.6 563.7 179.9 apply(iris[, 1:4], 1, sum) [1] 10.2 9.5 9.4 9.4 10.2 11.4 9.7 10.1 8.9 9.6 10.8 10.0 9.3 8.5 11.2
[16] 12.0 11.0 10.3 11.5 10.7 10.7 10.7 9.4 10.6 10.3 9.8 10.4 10.4 10.2 9.7
[31] 9.7 10.7 10.9 11.3 9.7 9.6 10.5 10.0 8.9 10.2 10.1 8.4 9.1 10.7 11.2
[46] 9.5 10.7 9.4 10.7 9.9 16.3 15.6 16.4 13.1 15.4 14.3 15.9 11.6 15.4 13.2
[61] 11.5 14.6 13.2 15.1 13.4 15.6 14.6 13.6 14.4 13.1 15.7 14.2 15.2 14.8 14.9
[76] 15.4 15.8 16.4 14.9 12.8 12.8 12.6 13.6 15.4 14.4 15.5 16.0 14.3 14.0 13.3
[91] 13.7 15.1 13.6 11.6 13.8 14.1 14.1 14.7 11.7 13.9 18.1 15.5 18.1 16.6 17.5
[106] 19.3 13.6 18.3 16.8 19.4 16.8 16.3 17.4 15.2 16.1 17.2 16.8 20.4 19.5 14.7
[121] 18.1 15.3 19.2 15.7 17.8 18.2 15.6 15.8 16.9 17.6 18.2 20.1 17.0 15.7 15.7
[136] 19.1 17.7 16.8 15.6 17.5 17.8 17.4 15.5 18.2 18.2 17.2 15.7 16.7 17.3 15.8lapply(iris[, 1:4], sum)$Sepal.Length
[1] 876.5
$Sepal.Width
[1] 458.6
$Petal.Length
[1] 563.7
$Petal.Width
[1] 179.9sapply(iris[, 1:4], sum)Sepal.Length Sepal.Width Petal.Length Petal.Width
876.5 458.6 563.7 179.9 tapply(iris[, 1], iris[, 5], sum) setosa versicolor virginica
250.3 296.8 329.4 Exercice :
Soit la fonction suivante :
Exo1 = function(M) {
res = rep(0, 5)
for (i in 1:5) {
tmp = 0
for (j in 1:4) {
tmp = tmp + M[i, j]
}
res[i] = tmp
}
return(res)
}
M = matrix(1:20, nrow = 5, ncol = 4)
Exo1(M)Proposez une fonction équivalente sans aucune boucle.
# A COMPLETERLe logiciel R permet d’effectuer des calculs avec toutes les lois de
probabilité usuelles, et aussi de simuler des échantillons issus de ces
lois. Pour chaque distribution, quatre commandes préfixées par une des
lettres d, p, q,
r et suivi du nom de la distribution
(nomdist) sont disponibles :
Voici une liste non exhaustive de lois de probabilité disponibles :
| Loi | nomdist |
|---|---|
| Gaussienne | norm |
| Binomiale | binom |
| Poisson | pois |
| Uniforme continue | unif |
| Exponentielle | exp |
| Student | t |
| Khi-deux | chisq |
| Fisher | f |
Exercice :
Simulez un échantillon de \(n=1000\) variables aléatoires gaussiennes de moyenne \(10\) et de variance \(4\) Calculez la moyenne et la variance de l’échantillon.
# A COMPLETERPour importer un tableau de données contenu dans un fichier en un
data.frame, on utilise la fonction read.table(). Par
exemple, pour un fichier nommé “Tableau.txt”, on utilisera la commande
Tab1 <- read.table("Tableau.txt") qui crée un data.frame
Tab1. La commande read.table() admet des options dont
header : indique si la première ligne contient des noms
de variables. Par défaut, la valeur de cette option est FALSE.sep : précise le séparateur de champ dans le fichier
entre guillemets (” ” par défaut).dec : le caractère utilisé pour les décimales (“.” par
défaut).Les fonctions read.csv() et read.csv2()
sont utilisées pour la lecture de fichiers de données au format
.csv.
Si maintenant on désire sauvegarder un jeu de données, on utilise la
commande write.table(). Les principales options de cette
fonction sont :
file : nom du fichier dans lequel écrire (vérifier le
répertoire courant)append : prend une valeur logique. Si TRUE, R ajoute
les données dans le fichier concerné sans effacer les précédentes. La
valeur par défaut est FALSE.sep : précise le séparateur à utiliser.dec : précise le caractère à utiliser pour les
décimales.Exercice :
Chargez le jeu de données ìris
disponible dans R avec la commandedata(iris) Sauvegardez le jeu de données dans un fichier intituléSauvIris.txtavec des “;” pour séparateurs. Importez les données du fichierSauvIris.txt
# A COMPLETERR permet d’enregistrer des objets entiers, en conservant à la fois les données contenues dans les objets et les structures des objets.
La fonction save.image() peut être utilisée à tout
moment pour enregistrer une image de session, c’est à dire l’ensemble
des objets dans l’environnement de travail d’une session R. La
sauvegarde d’une image de la session vous est également proposée lors de
la fermeture de R.
La fonction save() permet d’enregistrer spécifiquement
un ou des objets dans un fichier de format .RData. Ce fichier peut être
à tout moment rechargé sous R avec la fonction load().
Voici un exemple :
x <- runif(20)
y <- list(a = 1, b = TRUE, c = "oops")
save(x, y, file = "xy.RData")
load("xy.RData")On peut aussi enregistrer un seul objet, sans inclure le nom de
l’objet, à l’aide de la fonction saveRDS(). L’objet,
sauvegardé au format .rds peut être rechargé avec la
fonction readRDS().