Introduction - Introduction à R (2025)

Qu'est ce que R ?

R est un système d'analyse statistique et graphique créé par Ross Ihaka et Robert Gentleman.R est à la fois un logiciel et un langage interprété dont la conception dérive du langage S développé au sein des laboratoires AT&T Bell dans les années 80 et disponible actuellement sous la forme du logiciel S-PLUS commercialisé par la compagnie Insightful. Il y a des différences dans la conception de R et celle de S, pour en savoir plus sur ce point, se reporter au R-FAQ3.

Le langage R possède aujourd'hui une communauté mature d'utilisateurs et de développeurs qui ont créé et partagé des milliers de package via le Comprehensive R Archive Network (CRAN).

R comporte de nombreuses fonctions pour les analyses statistiques, les graphiques, le traitement et le stockage des données. Les graphiques sont visualisés à l'écran ou sur papier et peuvent être exportés sous divers formats (jpg, png, bmp, ps, pdf, emf, pictex, svg, xfig); les formats disponibles peuvent dépendre du système d'exploitation.Les résultats des analyses statistiques sont affichés à l'écran ou peuvent être sauvegardés ou exportés dans un fichier pour être utilisés dans des analyses ultérieures.

R est un langage de programmation simple et efficace qui permet à l'utilisateur d'écrire ses propres algorithmes en utilisant le traitement conditionnel, les boucles, la récursivité, les fonctions intrinsèques et utilisateurs et des fonctions d'entrée/sortie.

R comprend une suite d'opérateurs pour les calculs sur des tableaux, en particulier des matrices.

R offre les possibilités d'améliorer ses performances en convertisant le haut niveau d'interprétation du code R en un langage compilé écrit en C, C++ ou Fortran (Rcpp, ...).R permet de s'adapter à l'architecture des processeurs multi-coeurs et aux clusters de plusieurs noeuds en fournissant des outils aux développeurs qui leur permettent d'utiliser des techniques de programmation parallèle (parallel, multicore, snow, ...).

Un dernier point important: les statisticiens ont implémentés dans R des centaines de procédures adaptées à une grande variété d'applications, directement intégrées dans R sous forme de packages.

Pourquoi R ?

Avantages

R a des avantages majeurs:

1. Il est gratuit et le restera puisqu'il est distribué librement sous les termes de la GNU General Public Licence.
2. Il est disponible sur Internet, via un grand réseau de serveurs.
3. Il fonctionne sur de nombreux systèmes d'exploitation Unix et dérivés incluant Darwin, Mac OS X, Linux, FreeBSD et Solaris; sur Microsoft Windows.
4. Il est le produit d'une collaboration internationale entre statisticiens et informaticiens.
5. Il ne limite pas l'utilisateur à un ensemble de procédures ou d'options ou à une méthode presse-bouton, tout en utilisant les packages déjà intégrés dans R.
6. Il fournit des outils consistants (bibliothèques, language, ...) qui permettent de travailler avec des objets complexes de grande taille.
7. Il existe une documentation technique complète à laquelle participent les utilisateurs, des tutoriaux adaptés à des usages différents et aussi plusieurs bons livres sur les méthodes statistiques qui utilisent R (ou S) pour l'illustration.
8. Il est entièrement programmable, les procédures répétitives peuvent facilement être automatisées par des scripts écrits par l'utilisateur. Il est facile d'écrire ses propres fonctions, et pas trop compliqué d'écrire des paquets entiers pour implémenter de nouveaux algorithmes.
9. Le code source est publié, ainsi vous avez accès aux algorithmes exacts avec une validation possible par des statisticiens experts.
10. Il peut échanger des données en format MS-Excel, texte, format fixe et délimité (CSV, ...), de sorte que les jeux de données existants sont facilement importés, et les résultats calculés en R facilement exportables.
11. La plupart des programmes écrits avec S-PLUS fonctionneront sans modification, ou avec des changements mineurs, dans R.

Inconvénients

R présentent quelques inconvénients:

1. L'utilisateur doit définir lui-même la séquence des analyses et les exécuter pas à pas, cependant, il est facile de créer des scripts avec toutes les étapes dans les éditeurs des interfaces utilisateurs de R (dans ce cours, RStudio).
2. L'utilisateur doit apprendre à penser autrement la gestion de ses données, de penser les objets R comme des classes, ce qui lui permettra de bénéficier des avantages des langages orientés objet (les méthodes opérant différemment sur un objet en fonction de sa classe).
3. L'utilisateur doit apprendre un langage, à la fois pour les commandes mais aussi pour la spécification des analyses statistiques.

Alternatives

Il y a d'autres logiciels qui permettent de faire des calculs statistiques et du traitement de données. Ces logiciels peuvent souvent interagir entre eux avec la possibilité de programmer ses propres algorithmes ou d'interagir avec R. Aucun d'entre eux n'est open-source, ce qui signifie que vous devez faire confiance à l'entreprise pour faire les calculs correctement

• S-PLUS: : implémentation commerciale du langage S difusée par TIBCO.
• SAS: un concurrent de S-PLUS, très utilisée dans l'industrie, programmable.
• Des programmes statistiques spécifques.
• Tableurs comme Microsoft Excel.

Installer R

R est distribué librement sous les termes de la GNU General Public Licence, son développement et sa distribution sont assurés par plusieurs personnes regroupées dans la R core team.

Pour un meilleur suivi du cours, nous vous conseillons d'installer R (version 3.4 minimum) sur votre ordinateur personnel, il peut être téléchargé sur différents serveurs appelés “miroirs” et situés dans de nombreux pays. Plusieurs miroirs sont disponibles en France, on y trouvera des versions adaptées à différentes plateformes (Windows, Mac-OS et Linux).

Sous plusieurs formes, soit des exécutables précompilés pour Windows, Linux et OSX (Macintosh), soit des sources (écrits principalement en C et certaines routines en Fortran) qu'il faudra compiler avant de les utiliser.

• Installer R sous Windows

• Installer R sous Mac

• Sous Linux, R n’est fourni que comme un outil en ligne de commande, utilisez votre gestionnaire de packages habituel (de préférence, choisir un miroir proche de chez vous).

Plusieurs packages sont fournis avec l'installation de base, de nouveaux packages peuvent être facilement ajoutés, l'installation peut se faire en local ou pour l'ensemble des utilisateurs. Nous verrons comment installer de nouveaux packages dans la suite du cours.

RStudio est un environnement de développement intégré (IDE) qui propose des outils et facilite l’écriture de scripts et l’usage de R au quotidien. C’est une interface bien supérieure à celles fournies par défaut lorsqu’on installe R sous Windows ou sous Mac.

Installer RStudio, téléchargez la version adaptée à votre système.

Utiliser R

Il y a plusieurs méthodes pour travailler avec R

• En mode commande (CLI) avec un éditeur et une interface graphique ou pas.
• À partir d'un environnement de développement intégré (IDE). L'objectif d'un IDE est d'automatiser et de simplifier les activités du programmeur. Suivant les systèmes d'exploitation, il existe des interfaces de développement différentes.
• En utilisant le module ESS (Emacs Speaks Statistics) de l'éditeur emacs.

Dans ce cours nous utiliserons l'IDE RStudio utilisable sur la plupart des plateformes (Windows, Linux, Mac).

Utiliser R en mode Console

Le langage R est un langage interprété. Au démarrage d'une nouvelle session de R, on interagit avec R dans une console.

On écrit une ligne de code dans la console, on la valide (Entrée) et on observe le résultat (pas besoin d'une étape préalable de compilation du code).

Pour lancer une console R

• sous Windows, lancer le programme Rxxx (xxx correspondant au numéro de version) dont un raccourci a été créé sur le bureau après l'installation.

• sous Mac OS X, lancer le programme R présent dans le dossier Applications ou la commande R dans un terminal suivant le type d'installation de R choisi.

• sous Linux (et plus généralement tout système Unix), ouvrir un terminal et lancer la commande R.

• Au premier lancement de RStudio, l’écran principal est découpé en trois grandes zones :

  

La zone de gauche est la console.

Les interfaces graphiques sont différentes entre les différents systèmes d'exploitation mais cela ne change rien au langage qui sera compatible avec toutes les OS.

Dans la suite du cours, nous utiliserons la console de RStudio ou les notebooks sur le serveur de notebooks de GRICAD.

RStudio : interface conviviale

RStudio est un environnement de développement intégré (IDE), qui propose des outils et facilite l’écriture de scripts et l’usage de R au quotidien. C’est une interface bien supérieure à celles fournies par défaut lorsqu’on installe R sous Windows ou sous Mac.

Des versions libres sont téléchargeables sur la page https://www.rstudio.com/products/rstudio/download/#download.

• Téléchargez la version adaptée à votre système et installez la sur votre poste de travail.

• Cet environnement inclut dans une seule interface attractive:

  

  • une console (Console),
  • un terminal (Terminal),
  • un éditeur de code,
  • sorties graphiques (Plot),
  • l'historique (History),
  • une aide en ligne (Help),
  • le contenu de l'espace de travail (Environment),
  • un gestionnaire de fichier (Files),
  • le gestionnaire de paquets (Packages).

Cette interface peut être personnalisée, voir: Customizing RStudio.

On peut utiliser les gestionnaires de version comme git ou svn sous RStudio, ce qu'on ne fera pas dans ce cours. Cela fait partie du coup de R avancé.

Modification et exécution du code

L'éditeur de source de RStudio inclut une variété de fonctionnalités améliorant la productivité, y compris la mise en évidence de la syntaxe, l'achèvement du code, l'édition de plusieurs fichiers et la recherche/remplacement.

RStudio vous permet également d'exécuter de manière flexible le code R directement depuis l'éditeur de source. Travailler dans l'éditeur de source facilite la reproduction de séquences de commandes et le regroupement de commandes pour une réutilisation en tant que fonction.

Pour en savoir plus: Editing and Executing Code.

Gestion de fichiers

On utilisera l'onglet Files de RStudio. Celui-ci permet également de créer de nouveaux répertoires (New Folder) et de définir le répertoire courant comme répertoire de travail (Files -> More -> Set As Working Directory).

Historique

RStudio maintient un historique de toutes les commandes que vous avez déjà entrées dans la console. Vous pouvez parcourir et rechercher dans cet historique à l'aide de l'onglet History.

Les commandes sélectionnées dans l'onglet History peuvent être utilisées de deux façons, correspondant aux deux boutons sur le côté gauche de la barre d'outils "Historique":

• envoyer la(les) commande(s) sélectionnée(s) à la console,
• insèrer la(les) commande(s) sélectionnée(s) dans le document source actif

Pour en savoir plus: Using Command History.

Pour en savoir plus sur RStudio globalement: Using RStudio IDE

Utilisation de R comme une simple calculatrice

R utilise des fonctions et des opérateurs qui agissent sur des objets:

• Addition : +
• Soustraction : -
• Multiplication: *
• Division: /
• Exponentiation: ^ élève le nombre à sa gauche à la puissance du nombre à sa droite, par exemple 3^2 = 9 .
• Modulo: %% reste de la division entière du nombre à sa gauche par le nombre à sa droite, 13%%3 = 1
• Division entière : %/% division entière du nombre à sa gauche par le nombre à sa droite, 13%/%3 = 4

Une liste de fonctions génériques prédéfinies (log, sqrt,...).

Pour obtenir ces informations complètes, utiliser la commande help("Math").

Dans la console de RStudio, on essaie et on observe...

# R comme calculatrice2 + 33 - 22^313 %% 313 %/% 3log(7) #fonction prédéfinie de Rrunif(4)

5

1

8

1

4

1.94591014905531

1. 0.415537673747167
2. 0.683836687589064
3. 0.89679219131358
4. 0.928596392972395

Programmation sous R - Espace de travail

Un des concepts de base en programmation est la variable.

Une variable vous permet de stocker une valeur (par exemple 4) ou un objet (par exemple fonction) à l’aide de l’opérateur d’assignation

opérateur d'assignation <- dans R.

Vous pouvez ensuite utiliser le nom de cette variable pour accéder facilement à la valeur ou à l'objet stocké dans cette variable.

On peut retrouver l'ensemble des objets stockés avec la fonction ls() dans la console ou dans l'onglet Environment de RStudio.

On essaie et on observe...

# R comme langage interprete - espace de travaills() ## rien pour l'instantn <- 5na <- runif(n)ab <- 10nb <- n + bnb"(1) Espace de travail :"ls()rm(n)# Espace de travail"(2) Espace de travail :"ls()# Nettoyer l'espace de travailrm(list = ls())"(3) Espace de travail :"ls()

5

1. 0.621818745741621
2. 0.352833890821785
3. 0.200256045674905
4. 0.445061427541077
5. 0.989104883745313

15

'(1) Espace de travail :'

1. 'a'
2. 'b'
3. 'n'
4. 'nb'

'(2) Espace de travail :'

1. 'a'
2. 'b'
3. 'nb'

'(3) Espace de travail :'

Quelques statistiques

# R comme langage interprete - statistiquesn <- 20a <- runif(n)mean(a)sd(a)summary(a)

0.527959211776033

0.257873986261877

 Min. 1st Qu. Median Mean 3rd Qu. Max. 0.1362 0.3179 0.5495 0.5280 0.7143 0.9803

barplot(a)

b <- rnorm(2000, mean = 0, sd = 1)hist(b)

# Les distributions du package de basehelp(Distributions)

Espace de travail (workspace)

L'espace de travail est l'ensemble des objets stockés, consultable:

• Dans la console par la fonction ls().

• Dans l'onglet "Environment" de RStudio.

# Espace de travail (workspace)"(1) Espace de travail :"ls()a <- 7"(2) Espace de travail :"ls()#myfunc <- function() { y <- 1 ls()}myfunc() # Effacer des objets rm(a)"(3) Espace de travail :"ls()rm(myfunc)"(4) Espace de travail :"ls()#cmat1 <- matrix(1:20, ncol = 5)cmat2 <- matrix(1:20, ncol = 4)"(5) Espace de travail :"ls()# Effacer tout l'espace de travailrm(list = ls())"(6) Espace de travail :"ls()

'(1) Espace de travail :'

1. 'a'
2. 'b'
3. 'n'

'(2) Espace de travail :'

1. 'a'
2. 'b'
3. 'n'

'y'

'(3) Espace de travail :'

1. 'b'
2. 'myfunc'
3. 'n'

'(4) Espace de travail :'

1. 'b'
2. 'n'

'(5) Espace de travail :'

1. 'b'
2. 'cmat1'
3. 'cmat2'
4. 'n'

'(6) Espace de travail :'

Pour en savoir plus: Working Directories and Workspaces.

Les types de base en R

R utilise différents types de données dont les principaux sont:

• Un objet "vide" : NULL
• Les valeurs réelles comme 4.5 sont appelées numériques.
• Les nombres naturels comme 4 sont appelés integer. Les nombres entiers sont aussi numériques.
• Les valeurs booléennes (TRUE ou FALSE) sont appelées logiques.
• Les chaînes de caractères comme "nom" sont appelées character.

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

Pour connaître le mode d'un objet x de R, il suffit d'exécuter la fonction mode(x).

• La fonction typeof() permet d'obtenir une description plus précise de la représentation interne d'un objet.

• R utilise un mécanisme de fonction générique simple, le choix de la méthode utilisée dépend de la classe du premier argument de la fonction générique (ex: plot(), print(), ...).

Pour connaître la classe d'une variable, on utilise la fonction class().

# Variables de differents typesmy_logical <- FALSE my_integer <- 5Lmy_numeric <- 426my_character <- "42"

# mode, type et classe de my_numericmode(my_numeric)typeof(my_numeric)class(my_numeric)

'numeric'

'double'

'numeric'

# mode, type et classe de my_numericmode(my_integer)typeof(my_integer)class(my_integer)xx <- my_numeric + my_integerxxtypeof(xx)

'numeric'

'integer'

'integer'

431

'double'

# mode, type et classe de my_charactermode(my_character)typeof(my_character)class(my_character)

'character'

'character'

'character'

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

'42 euros'

'42 14'

'character'

'character'

# mode et classe de my_logicalmode(my_logical)class(my_logical)

'logical'

'logical'

Tester/ concertir le mode d'un objet

• Il est possible de tester le mode d'un objet x de R avec les fonctions:
• is.null(x)
• is.numeric(x)
• is.logical(x)
• is.character(x)
• is.complex(x)

Le résultat de ces fonctions est un booléen qui prend les valeurs TRUE, FALSE ou NA (missing value).

• Il est possible de convertir un objet d'un mode à un autre avec les fonctions:
• as.numeric(x)
• as.logical(x)
• as.character(x)
• as.complex(x)

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 <- TRUEmode(a)d <- as.numeric(a)mode(d)# Conversion "logical" en "character"as.character(a)# Conversion "character" en "numeric"b <- "3"as.numeric(b)6 + as.numeric(b)

'logical'

'numeric'

'TRUE'

3

9

Exemple de fonction générique

La fonction print

# fonction generiquea <- 1:20print(a)b <- 5.8class(b)print(b)# objet de classe "matrix"cmat1 <- matrix(a, ncol = 5)class(cmat1)print(cmat1)cmat2 <- matrix(a, ncol = 4)class(cmat2)print(cmat2)

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

'numeric'

[1] 5.8

'matrix'

 [,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'

 [,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

Valeur manquante et valeurs spéciales

• Certaines données sont absentes ou inexploitables, elles ne sont pas disponibles pour le traitement, R les note NA pour Not Available.

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

• On peut mentionner également les valeurs spéciales Inf pour l'infini et NaN pour Not a Number.

et les fonctions de test associés:

• is.finite(x)
• is.infinite(x)
• is.nan(x)

# donnees manquantes ou nonv <- c(2, 6, 4, 8, 2, 9, 10)vmean(v)vv <- c(2, 6, 4, 8, 2, NA, 10)mean(vv)mean(vv, na.rm = TRUE)

1. 2
2. 6
3. 4
4. 8
5. 2
6. 9
7. 10

5.85714285714286

<NA>

5.33333333333333

# Valeurs spécialesexp(1e10)w <- c(log(-4), 6, 9)wmean(w)mean(w, na.rm = TRUE)

Inf

Warning message in log(-4):“production de NaN”

1. NaN
2. 6
3. 9

NaN

7.5

Utilisation de scripts

Il n’est pas toujours très pratique de travailler uniquement sur la console, la saisie est réalisée ligne à ligne. En cas d’erreur de saisie, on devra soit resaisir la commande en la corrigeant, soit la rappeler en la recherchant dans l’historique des commandes en utilisant l'onglet History de RStudio pour pouvoir la modifier.

La méthode utilisée est de construire des scripts. Un script est un fichier texte qui contient une séquence d'instructions. La saisie de ces instructions peut se faire à l'extérieur de RStudio avec un éditeur (nedit, emacs, notepad,...) ou directement dans l'éditeur de RStudio.

Pour créer un nouveau script, utiliser le menu File -> New File -> R Script.

Une fenêtre d'édition s'ouvre dans laquelle vous pouvez saisir vos instructions, exécuter instruction par instruction (Ctrl + Entrée) ou globalement, sauvegarder le script, charger des scripts existants...

Pour en savoir plus: Editing and Executing Code.

Qu'est ce qu'un Data Frame?

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

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

Sous R, les tableaux de données sont des objets particuliers appelés data.frame. On verra dans la suite du cours que tout type d'objet a deux attributs intrinsèques, son mode et sa longueur. Il peutavoir des attributs spécifiques qui diffèrent selon le type de l'objet (dim, dimnames, class, ...).

Pour obtenir les attributs d'un objet, on utilise la fonction attributes(). Les attributs d'un data-frame sont le nom des variables (names), le nom des individus (row.names), les dimensions du tableau, le nombre des lignes et des colonnes.

Pour accéder à la valeur de ces attributs, on utilise attr(<objet>, <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.

Traitement du fichier de données "mtcars.csv"

• Description : les données ont été extraites du magazine Motor Trend US de 1974 et comprennent la consommation de carburant et 10 aspects de la conception et des performances de 32 automobiles (modèles 1973-1974).

• Format :

Un fichier de données "mtcars" avec 32 observations sur 11 variables:

mpg: Miles/(US) gallon (variable quantitative)cyl: Number of cylinders (variable qualitative)disp: Displacement (cu.in.) (variable quantitative)hp: Gross horsepower (variable quantitative)drat: Rear axle ratio (variable quantitative)wt: Weight (1000 lbs) (variable quantitative)qsec: 1/4 mile time (variable quantitative)vs: V/S (variable qualitative)am: Transmission (0 = automatic, 1 = manual) (variable qualitative)gear: Number of forward gears (variable qualitative)carb: Number of carburetors (variable qualitative)

La première ligne du fichier de données (mtcars.csv) contient les labels des 11 variables et pour tout individu, l'observation de chaque variable, séparées par des virgules.

On lit le fichier de données avec la fonction read.csv() adaptée au format qui fournit en sortie un objet de type data.frame. D'autres fonctions sont disponibles pour d'autres formats de données. Certains packages (readr, data.table) fournissent d'autres fonctions souvent plus rapides, pour les plus gros jeux de données.

Le fichier de données se trouve dans le répertoire data.

help(read.csv)

# Lecture du fichier de donnéesmtcars <- read.csv("data/mtcars.csv", header = TRUE, sep = ",")ls()

1. 'a'
2. 'b'
3. 'cmat1'
4. 'cmat2'
5. 'd'
6. 'mtcars'
7. 'my_character'
8. 'my_integer'
9. 'my_logical'
10. 'my_numeric'
11. 'v'
12. 'vv'
13. 'w'
14. 'xx'

class(mtcars)attributes(mtcars)names(mtcars) # fonction pour recuperer l'attribut qui contient le nom des variablesattr(mtcars, "names")

'data.frame'

$names

1. 'mpg'
2. 'cyl'
3. 'disp'
4. 'hp'
5. 'drat'
6. 'wt'
7. 'qsec'
8. 'vs'
9. 'am'
10. 'gear'
11. 'carb'

$class

'data.frame'

$row.names

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'

1. 'mpg'
2. 'cyl'
3. 'disp'
4. 'hp'
5. 'drat'
6. 'wt'
7. 'qsec'
8. 'vs'
9. 'am'
10. 'gear'
11. 'carb'

mtcars

# variable disp dans le data-frame "mtcars"mtcars[, "disp"] ## matrix-like accessormtcars[["disp"]] ## list-like accessor

1. 160
2. 160
3. 108
4. 258
5. 360
6. 225
7. 360
8. 146.7
9. 140.8
10. 167.6
11. 167.6
12. 275.8
13. 275.8
14. 275.8
15. 472
16. 460
17. 440
18. 78.7
19. 75.7
20. 71.1
21. 120.1
22. 318
23. 304
24. 350
25. 400
26. 79
27. 120.3
28. 95.1
29. 351
30. 145
31. 301
32. 121

1. 160
2. 160
3. 108
4. 258
5. 360
6. 225
7. 360
8. 146.7
9. 140.8
10. 167.6
11. 167.6
12. 275.8
13. 275.8
14. 275.8
15. 472
16. 460
17. 440
18. 78.7
19. 75.7
20. 71.1
21. 120.1
22. 318
23. 304
24. 350
25. 400
26. 79
27. 120.3
28. 95.1
29. 351
30. 145
31. 301
32. 121

mtcars[1:4, ] # 4 premieres observations de toutes les variable

names(mtcars)row.names(mtcars)

1. 'mpg'
2. 'cyl'
3. 'disp'
4. 'hp'
5. 'drat'
6. 'wt'
7. 'qsec'
8. 'vs'
9. 'am'
10. 'gear'
11. 'carb'

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'

dimnames(mtcars)

1. 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'
2. 1. 'mpg'
   2. 'cyl'
   3. 'disp'
   4. 'hp'
   5. 'drat'
   6. 'wt'
   7. 'qsec'
   8. 'vs'
   9. 'am'
   10. 'gear'
   11. 'carb'

summary(mtcars)

 mpg cyl disp hp Min. :10.40 Min. :4.000 Min. : 71.1 Min. : 52.0 1st Qu.:15.43 1st Qu.:4.000 1st Qu.:120.8 1st Qu.: 96.5 Median :19.20 Median :6.000 Median :196.3 Median :123.0 Mean :20.09 Mean :6.188 Mean :230.7 Mean :146.7 3rd Qu.:22.80 3rd Qu.:8.000 3rd Qu.:326.0 3rd Qu.:180.0 Max. :33.90 Max. :8.000 Max. :472.0 Max. :335.0 drat wt qsec vs Min. :2.760 Min. :1.513 Min. :14.50 Min. :0.0000 1st Qu.:3.080 1st Qu.:2.581 1st Qu.:16.89 1st Qu.:0.0000 Median :3.695 Median :3.325 Median :17.71 Median :0.0000 Mean :3.597 Mean :3.217 Mean :17.85 Mean :0.4375 3rd Qu.:3.920 3rd Qu.:3.610 3rd Qu.:18.90 3rd Qu.:1.0000 Max. :4.930 Max. :5.424 Max. :22.90 Max. :1.0000 am gear carb Min. :0.0000 Min. :3.000 Min. :1.000 1st Qu.:0.0000 1st Qu.:3.000 1st Qu.:2.000 Median :0.0000 Median :4.000 Median :2.000 Mean :0.4062 Mean :3.688 Mean :2.812 3rd Qu.:1.0000 3rd Qu.:4.000 3rd Qu.:4.000 Max. :1.0000 Max. :5.000 Max. :8.000

ls()

1. 'a'
2. 'b'
3. 'cmat1'
4. 'cmat2'
5. 'd'
6. 'mtcars'
7. 'my_character'
8. 'my_integer'
9. 'my_logical'
10. 'my_numeric'
11. 'v'
12. 'vv'
13. 'w'
14. 'xx'

Sauvegarde

Il est possible de sauvegarder des données et/ou des résultats au format RData, format propre au logiciel R. Cela facilite l’archivage de résultats intermédiaires ou l’enregistrement d’un tableau de données nettoyé (recodage de valeurs manquantes, modification des modalités de variables qualitatives, correction des erreurs de saisie, ...) ou augmenté de variables auxiliaires. Pour cela, on utilise la commande save(). La commande load() permet de recharger des données sauvegardées au format RData.

# Contenu de l'espace de travaills()save(mtcars, file = "data/mtcars.RData")

1. 'a'
2. 'b'
3. 'cmat1'
4. 'cmat2'
5. 'd'
6. 'mtcars'
7. 'my_character'
8. 'my_integer'
9. 'my_logical'
10. 'my_numeric'
11. 'v'
12. 'vv'
13. 'w'
14. 'xx'

Load

rm(list = ls())"(1) espace de travail :"ls()load("data/mtcars.RData")"(2) espace de travail :"ls()

'(1) espace de travail :'

'(2) espace de travail :'

'mtcars'

Le format RDS peut etre aussi utilisé pour stocker des objets R. Il a le bénéfice de pouvoir choisir le nom de la variable dans lequel mettre l'objet.

saveRDS(mtcars, file = "data/mtcars.rds")my_mtcars_name <- readRDS("data/mtcars.rds")ls()

1. 'mtcars'
2. 'my_mtcars_name'

Quitter R

Pour quitter R, exécuter la fonction

q() # R vous demande

Save workspace image? [y/n/c]:

Si vous répondez "y" , vous sauvegardez la session, R crée deux fichiers dans le répertoire de travail, .Rhistory et .RData.

• .Rhistory: historique des commandes de la session
• .RData: environnement (workspace) de la session.

Attention !!! Nécessité de gérer le volume de ces sauvegardes...

Lorsque vous réouvrez une session, vous retrouvez l'environnement et l'historique de la session sauvegardée, ce qui peut dans de nombreux cas générer des erreurs pas toujours faciles à identifier.

On peut dans la configuration de RStudio (menu Preferences) demander à supprimer la sauvegarde automatique, ou demander à ce que la question soit posée. Si vous voulez tendre vers une recherche plus reproductible, il est conseillé de ne pas enregistrer votre environnement, votre code devrait être capable de le regénérer pour vous.

Bibliothèques ou package

Un package ou une bibliothèque de programmes externes, est un ensemble de fonctions R, qui complète les fonctionnalités de R.

• Liste des package installés

library()mat <- available.packages() # Packages disponibles (au CRAN)nrow(mat)

Warning message in library():“libraries ‘/usr/local/lib/R/site-library’, ‘/usr/lib/R/site-library’ contain no packages”

13224

• Charger un package(si la librairie est déjà chargée, ne fait rien)

library(grDevices)sessionInfo() # packages chargés en cours de session

R version 3.4.4 (2018-03-15)Platform: x86_64-pc-linux-gnu (64-bit)Running under: Linux Mint 18.3Matrix products: defaultBLAS: /usr/lib/openblas-base/libblas.so.3LAPACK: /usr/lib/libopenblasp-r0.2.18.solocale: [1] LC_CTYPE=fr_FR.UTF-8 LC_NUMERIC=C [3] LC_TIME=fr_FR.UTF-8 LC_COLLATE=fr_FR.UTF-8 [5] LC_MONETARY=fr_FR.UTF-8 LC_MESSAGES=fr_FR.UTF-8 [7] LC_PAPER=fr_FR.UTF-8 LC_NAME=C [9] LC_ADDRESS=C LC_TELEPHONE=C [11] LC_MEASUREMENT=fr_FR.UTF-8 LC_IDENTIFICATION=Cattached base packages:[1] stats graphics grDevices utils datasets methods baseloaded via a namespace (and not attached): [1] compiler_3.4.4 IRdisplay_0.6.1 pbdZMQ_0.3-3 [4] tools_3.4.4 htmltools_0.3.6 base64enc_0.1-3 [7] rstudioapi_0.7 crayon_1.3.4 Rcpp_1.0.0 [10] uuid_0.1-2 IRkernel_0.8.14.9000 jsonlite_1.5 [13] digest_0.6.18 repr_0.17 RhpcBLASctl_0.18-185[16] evaluate_0.12

• Liste des fonctions d'un package

library(help = "stats") # fonctions du package "stats"

• Liste des datasets disponibles comme exemples sous R

data()data(package = "datasets") # datasets pour le package datasets

Installation d'un package

 install.packages("gplots")

Mise à jour d'un package

Certains packages sont en constante évolution avec de nouvelles versions disponibles. Il est préférable de les mettre à jour de temps en temps.

 update.packages()

Attention, la mise à jour d'un package est fonction de la version de R. Il faudra mettre à jour R régulièrement.

Créer ses propres packages

L'utilisateur peut créer ses propres packages (R avancé), les diffuser sur le CRAN ou pour l'usage de sa propre communauté.

Installer un package en local

Utilisation de la variable d'environnement R_LIBS qui fournit le/les répertoire(s) d'installation en local des packages

 export R_LIBS="/home/yourusername/R/lib install.packages("gplots") # en local dans R_LIBS

.libPaths() # liste des repertoires de recherche des librairies

1. '/home/privef/R/x86_64-pc-linux-gnu-library/3.4'
2. '/usr/local/lib/R/site-library'
3. '/usr/lib/R/site-library'
4. '/usr/lib/R/library'

Si vous ne voulez pas mettre à jour la variable à chaque installation.

• Placer la commande export dans le fichier .bashrc de votre "home directory", elle sera exécutée à chaque session.

ou,

• dans un fichier .Renviron de votre "home directory", la ligne

  R_LIBS="/home/yourusername/R/lib"

Vous pouvez indiquez plusieurs répertoires, séparés par ":"

• Pour indiquer la localisation des packages sur la plateforme utilisée, utiliser la variable R_LIBS_SITE

  R_LIBS_SITE=/Library/Frameworks/R.framework/Versions/Current/Resources/library

• Exécuter la fonction .libPaths() et observez.

.libPaths() # liste des repertoires de recherche des librairies

1. '/home/privef/R/x86_64-pc-linux-gnu-library/3.4'
2. '/usr/local/lib/R/site-library'
3. '/usr/lib/R/site-library'
4. '/usr/lib/R/library'

• Ajouter un répertoire local

.libPaths("")

Plusieurs répertoires possibles, séparés par ":".

.libPaths("/home/viryl/R/lib") # ajout d'un repertoire d'installation local

.libPaths()

1. '/usr/local/lib/R/site-library'
2. '/usr/lib/R/site-library'
3. '/usr/lib/R/library'

Documentation

1. Dans la console:

   • La fonction help(ma_function) ou ?ma_fonction dans la console affiche l'aide dans l'onglet Help de l'interface RStudio. On y trouve:

     • la description de la fonction,
     • les arguments optionnels ou obligatoires utilisés dans cette fonction, leur signification,
     • les sorties de la fonction,
     • les références,
     • quelques exemples

help(plot) # ou ?plot donne le même résultat. 

• Sur les détails de programmation

help("[[") # encadré d'une simple ou double quote

help("if"); help("for")

• La fonction help.start() permet d'ouvrir la version online (HTML) de l'aide R.
• Si on ne connait pas exactement le nom d'une fonction que l'on souhaite utiliser, il est alors possible de retrouver cette fonction grâce à help.search("mot_clé") qui vous affichera une liste des fonctions en rapport avec le mot_clé.
• Si on ne se souvient que d'une partie du nom d'une fonction, on peut alors utiliser la fonction apropos("pattern") pour lister les noms des fonctions qui contiennent ce pattern.

• Si aucune de ces fonctions n'a permis de résoudre votre problème, il reste la fonction RSiteSearch("mot_clé1 mot_clé2 ...") qui permet de faire directement une recherche dans la "R-help mailing list" (sorte de forum de discussion dédié à l'utilisation de R) ainsi que dans toutes les documentations de R et affiche les résultats dans une page Web.

• On accède à une aide complète sur l'utilisation, l'installation de R dans l'onglet Help de RStudio.

• De nombreux tutoriaux sur internet. Demandez à notre ami Google.

help.search("correlation")

apropos("NA")

1. 'addNA'
2. 'all.names'
3. 'allNames'
4. 'anyNA'
5. 'anyNA.numeric_version'
6. 'anyNA.POSIXlt'
7. 'as.name'
8. 'asNamespace'
9. 'aspell_write_personal_dictionary_file'
10. 'assignInMyNamespace'
11. 'assignInNamespace'
12. 'attachNamespace'
13. 'basename'
14. '.BaseNamespaceEnv'
15. 'case.names'
16. 'citeNatbib'
17. 'classMetaName'
18. 'className'
19. 'colnames'
20. 'colnames<-'
21. 'defaultDumpName'
22. 'determinant'
23. 'determinant.matrix'
24. 'dimnames'
25. 'dimnames<-'
26. 'dimnames<-.data.frame'
27. 'dimnames.data.frame'
28. 'dirname'
29. 'DNase'
30. '.DollarNames'
31. 'elNamed'
32. 'elNamed<-'
33. 'enc2native'
34. 'environmentName'
35. '.External'
36. '.External2'
37. '.External.graphics'
38. 'externalRefMethod'
39. 'factanal'
40. 'file.rename'
41. 'fileSnapshot'
42. 'finalDefaultMethod'
43. 'findMethodSignatures'
44. 'fixInNamespace'
45. 'getClassName'
46. 'getFromNamespace'
47. 'getNamespace'
48. '.getNamespace'
49. '..getNamespace'
50. 'getNamespaceExports'
51. 'getNamespaceImports'
52. 'getNamespaceInfo'
53. '.getNamespaceInfo'
54. 'getNamespaceName'
55. 'getNamespaceUsers'
56. 'getNamespaceVersion'
57. 'getNativeSymbolInfo'
58. 'getPackageName'
59. 'getSrcFilename'
60. 'getTaskCallbackNames'
61. 'hasName'
62. 'inheritedSlotNames'
63. '.Internal'
64. 'isBaseNamespace'
65. 'is.na'
66. 'is.na<-'
67. 'is.na.data.frame'
68. 'is.na<-.default'
69. 'is.na<-.factor'
70. 'is.name'
71. 'isNamespace'
72. 'isNamespaceLoaded'
73. 'is.nan'
74. 'is.na<-.numeric_version'
75. 'is.na.numeric_version'
76. 'is.na.POSIXlt'
77. 'kernapply'
78. 'library.dynam'
79. 'library.dynam.unload'
80. 'loadedNamespaces'
81. 'loadingNamespaceInfo'
82. 'loadNamespace'
83. 'make.names'
84. 'matchSignature'
85. 'metaNameUndo'
86. 'methodSignatureMatrix'
87. 'methodsPackageMetaName'
88. 'mlistMetaName'
89. 'month.name'
90. 'my_mtcars_name'
91. 'na.action'
92. 'na.contiguous'
93. 'na.exclude'
94. 'na.fail'
95. 'names'
96. 'names<-'
97. 'namespaceExport'
98. 'namespaceImport'
99. 'namespaceImportClasses'
100. 'namespaceImportFrom'
101. 'namespaceImportMethods'
102. 'names<-.POSIXlt'
103. 'names.POSIXlt'
104. 'na.omit'
105. 'na.pass'
106. 'napredict'
107. 'naprint'
108. 'naresid'
109. 'nargs'
110. 'occupationalStatus'
111. 'OlsonNames'
112. 'packageHasNamespace'
113. 'packageName'
114. 'parseNamespaceFile'
115. 'print.NativeRoutineList'
116. 'provideDimnames'
117. 'reg.finalizer'
118. 'requireNamespace'
119. 'rownames'
120. 'row.names'
121. 'row.names<-'
122. 'rownames<-'
123. 'row.names<-.data.frame'
124. 'row.names.data.frame'
125. 'row.names<-.default'
126. 'row.names.default'
127. 'setNames'
128. 'setNamespaceInfo'
129. 'setPackageName'
130. 'signalCondition'
131. '.signalSimpleWarning'
132. 'signature'
133. 'SignatureMethod'
134. 'slotNames'
135. '.slotNames'
136. 'state.name'
137. 'substituteFunctionArgs'
138. 'taskCallbackManager'
139. 'unloadNamespace'
140. 'unname'
141. 'USPersonalExpenditure'
142. 'validSlotNames'
143. 'variable.names'

Bibliographie

Sites Web

• Site RStudio
• Using RStudio IDE
• Introduction à R (MOOC - Introduction à la statistique avec R
• Introduction à R et au tidyverse
• Cours complet sur l'analyse de données (MOOC)
• Data Science
• Télécharger des Aide-Mémoires sur le site de RStudio
• R Programming Tutorial – Beginners , intermediate and Advanced

Livres

• Hands-On Programming with R - Write Your Own Functions and Simulations (Garrett Grolemund)
• Training books