Commit 69c614a0 authored by Laurence Viry's avatar Laurence Viry
Browse files

modif ManipDon 9/07/18

parent 95453395
Pipeline #9702 passed with stages
in 1 minute and 2 seconds
......@@ -18,9 +18,7 @@
"\n",
"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 /sorties. \n",
"\n",
"R comprend une suite d'opérateurs po\n",
"\n",
"ur les calculs sur des tableaux, en particulier des matrices.\n",
"R comprend une suite d'opérateurs pour les calculs sur des tableaux, en particulier des matrices.\n",
"\n",
"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**,...)\n",
"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 lui permet d'utiliser des techniques de programmation parallèle (**parallel**,**multicore**,**snow**,...)\n",
......@@ -59,7 +57,7 @@
"3. L'utilisateur doit apprendre un langage, à la fois pour les commandes mais aussi pour la spécification des analyses statistiques.\n",
"\n",
"### Alternatives\n",
"Il y a d'autres logiciels qui permettent de faire des calculs statistiques et du traitement de données, ils 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 correctemen\n",
"Il y a d'autres logiciels qui permettent de faire des calculs statistiques et du traitement de données, ils 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.\n",
"\n",
" - S-PLUS: : implémentation commerciale du langage S di usée par TIBCO.\n",
" - SAS: un concurrent de S-PLUS, très utilisée dans l'industrie, programmable.\n",
......
%% Cell type:markdown id: tags:
# Introduction
## 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](https://cran.r-project.org/doc/FAQ/R-FAQ.html).
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, https://cran.r-project.org).
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,
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 /sorties.
R comprend une suite d'opérateurs po
ur les calculs sur des tableaux, en particulier des matrices.
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 lui permet d'utiliser des techniques de programmation parallèle (**parallel**,**multicore**,**snow**,...)
Un dernier point important, les statisticiens ont implémentés dans R sous forme de packages directement intégrées dans R, des centaines de procédures adaptées à une grande variété d'applications.
%% Cell type:markdown id: tags:
## 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](http://www.gnu.org/)
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, à 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 les 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 objet. Les méthodes opérant 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, ils 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 correctemen
Il y a d'autres logiciels qui permettent de faire des calculs statistiques et du traitement de données, ils 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 di usée par TIBCO.
- SAS: un concurrent de S-PLUS, très utilisée dans l'industrie, programmable.
- [Des programmes statistiques spécifques](http://www.stata.com/links/statistical-software-providers/).
- Tableurs: Microsoft Excel (Data Analysis. . . ),
%% Cell type:markdown id: tags:
## Installer R
R est distribué librement sous les termes de la [GNU General Public Licence](http://www.gnu.org/)
, son développement et sa distribution sont assurés par plusieurs statisticiens
rassemblés dans le [**R Development Core Team**](https://cran.r-project.org/mirrors.html).
Pour un meilleur suivi du cours, nous vous conseillons d'installer **R** (Version 3.4.x au moins) 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 :
- des exécutables précompilés pour Windows, Linux et OSX (Macintosh).
- de sources(écrit principalement en C et certaines routines en Fortran) qu'il faudra compiler avant de les utiliser.
- [Installer R sous **Windows**](https://cloud.r-project.org/bin/windows/base/)
- [Installer R sous **Mac**](https://cloud.r-project.org/bin/macosx/)
- [Sous **Linux**](https://cran.r-project.org/mirrors.html), 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 package dans la suite du cours.
[RStudio](https://www.rstudio.com/products/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-OS
[Installer RStudio](https://www.rstudio.com/products/rstudio/download/#download), téléchargez la version adaptée à votre système.
%% Cell type:markdown id: tags:
## RStudio : interface conviviale
[RStudio](https://www.rstudio.com/products/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-OS
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:
<img src="../figures/InterfaceRStudio.jpg",width="80%",height="80%">
- 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](https://support.rstudio.com/hc/en-us/articles/200549016-Customizing-RStudio).
On peut utiliser les gestionnaires de version **git**, **svn**,... sous RStudio, ce qu'on ne fera pas dans ce cours, [voir le tutoriel](https://informatique-mia.inra.fr/r4ciam/sites/ciam.inra.fr.r4ciam/files/Tutoriels/UtilisationGit13mai.pdf).
%% Cell type:markdown id: tags:
### 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](https://support.rstudio.com/hc/en-us/articles/200484448).
%% Cell type:markdown id: tags:
### 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).
%% Cell type:markdown id: tags:
### Historique
RStudio maintient une base de données de toutes les commandes que vous avez déjà entrées dans la console. Vous pouvez parcourir et rechercher dans cette base de données à l'aide de l'onglet **History**, afficher le contexte d'une commande.
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](https://support.rstudio.com/hc/en-us/articles/200526217-Command-History).
%% Cell type:markdown id: tags:
Pour en savoir plus sur RStudio globalement: [Using RStudio IDE](https://support.rstudio.com/hc/en-us/sections/200107586-Using-the-RStudio-IDE)
%% Cell type:markdown id: tags:
## 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 de cet 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 plates-formes (Windows, Linux, MaxOS).
%% Cell type:markdown id: tags:
## 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.
<img src="../figures/Console-R-Windows.jpg",width="60%",height="60%">
- 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.
<img src="../figures/Console-R-Macos.jpg",width="60%",height="60%">
- sous Linux (et plus généralement tout système Unix), **ouvrir un terminal** et **lancer la commande R**.
<img src="../figures/consoleLinux.jpg",width="60%",height="60%">
- Au premier lancement de RStudio, l’écran principal est découpé en trois grandes zones :
<img src="../figures/interfaceRStudio_0.jpg",width="60%",height="60%">
**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 plates-formes.
Dans la suite du cours, nous utiliserons la console de **RStudio** ou les notebooks sur le serveur de notebooks de GRICAD.
%% Cell type:markdown id: tags:
### 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...
%% Cell type:code id: tags:
``` R
# R comme calculatrice
2+3
3-2
2^3
13 %% 3
13 %/% 3
log(7) #fonction prédéfinie de R
runif(4)
"espace de travail"
ls() # fournit le nom des objets de l'espace de travail
```
%%%% Output: display_data
5
5
%%%% Output: display_data
1
1
%%%% Output: display_data
8
8
%%%% Output: display_data
1
1
%%%% Output: display_data
4
4
%%%% Output: display_data
1.94591014905531
1.94591014905531
%%%% Output: display_data
1. 0.716547878459096
2. 0.827923827804625
3. 0.607921322109178
4. 0.211772634647787
\begin{enumerate*}
\item 0.716547878459096
\item 0.827923827804625
\item 0.607921322109178
\item 0.211772634647787
\end{enumerate*}
%%%% Output: display_data
'espace de travail'
'espace de travail'
%%%% Output: display_data
%% Cell type:markdown id: tags:
## Programmation sous R - Espace de travail
Un concept de base en programmation s'appelle une **variable**.
Une variable vous permet de **stocker une valeur** (par exemple 4) ou **un objet** (par exemple une description de 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...
%% Cell type:code id: tags:
``` R
# R comme langage interprete - espace de travail
ls()
n <- 5
n
a <- runif(n)
a
b <- 10
nb <- n + b
nb
"Espace de travail 1"
ls()
rm(n)
# Espace de travail
"Espace de travail 2"
ls()
# Nettoyer l'espace de travail
rm(list=ls())
"Espace de travail 3"
ls()
```
%%%% Output: display_data
%%%% Output: display_data
5
5
%%%% Output: display_data
1. 0.62501686764881
2. 0.938050465425476
3. 0.316431388491765
4. 0.902880884939805
5. 0.355515625793487
\begin{enumerate*}
\item 0.62501686764881
\item 0.938050465425476
\item 0.316431388491765
\item 0.902880884939805
\item 0.355515625793487
\end{enumerate*}
%%%% Output: display_data
15
15
%%%% Output: display_data
'Espace de travail 1'
'Espace de travail 1'
%%%% Output: display_data
1. 'a'
2. 'b'
3. 'n'
4. 'nb'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'n'
\item 'nb'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 2'
'Espace de travail 2'
%%%% Output: display_data
1. 'a'
2. 'b'
3. 'nb'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'nb'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 3'
'Espace de travail 3'
%%%% Output: display_data
%% Cell type:markdown id: tags:
### Quelques statistiques
%% Cell type:code id: tags:
``` R
ls()
a <- 4
a
```
%%%% Output: display_data
%%%% Output: display_data
4
4
%% Cell type:code id: tags:
``` R
# R comme langage interprete - statistiques
n <-20
a <- runif(n)
mean(a)
sd(a)
summary(a)
```
%%%% Output: display_data
0.447511035855859
0.447511035855859
%%%% Output: display_data
0.267335138241474
0.267335138241474
%%%% Output: display_data
%% Cell type:code id: tags:
``` R
barplot(a)
```
%%%% Output: display_data
[Hidden Image Output]
%% Cell type:code id: tags:
``` R
b <- rnorm(20,mean=0,sd=1)
hist(b)
```
%%%% Output: display_data
[Hidden Image Output]
%% Cell type:code id: tags:
``` R
# Les distributions du package de base
help(Distributions)
```
%% Cell type:markdown id: tags:
### 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.
%% Cell type:code id: tags:
``` R
# Espace de travail (workspace)
"Espace de travail 1"
ls()
a <- 7
"Espace de travail 2"
ls()
#
myfunc <- function() {y <- 1; ls()}
myfunc()
# Effacer des objets
rm(a)
"Espace de travail 3"
ls()
rm(myfunc)
"Espace de travail 4"
ls()
#
cmat1 <-matrix(1:20,ncol=5)
cmat2 <-matrix(1:20,ncol=4)
"Espace de travail 5"
ls()
# Effacer tout l'espace de travail
rm(list = ls())
"Espace de travail 6"
ls()
```
%%%% Output: display_data
'Espace de travail 1'
'Espace de travail 1'
%%%% Output: display_data
1. 'a'
2. 'b'
3. 'n'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'n'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 2'
'Espace de travail 2'
%%%% Output: display_data
1. 'a'
2. 'b'
3. 'n'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'n'
\end{enumerate*}
%%%% Output: display_data
'y'
'y'
%%%% Output: display_data
'Espace de travail 3'
'Espace de travail 3'
%%%% Output: display_data
1. 'b'
2. 'myfunc'
3. 'n'
\begin{enumerate*}
\item 'b'
\item 'myfunc'
\item 'n'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 4'
'Espace de travail 4'
%%%% Output: display_data
1. 'b'
2. 'n'
\begin{enumerate*}
\item 'b'
\item 'n'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 5'
'Espace de travail 5'
%%%% Output: display_data
1. 'b'
2. 'cmat1'
3. 'cmat2'
4. 'n'
\begin{enumerate*}
\item 'b'
\item 'cmat1'
\item 'cmat2'
\item 'n'
\end{enumerate*}
%%%% Output: display_data
'Espace de travail 6'
'Espace de travail 6'
%%%% Output: display_data
%% Cell type:markdown id: tags:
Pour en savoir plus: [Working Directories and Workspaces](https://support.rstudio.com/hc/en-us/articles/200711843-Working-Directories-and-Workspaces).
%% Cell type:markdown id: tags:
### Les types de base en R
R utilise différents types de données dont les principaux sont:
* Un objet vide noté: 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()**
%% Cell type:code id: tags:
``` R
# Variables of differents types
my_numeric <- 426
my_character <- "42"
my_logical <- FALSE
my_integer <- 5L
```
%% Cell type:code id: tags:
``` R
# Class de my_numeric
" mode, typeof et classe my_numeric"
mode(my_numeric)
typeof(my_numeric)
class(my_numeric)
```
%%%% Output: display_data
' mode, typeof et classe my_numeric'
' mode, typeof et classe my\_numeric'
%%%% Output: display_data
'numeric'
'numeric'
%%%% Output: display_data
'double'
'double'
%%%% Output: display_data
'numeric'
'numeric'
%% Cell type:code id: tags:
``` R
# Class de my_numeric
" mode, typeof et classe my_integer"
mode(my_integer)
typeof(my_integer)
class(my_integer)
xx <- my_numeric + my_integer
xx
mode(xx)
class(xx)
```
%%%% Output: display_data
' mode, typeof et classe my_integer'
' mode, typeof et classe my\_integer'
%%%% Output: display_data
'numeric'
'numeric'
%%%% Output: display_data
'integer'
'integer'
%%%% Output: display_data
'integer'
'integer'
%%%% Output: display_data
431
431
%%%% Output: display_data
'numeric'
'numeric'
%%%% Output: display_data
'numeric'
'numeric'
%% Cell type:code id: tags:
``` R
# Class de my_character
" mode, typeof et classe my_character"
mode(my_character)
typeof(my_character)
class(my_character)
```
%%%% Output: display_data
' mode, typeof et classe my_character'
' mode, typeof et classe my\_character'
%%%% Output: display_data
'character'
'character'
%%%% Output: display_data
'character'
'character'
%%%% Output: display_data
'character'
'character'
%% Cell type:code id: tags:
``` R
# my_character + 10 # argument non numérique pour un opérateur binaire
paste(my_character, "euros") # Concatène après conversion en caractères
b <- paste(my_character, 14)
b
mode(b)
class(b)
```
%%%% Output: display_data
'42 euros'
'42 euros'
%%%% Output: display_data
'42 14'
'42 14'
%%%% Output: display_data
'character'
'character'
%%%% Output: display_data
'character'
'character'
%% Cell type:code id: tags:
``` R
# Class de my_logical
" mode et classe my_logical"
mode(my_logical)
class(my_logical)
```
%%%% Output: display_data
' mode et classe my_logical'
' mode et classe my\_logical'
%%%% Output: display_data
'logical'
'logical'
%%%% Output: display_data
'logical'
'logical'
%% Cell type:markdown id: tags:
#### 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** et **FALSE**
* 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...
%% Cell type:code id: tags:
``` R
# Conversion "logical" en "numeric"
a <- TRUE
mode(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)
```
%%%% Output: display_data
'logical'
'logical'
%%%% Output: display_data
'numeric'
'numeric'
%%%% Output: display_data
'TRUE'
'TRUE'
%%%% Output: display_data
3
3
%%%% Output: display_data
9
9
%% Cell type:markdown id: tags:
#### Exemple de fonction générique
La fonction **print**
%% Cell type:code id: tags:
``` R
# fonction generique
a <- 1:20
print(a)
b <- 5.8
class(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)
```
%%%% Output: stream
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
%%%% Output: display_data
'numeric'
'numeric'
%%%% Output: stream
[1] 5.8
%%%% Output: display_data
'matrix'
'matrix'
%%%% Output: stream
[,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
%%%% Output: display_data
'matrix'
'matrix'
%%%% Output: stream
[,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
%% Cell type:markdown id: tags:
#### 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 booléen 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)
%% Cell type:code id: tags:
``` R
# donnees manquantes
v <- c(2,6,4,8,2,9,10)
v
mean(v)
vv <- c(2,6,4,8,2,NA,10)
mean(vv)
mean(vv,na.rm=TRUE)
```
%%%% Output: display_data
1. 2
2. 6
3. 4
4. 8
5. 2
6. 9
7. 10
\begin{enumerate*}
\item 2
\item 6
\item 4
\item 8
\item 2
\item 9
\item 10
\end{enumerate*}
%%%% Output: display_data
5.85714285714286
5.85714285714286
%%%% Output: display_data
%%%% Output: display_data
5.33333333333333
5.33333333333333
%% Cell type:code id: tags:
``` R
# Valeurs spéciales
exp(1e10)
w <- c(log(-4),6,9)
w
mean(w)
mean(w,na.rm=TRUE)
```
%%%% Output: display_data
Inf
Inf
%%%% Output: stream
Warning message in log(-4):
“NaNs produced”
%%%% Output: display_data
1. NaN
2. 6
3. 9
\begin{enumerate*}
\item NaN
\item 6
\item 9
\end{enumerate*}
%%%% Output: display_data
NaN
NaN
%%%% Output: display_data
7.5
7.5
%% Cell type:markdown id: tags:
## 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 ou globalement, sauvegarder le script, charger des scripts existants...
Pour en savoir plus: [Editing and Executing Code](https://support.rstudio.com/hc/en-us/articles/200484448-Editing-and-Executing-Code)
%% Cell type:markdown id: tags:
## Qu'est ce qu'un Data Frame?
**Un tableau de données est un ensemble de vecteurs rangés colonne par colonne**. Chaque colonne du tableau data correspond à une variable, chaque ligne à un individu. Les variables peuvent être de type différent (numérique, booléen, character,...).
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 peut
avoir des attributs spécifiques qui différents 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 utile le caractère **\$** et le nom de l'attribut.
La fonction **dim()** fournit les dimensions du tableau de données: le nombre d'observations et le nombre de variables.
La fonction **dimnames()** fournit le nom des dimensions du tableau de données: le nom des individus et le nom des variables.
%% Cell type:markdown id: tags:
### 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ée par **","**.
<img src="../figures/donMtcars.jpg",width="60%",height="60%">
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.
Le fichier de données se trouve dans le répertoire **data**.
%% Cell type:code id: tags:
``` R
help(read.csv)
```
%% Cell type:code id: tags:
``` R
ls() # Contenu de l'espace de travail
```
%%%% Output: display_data
1. 'a'
2. 'b'
3. 'cmat1'
4. 'cmat2'
5. 'd'
6. 'my_character'
7. 'my_integer'
8. 'my_logical'
9. 'my_numeric'
10. 'v'
11. 'vv'
12. 'w'
13. 'xx'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'cmat1'
\item 'cmat2'
\item 'd'
\item 'my\_character'
\item 'my\_integer'
\item 'my\_logical'
\item 'my\_numeric'
\item 'v'
\item 'vv'
\item 'w'
\item 'xx'
\end{enumerate*}
%% Cell type:code id: tags:
``` R
# Lecture du fichier de données
mtcars <- read.csv("data/mtcars.csv",header=TRUE,sep=",")
ls()
```
%%%% Output: display_data
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'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'cmat1'
\item 'cmat2'
\item 'd'
\item 'mtcars'
\item 'my\_character'
\item 'my\_integer'
\item 'my\_logical'
\item 'my\_numeric'
\item 'v'
\item 'vv'
\item 'w'
\item 'xx'
\end{enumerate*}
%% Cell type:code id: tags:
``` R
class(mtcars)
attributes(mtcars)
mtcars$names # attribut qui contient le nom des variables
```
%%%% Output: display_data
'data.frame'
'data.frame'
%%%% Output: display_data
$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
\begin{description}
\item[\$names] \begin{enumerate*}
\item 'mpg'
\item 'cyl'
\item 'disp'
\item 'hp'
\item 'drat'
\item 'wt'
\item 'qsec'
\item 'vs'
\item 'am'
\item 'gear'
\item 'carb'
\end{enumerate*}
\item[\$class] 'data.frame'
\item[\$row.names] \begin{enumerate*}
\item 1
\item 2
\item 3
\item 4
\item 5
\item 6
\item 7
\item 8
\item 9
\item 10
\item 11
\item 12
\item 13
\item 14
\item 15
\item 16
\item 17
\item 18
\item 19
\item 20
\item 21
\item 22
\item 23
\item 24
\item 25
\item 26
\item 27
\item 28
\item 29
\item 30
\item 31
\item 32
\end{enumerate*}
\end{description}
%%%% Output: display_data
%% Cell type:code id: tags:
``` R
mtcars
```
%%%% Output: display_data
mpg | cyl | disp | hp | drat | wt | qsec | vs | am | gear | carb |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 21.0 | 6 | 160.0 | 110 | 3.90 | 2.620 | 16.46 | 0 | 1 | 4 | 4 |
| 21.0 | 6 | 160.0 | 110 | 3.90 | 2.875 | 17.02 | 0 | 1 | 4 | 4 |
| 22.8 | 4 | 108.0 | 93 | 3.85 | 2.320 | 18.61 | 1 | 1 | 4 | 1 |
| 21.4 | 6 | 258.0 | 110 | 3.08 | 3.215 | 19.44 | 1 | 0 | 3 | 1 |
| 18.7 | 8 | 360.0 | 175 | 3.15 | 3.440 | 17.02 | 0 | 0 | 3 | 2 |
| 18.1 | 6 | 225.0 | 105 | 2.76 | 3.460 | 20.22 | 1 | 0 | 3 | 1 |
| 14.3 | 8 | 360.0 | 245 | 3.21 | 3.570 | 15.84 | 0 | 0 | 3 | 4 |
| 24.4 | 4 | 146.7 | 62 | 3.69 | 3.190 | 20.00 | 1 | 0 | 4 | 2 |
| 22.8 | 4 | 140.8 | 95 | 3.92 | 3.150 | 22.90 | 1 | 0 | 4 | 2 |
| 19.2 | 6 | 167.6 | 123 | 3.92 | 3.440 | 18.30 | 1 | 0 | 4 | 4 |
| 17.8 | 6 | 167.6 | 123 | 3.92 | 3.440 | 18.90 | 1 | 0 | 4 | 4 |
| 16.4 | 8 | 275.8 | 180 | 3.07 | 4.070 | 17.40 | 0 | 0 | 3 | 3 |
| 17.3 | 8 | 275.8 | 180 | 3.07 | 3.730 | 17.60 | 0 | 0 | 3 | 3 |
| 15.2 | 8 | 275.8 | 180 | 3.07 | 3.780 | 18.00 | 0 | 0 | 3 | 3 |
| 10.4 | 8 | 472.0 | 205 | 2.93 | 5.250 | 17.98 | 0 | 0 | 3 | 4 |
| 10.4 | 8 | 460.0 | 215 | 3.00 | 5.424 | 17.82 | 0 | 0 | 3 | 4 |
| 14.7 | 8 | 440.0 | 230 | 3.23 | 5.345 | 17.42 | 0 | 0 | 3 | 4 |
| 32.4 | 4 | 78.7 | 66 | 4.08 | 2.200 | 19.47 | 1 | 1 | 4 | 1 |
| 30.4 | 4 | 75.7 | 52 | 4.93 | 1.615 | 18.52 | 1 | 1 | 4 | 2 |
| 33.9 | 4 | 71.1 | 65 | 4.22 | 1.835 | 19.90 | 1 | 1 | 4 | 1 |
| 21.5 | 4 | 120.1 | 97 | 3.70 | 2.465 | 20.01 | 1 | 0 | 3 | 1 |
| 15.5 | 8 | 318.0 | 150 | 2.76 | 3.520 | 16.87 | 0 | 0 | 3 | 2 |
| 15.2 | 8 | 304.0 | 150 | 3.15 | 3.435 | 17.30 | 0 | 0 | 3 | 2 |
| 13.3 | 8 | 350.0 | 245 | 3.73 | 3.840 | 15.41 | 0 | 0 | 3 | 4 |
| 19.2 | 8 | 400.0 | 175 | 3.08 | 3.845 | 17.05 | 0 | 0 | 3 | 2 |
| 27.3 | 4 | 79.0 | 66 | 4.08 | 1.935 | 18.90 | 1 | 1 | 4 | 1 |
| 26.0 | 4 | 120.3 | 91 | 4.43 | 2.140 | 16.70 | 0 | 1 | 5 | 2 |
| 30.4 | 4 | 95.1 | 113 | 3.77 | 1.513 | 16.90 | 1 | 1 | 5 | 2 |
| 15.8 | 8 | 351.0 | 264 | 4.22 | 3.170 | 14.50 | 0 | 1 | 5 | 4 |
| 19.7 | 6 | 145.0 | 175 | 3.62 | 2.770 | 15.50 | 0 | 1 | 5 | 6 |
| 15.0 | 8 | 301.0 | 335 | 3.54 | 3.570 | 14.60 | 0 | 1 | 5 | 8 |
| 21.4 | 4 | 121.0 | 109 | 4.11 | 2.780 | 18.60 | 1 | 1 | 4 | 2 |
\begin{tabular}{r|lllllllllll}
mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
\hline
21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4 \\
21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4 \\
22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1 \\
21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1 \\
18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2 \\
18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1 \\
14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4 \\
24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2 \\
22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2 \\
19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4 \\
17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4 \\
16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3 \\
17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3 \\
15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3 \\
10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4 \\
10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4 \\
14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4 \\
32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1 \\
30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2 \\
33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1 \\
21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1 \\
15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2 \\
15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2 \\
13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4 \\
19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2 \\
27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1 \\
26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2 \\
30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2 \\
15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4 \\
19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6 \\
15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8 \\
21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2 \\
\end{tabular}
%% Cell type:code id: tags:
``` R
mtcars[,"disp"] # variable disp dans le data-frame "mtcars"
mtcars[["disp"]]
```
%%%% Output: display_data
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
\begin{enumerate*}
\item 160
\item 160
\item 108
\item 258
\item 360
\item 225
\item 360
\item 146.7
\item 140.8
\item 167.6
\item 167.6
\item 275.8
\item 275.8
\item 275.8
\item 472
\item 460
\item 440
\item 78.7
\item 75.7
\item 71.1
\item 120.1
\item 318
\item 304
\item 350
\item 400
\item 79
\item 120.3
\item 95.1
\item 351
\item 145
\item 301
\item 121
\end{enumerate*}
%%%% Output: display_data
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
\begin{enumerate*}
\item 160
\item 160
\item 108
\item 258
\item 360
\item 225
\item 360
\item 146.7
\item 140.8
\item 167.6
\item 167.6
\item 275.8
\item 275.8
\item 275.8
\item 472
\item 460
\item 440
\item 78.7
\item 75.7
\item 71.1
\item 120.1
\item 318
\item 304
\item 350
\item 400
\item 79
\item 120.3
\item 95.1
\item 351
\item 145
\item 301
\item 121
\end{enumerate*}
%% Cell type:code id: tags:
``` R
mtcars[1:4,] # Observations de toutes les variable sur les 4 premiers individus
```
%%%% Output: display_data
mpg | cyl | disp | hp | drat | wt | qsec | vs | am | gear | carb |
|---|---|---|---|
| 21.0 | 6 | 160 | 110 | 3.90 | 2.620 | 16.46 | 0 | 1 | 4 | 4 |
| 21.0 | 6 | 160 | 110 | 3.90 | 2.875 | 17.02 | 0 | 1 | 4 | 4 |
| 22.8 | 4 | 108 | 93 | 3.85 | 2.320 | 18.61 | 1 | 1 | 4 | 1 |
| 21.4 | 6 | 258 | 110 | 3.08 | 3.215 | 19.44 | 1 | 0 | 3 | 1 |
\begin{tabular}{r|lllllllllll}
mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
\hline
21.0 & 6 & 160 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4 \\
21.0 & 6 & 160 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4 \\
22.8 & 4 & 108 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1 \\
21.4 & 6 & 258 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1 \\
\end{tabular}
%% Cell type:code id: tags:
``` R
names(mtcars)
row.names(mtcars)
```
%%%% Output: display_data
1. 'mpg'
2. 'cyl'
3. 'disp'
4. 'hp'
5. 'drat'
6. 'wt'
7. 'qsec'
8. 'vs'
9. 'am'
10. 'gear'
11. 'carb'
\begin{enumerate*}
\item 'mpg'
\item 'cyl'
\item 'disp'
\item 'hp'
\item 'drat'
\item 'wt'
\item 'qsec'
\item 'vs'
\item 'am'
\item 'gear'
\item 'carb'
\end{enumerate*}
%%%% Output: display_data
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'
\begin{enumerate*}
\item '1'
\item '2'
\item '3'
\item '4'
\item '5'
\item '6'
\item '7'
\item '8'
\item '9'
\item '10'
\item '11'
\item '12'
\item '13'
\item '14'
\item '15'
\item '16'
\item '17'
\item '18'
\item '19'
\item '20'
\item '21'
\item '22'
\item '23'
\item '24'
\item '25'
\item '26'
\item '27'
\item '28'
\item '29'
\item '30'
\item '31'
\item '32'
\end{enumerate*}
%% Cell type:code id: tags:
``` R
dimnames(mtcars)
```
%%%% Output: display_data
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'
\begin{enumerate}
\item \begin{enumerate*}
\item '1'
\item '2'
\item '3'
\item '4'
\item '5'
\item '6'
\item '7'
\item '8'
\item '9'
\item '10'
\item '11'
\item '12'
\item '13'
\item '14'
\item '15'
\item '16'
\item '17'
\item '18'
\item '19'
\item '20'
\item '21'
\item '22'
\item '23'
\item '24'
\item '25'
\item '26'
\item '27'
\item '28'
\item '29'
\item '30'
\item '31'
\item '32'
\end{enumerate*}
\item \begin{enumerate*}
\item 'mpg'
\item 'cyl'
\item 'disp'
\item 'hp'
\item 'drat'
\item 'wt'
\item 'qsec'
\item 'vs'
\item 'am'
\item 'gear'
\item 'carb'
\end{enumerate*}
\end{enumerate}
%% Cell type:code id: tags:
``` R
summary(mtcars)
```
%%%% Output: display_data
%% Cell type:code id: tags:
``` R
ls()
```
%%%% Output: display_data
%% Cell type:markdown id: tags:
### 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**.
%% Cell type:code id: tags:
``` R
# Contenu de l'espace de travail
ls()
save(mtcars,file="data/mtcars.RData")
```
%%%% Output: display_data
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'
\begin{enumerate*}
\item 'a'
\item 'b'
\item 'cmat1'
\item 'cmat2'
\item 'd'
\item 'mtcars'
\item 'my\_character'
\item 'my\_integer'
\item 'my\_logical'
\item 'my\_numeric'
\item 'v'
\item 'vv'
\item 'w'
\item 'xx'
\end{enumerate*}
%% Cell type:markdown id: tags:
** Load**
%% Cell type:code id: tags:
``` R
rm(list=ls())
"espace de travail 1"
ls()
load("data/mtcars.RData")
"espace de travail 2"
ls()
```
%%%% Output: display_data
'espace de travail 1'
'espace de travail 1'
%%%% Output: display_data
%%%% Output: display_data
'espace de travail 2'
'espace de travail 2'
%%%% Output: display_data
'mtcars'
'mtcars'
%% Cell type:markdown id: tags:
## 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.
%% Cell type:markdown id: tags:
## Bibliothèques ou package
Un package ou une bibliothèque de programmes externes, est un ensemble de programme R, qui complète les fonctionnalités de R.
* Liste des package installés
%% Cell type:code id: tags:
``` R
library()
mat <- available.packages() # Packages disponibles (au CRAN)
```
%%%% Output: display_data
%% Cell type:markdown id: tags:
* Charger un package(si la librairie est déjà chargée, ne fait rien)
%% Cell type:code id: tags:
``` R
library(grDevices)
sessionInfo() # packages chargés en cours de session
```
%% Cell type:markdown id: tags:
* Liste des fonctions d'un package
%% Cell type:code id: tags:
``` R
library(help="stats") #fonctions du package "stats"
```
%% Cell type:markdown id: tags:
* Liste des datasets disponibles comme exemples sous R
%% Cell type:code id: tags:
``` R
data()
data(package="datasets") # Datasets pour le package datasets
```
%% Cell type:markdown id: tags:
### Installer package
Installation d'un package en tant qu'administrateur
install.packages("gplots") # sous root
### 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**. Ilfaudra mettre à jour R régulièrement.
### Créer ses propres packages
L'utilisateur peut créer ses propres packages(R avancé), les difuser sur le [CRAN](https://cran.r-project.org) ou pour l'usage de sa propre communuaté.
%% Cell type:markdown id: tags:
### Installer un package en local
Utilisation de la variable d'environnement **RLIBS** qui fournit le/les répertoire(s) d'installation en local des packages
export RLIBS="/home/yourusername/R/lib
install.packages("gplots") # en local dans R_LIBS
%% Cell type:code id: tags:
``` R
.libPaths() # liste des repertoires de recherche des librairies
```
%%%% Output: display_data
'/opt/conda/lib/R/library'
'/opt/conda/lib/R/library'
%% Cell type:markdown id: tags:
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
*RLIBS="/home/yourusername/R/lib"*
Vous pouvez indiquez plusieurs répertoires, séparés par **":"**
* Exécuter la fonction **.libPaths()** et observez.
%% Cell type:code id: tags:
``` R
.libPaths() # liste des repertoires de recherche des librairies
```
%%%% Output: display_data
'/opt/conda/lib/R/library'
'/opt/conda/lib/R/library'
%% Cell type:markdown id: tags:
* Ajouter un répertoire local
%% Cell type:markdown id: tags:
*.libPaths("<path du repertoire local>")*
Plusieurs répertoires possibles, séparés par ":".
%% Cell type:code id: tags:
``` R
.libPaths("/home/viryl/R/lib") # ajout d'un repertoire d'installation local
```
%% Cell type:code id: tags:
``` R
.libPaths()
```
%%%% Output: display_data
1. '/home/viryl/R/lib'
2. '/opt/conda/lib/R/library'
\begin{enumerate*}
\item '/home/viryl/R/lib'
\item '/opt/conda/lib/R/library'
\end{enumerate*}
%% Cell type:markdown id: tags:
## 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'interfcae 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
%% Cell type:code id: tags:
``` R
help(plot) # ou ?plot donne le même résultat.
```
%% Cell type:markdown id: tags:
- ** Sur les détails de programmation **
%% Cell type:code id: tags:
``` R
help("[[") # encadré d'une simple ou double quote
```
%% Cell type:code id: tags:
``` R
help("if"); help("for")
```
%% Cell type:markdown id: tags:
- 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.
2. On accède à une aide complète sur l'utilisation, l'installation de R dans l'onglet **Help** de **RStudio**.
3. De nombreux tutoriaux sur internet.
%% Cell type:code id: tags:
``` R
help.search("correlation ")
```
%% Cell type:code id: tags:
``` R
apropos("NA")
```
%% Cell type:markdown id: tags:
### Bibliographie
#### Sites Web
* [Site RStudio](https://www.rstudio.com/online-learning)
* [Using RStudio IDE](https://support.rstudio.com/hc/en-us/sections/200107586-Using-the-RStudio-IDE)
* [Introduction à R (MOOC - Introduction à la statistique avec R](https://www.fun-mooc.fr/c4x/UPSUD/42001S03/asset/introR.html)
* [Introduction à R et au tidyverse](https://juba.github.io/tidyverse/index.html)
* [Cours complet sur l'analyse de données (MOOC)](http://factominer.free.fr/course/MOOC_fr.html)
* [Data Science](https://www.rstudio.com/online-learning/#DataScience)
#### Livres
* [Hands-On Programming with R - Write Your Own Functions and Simulations (Garrett Grolemund)](http://shop.oreilly.com/product/0636920028574.do#)
* [Training books](https://www.rstudio.com/resources/training/books/)
%% Cell type:markdown id: tags:
......
This diff is collapsed.
This diff is collapsed.
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment