---
title: "Initiation à R"
author: "Sébastien Déjean"
date: "Octobre 2020"
output:
  html_document: 
    toc: yes
  pdf_document:
    toc: yes
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

# Introduction : comment travailler avec R

## Installation

R est un logiciel libre et gratuit. Il est téléchargeable à l'adresse [cran.r-project.org](https://cran.r-project.org) pour les principaux système d'exploitation Windows, Mac et Linux.

## RStudio

Il est recommandé d'utiliser un environnement de développement qui simplifie le travail avec R. RStudio est un produit commercial et payant mais une version gratuite (légalement) est disponible au téléchargement à l'adresse [rstudio.com](https://rstudio.com).

## Environnement et espace de travail

* Les objets manipulables dans R (variables créées, jeux de données importées, résultats de fonction...) peuvent être stockés dans un **espace de travail**  (*workspace*) qui apparaîtra dans le **répertoire de travail** (*working directory*) comme un fichier `.RData`.
	
* On peut charger un **espace de travail** avec `load()`, lister son contenu avec `ls()` et le sauvegarder avec `save()` ou `save.image()`.
	
* On peut connaître le **répertoire de travail** courant grâce à la commande `getwd()` et le modifier avec `setwd()`.
	
* Le contenu du **répertoire de travail** (c'est à dire la liste des fichiers telle qu'elle peut apparaître dans un explorateur ou gestionnaire de fichiers) est accessible avec la commande `dir()`.

Ces opérations sont également réalisables au moyen des menus disponibles dans RStudio.

## Aide

L'aide est accessible par un appel à la fonction `help()` ou en utilisant le raccourci `?`. Par exemple, l'aide de la fonction `plot()` est accessible par `help(plot)` ou `?plot`.

De manière générale, une fiche d'aide est composée des rubriques suivantes :

* Description
* Usage
* Arguments
* Details
* Value
* Note
* Authors
* Reference(s)
* See also
* Examples


Le nom de ces rubriques est suffisamment explicite pour désigner ce qu'elle contient. Pour un utilisateur non expérimenté, les deux dernières rubriques sont certainement les plus utiles : `See also` permet d'apprendre le nom de nouvelles fonctions en relation avec la recherche initiale et `Examples` permet de manipuler immédiatement, par copier-coller, toute nouvelle fonction.

La fonction `help.search()` (raccourcie en `??`) permet de rechercher dans l'aide en ligne les fonctions en rapport avec un terme (chaîne de caractères) passé en paramètres. Pour tout savoir sur les fonctions en relation avec le tracé de graphiques, on pourra par exemple saisir `help.search("plot")` ou `??plot`.

Et pour comprendre comment fonctionne `help.search()`, on pourra bien entendu entrer `help(help.search)` et même `help(help)` pour savoir comment utiliser la fonction `help()` !

> **Tout au long de ce document, vous êtes vivement encouragés à consulter la fiche d'aide de toutes les fonctions utilisées.**

### Les **cheat sheets**

Un aide précieuse est apportée par les **cheat sheet** que de plus en plus de développeurs de packages proposent à destination de leurs utilisateurs. Il s'agit de *feuilles de triche*, disons plutôt, *fiche de révision* ou *aide-mémoire* qui synthétisent des informations sur les principales functions d'un package. Le site de RStudio en propose quelques-unes à cette adresse [rstudio.com/resources/cheatsheets](https://rstudio.com/resources/cheatsheets).

## Utilisation de packages

Les *packages* sont des ensembles de fonctions (et parfois de données) proposés par la communauté des utilisateurs de `R` et permettant d'accomplir des tâches spécifiques.

L'utilisation d'une fonction incluse dans un package nécessite 2 étapes préalables (réalisables via le menu `Packages` de Rstudio) :

* L'**installation** : utiliser la fonction `install.packages()` pour récupérer les sources du package et les installer. Cette opération ne doit être accomplie qu'une seule fois.

* Le **chargement** : utiliser la fonction `library(NomDuPackage)` pour charger le package et l'utiliser durant une session. Cette opération est à renouveler chaque fois que l'on souhaite utiliser un package.

Il est recommandé de procéder régulièrement à une mise à jour des packages (menu `Packages` ou fonction `update.packages()`).

## R Markdown

Le système **R Markdown** permet de rassembler en un fichier unique l'ensemble des commandes R utilisées et les commentaires associés. Une compilation de ce fichier fournit une sortie au format pdf, html ou Word incluant également les sorties numériques et graphiques générées par les commandes. Son utilisation est relativement simple dans RStudio. Un exemple dont il est fortement recommandé de s'inspirer pour démarrer est disponible lorsque l'on demande la création d'un nouveau fichier R Markdown dans le menu File (Fichier) de RStudio. Un clic sur le bouton *Knit* assurer la compilation du fichier et la production de la sortie au format souhaité.

Le présent document a été préparé avec R Markdown.

# Structures de données

## Type de données

### Numérique, caractère, logique

R peut gérer des données numériques, des chaînes de caractères ainsi que des valeurs logiques TRUE / FALSE.

```{r}
2+2
2.5+1.56
"hello"
1 > 2
```

Cette caractéristique d'un objet R peut être testée avec des fonctions *ad hoc*.

```{r}
is.numeric(2)
is.numeric(2.5)
is.numeric("hello")
is.character("hello")
is.logical(1>2)
```

La fonction `typeof` permet d'identifier le type d'un objet.

```{r}
typeof(2)
typeof("bonjour")
typeof(TRUE)
```

### Données manquantes

Les données manquantes sont codées `NA` pour Not Available.

```{r}
NA
is.na(NA)
```

Il est important de les repérer et d'identifier comment une fonction réagit en cas de données manquantes.

### Les dates

Les dates sont un cas particulier de données. On peut les manipuler dans R avec des outils spécifiques.

```{r}
date()
armistice <- as.Date("1918-11-11")
weekdays(armistice)
months(armistice)
quarters(armistice)
aujourdhui <- as.Date("2020-10-15")
aujourdhui-armistice
```

> **L'opérateur `<-` permet de stocker le résultat d'une commande dans un objet.**

Cette opération n'implique pas une visualisation du contenu de l'objet. Il faut pour cela saisir le nom de l'objet pour voir son contenu (voir l'exemple ci-dessous avec l'objet `UnVecteur`).

## Vecteur - `vector`

Un vecteur est un objet qui contient un ou plusieurs éléments **du même type**.

### Des valeurs numériques

```{r}
UnVecteur <- c(2,5,9,8,12)
UnVecteur
UnAutreVecteur <- 1:24
EncoreUn <- rep(5, times = 10)
EtUnDernier <- seq(from=1, to=60, by=7)
length(EtUnDernier)
```

Une donnée manquante ne pose pas de problème dans un vecteur.

```{r}
UnVecteurAvecNA <- c(2,5,NA,9,8,12,NA)
UnVecteurAvecNA
```

Pour extraire tous les éléments différents de 9 dans un vecteur.

```{r}
UnVecteur[UnVecteur != 9]
```

### Des chaînes de caractères

```{r}
UnePhrase <- c("Bonjour","les","amis")
UnePhrase
length(UnePhrase)
```

La fonction `length` renvoie le nombre d'éléments du vecteur, pas le nombre de caractères d'une chaîne de caractères. Pour cela, on peut utiliser la fonction `nchar` qui, utilisée sur un vecteur, renvoit le nombre de caractères de chaque élément du vecteur (voir plus loin).

```{r}
nchar(UnePhrase)
```


### Des valeurs logiques

```{r}
VraiouFaux <- c(TRUE, TRUE, FALSE, TRUE, FALSE)
VraiouFaux
```

### Mais pas de mélange

```{r}
UnEssai <- c(2,3,"bonjour")
UnEssai
```

La commande ci-dessus ne renvoie pas d'erreur mais les guillements autour de 2 et 3 indiquent que R a converti tous les éléments du vecteur en chaîne de caractères. C'est en effet le format dans lequel R a su rassembler tous les éléments du vecteur. Convertir la valeur numérique `2` en la chaîne de caractères `"2"` est possible ; convertir la chaîne de caractères `"bonjour"` en numérique ne l'est pas.

### Opérations sur un vecteur

On peut appliquer des opérations à un vecteur. Elles s'appliqueront pour tous les éléments.

```{r}
EtUnDernier * 10
log(EtUnDernier)
UnVecteurAvecNA^2
UnVecteur > 5
nchar(UnePhrase)
```

### Sélection de parties d'un vecteur

La sélection de parties d'un vecteur se fait en utilisant l'opérateur `[]`.

```{r}
UnVecteur[1:3] # les 3 premiers éléments
UnVecteur[-2] # tous les éléments sauf le 2ème
UnVecteur[c(1,3)] # les 1er et 3ème éléments
```


## Facteur - `factor`

Les facteurs ressemblent beaucoup à des vecteurs de chaînes de caractères, mais il dispose de modalités pré-définies.

```{r}
MesCategories <- c("Rien","Peu","Beaucoup","Tout")
MesCategories
RecueilAvis <-
  sample(x = MesCategories, size=20, replace=TRUE)
RecueilAvis
```

La ligne ci-dessus réalise un tirage aléatoire de taille 20 (`size=20`) avec remise (`replace=TRUE`) à partir du vecteur de chaînes de caractères de longueur 4 `MesCategories`.

```{r}
RecueilAvisFactor <- factor(
  x = RecueilAvis,
  levels = MesCategories)
levels(RecueilAvisFactor)
```

La ligne ci-dessous renvoie une erreur car `Plein` ne fait pas partie des niveaux du facteur 

```{r eval=FALSE}
RecueilAvisFactor[3] <- "Plein"
```

alors qu'une commande similaire sur un vecteur de chaîne de caractères ne pose aucun problème.

```{r}
RecueilAvis[3] <- "Plein"
RecueilAvis
```

A noter qu'une catégorie peut très bien ne pas apparaître dans un échantillonnage. Dans ce cas, le comptage des occurrences de chaque catégorie fera apparaître un 0 dans la catégorie correspondante.

```{r}
EssaiFactor <- factor(c("Peu","Rien","Beaucoup","Rien","Peu"),
                      levels = MesCategories)
table(EssaiFactor)
table(c("Peu","Rien","Beaucoup","Rien","Peu"))
```

## Matrice - `matrix`

Pour faire simple : une matrice est un vecteur à 2 dimensions. Comme le vecteur, elle n'autorise que des éléments du même type. La sélection de partie d'une matrice se fait avec 2 indices fournis entre crochets: `[ligne,colonne]`.

```{r}
UneMatrice <- matrix(1:24, ncol=3)
UneMatrice
UneAutreMatrice <- UneMatrice
UneAutreMatrice[2,3] <- "mot"
UneAutreMatrice
UneMatrice[5:7,1:2]
```

## Liste - `list`

A l'opposé du vecteur et de la matrice, un objet de type `list` permet de stocker des éléments de natures différentes.

```{r}
MaListe <- list(Mot = "chien", Nombre = 8,
                VecteurNum = 1:6, Matrice = UneMatrice)
MaListe
names(MaListe)
MaListe$Mot
MaListe$VecteurNum
MaListe$VecteurNum * 10
```

> **L'opérateur `$` permet d'accéder aux différents composents d'un objet de type `list `.**

La `list` est une structure de données très utile en R pour renvoyer les différents éléments du résultat d'une fonction. Consulter par exemple l'aide de la fonction `t.test` qui met en oeuvre le test de Student pour constater que la rubrique `Value` mentionne : `A list with class "htest" containing the following components...`

## Tableau de données - `data.frame`

Le `data.frame`, comme son nom l'indique, est une structure pour stocker des données. Ce type hérite à la fois de la matrice (les données sont dans une structure rectangulaire caractérisée par des lignes et des colonnes) et de la liste (les colonnes d'un `data.frame` peuvent contenir des données de natures différentes).

```{r}
taille <- round(runif(20,150,180),1)
masse <- round(runif(20,50,90),1)
coul.yeux <- c("bleu","noir","vert","marron")
coul.cheveux <- c("blond","chatain","noir")
yeux <- sample(coul.yeux,20,replace=T)
cheveux <- sample(coul.cheveux, 20, rep = TRUE)
table(yeux)
table(cheveux)
table(yeux, cheveux)
MonDataFrame <- data.frame(taille,masse,yeux,cheveux)
MonDataFrame
MonDataFrame$taille
MonDataFrame$yeux
IMC <- MonDataFrame$masse / MonDataFrame$taille^2
```

### `tibble`

Les `tibble` sont une évolution récente de la structure `data.frame`, ils rendent la manipulation de jeux de données plus efficaces. Pour utiliser les tibbles et leurs fonctionnalités associées, il faut au préalable installer le package `install.packages("tibble")` ou la suite des packages `tidyverse` que nous utiliserons plus loin.

```{r}
library(tibble)
iris.tib <- as_tibble(iris)
iris.tib
iris
```

Une des différences majeures avec les `data.frame` réside dans l'affichage qui est limité aux 10 premières lignes.

A noter également que l'affichage tient compte du nombre de colonnes à afficher.

# Importation / exportation de données

## Les fonctions de base

### Exportation

Commençons par l'exportation car cela nous simplifie les exemples à suivre pour l'importation. La fonction de base pour exporter des données au format texte est `write.table`.

```{r}
write.table(MonDataFrame, "Fichier_MonDataFrame.txt")
dir()
```

Sans précision d'un chemin, le fichier .txt ainsi créé apparaît dans le répertoire de travail. Ce que l'on peut vérifier au moyen de la commande `dir` ou dans le panneau Files de RStudio.

On peut ensuite jouer avec les paramètres pour modifier le séparateur (`sep`), la présence d'un entête (`col.names`) ou de noms de ligne (`row.names`)... ou utiliser les fonctions associées `write.csv` et `write.csv2` qui proposent des paramétrages par défaut différents.

```{r}
write.csv(MonDataFrame, "Fichier_MonDataFrame.csv")
write.csv2(MonDataFrame, "Fichier_MonDataFrame_V2.csv")
```

### Importation

Nous allons maintenant jouer la partition dans l'autre sens en important les données des fichiers précédemment créés.

Commençons par effacer le data.frame `MonDataFrame` et recréons le data.frame en important les fichiers.

```{r}
rm(MonDataFrame)
```

```{r}
MonDataFrameLeRetourTxt <- read.table("Fichier_MonDataFrame.txt")
MonDataFrameLeRetourTxt
```

Tout semble s'être bien passé. Et les autres versions ?

```{r}
MonDataFrameLeRetourCsv <- read.table("Fichier_MonDataFrame.csv")
MonDataFrameLeRetourCsv
```

Hum, hum, petit souci, non ?

```{r}
MonDataFrameLeRetourCsvOK <- read.table("Fichier_MonDataFrame.csv", sep=",",
                                      header = TRUE, row.names=1)
MonDataFrameLeRetourCsvOK
```

C'est mieux non ? Le même résultat est accessible avec 

```{r}
MonDataFrameLeRetourCsvOK2 <- read.csv("Fichier_MonDataFrame.csv")
```

Et de la même façon avec la fonction `read.csv2` pour importer le fichier avec le `;` comme séparateur de champs et la `,` comme séparateur décimal.

Pour choisir la bonne fonction et son paramétrage, il est vivement recommandé de regarder le fichier à importer dans un éditeur de texte (Bloc-Notes, gedit, emacs...) et pas dans un tableur qui ne montrera pas le séparateur de champs.

## Des packages spécifiques


### `readr`

Le package `readr` propose une évolution des fonctions d'importation (et d'exportation) de fichiers au format texte. Il dispose d'une *cheat sheet* (data-import) présentant ses fonctions principales. Après installation et chargement du package, un coup d'oeil à l'aide en ligne permet de compléter la vue sur les possibilités de ce package.


### `readxl`

Comme son nom l'indique, le package `readxl` permet d'importer des fichiers Excel aux formats xls et xlsx. Les fonctions `read_excel`, `read_xls` et  `read_xlsx` permettent d'importer certaines feuilles d'un classeur Excel, certaines plages de données...

Installer et charger le package puis consulter l'aide en ligne des fonctions pour voir les spécificités proposées.

### `haven`

Le package `haven` permet d'importer des fichiers données dans des formats propres à d'autres logiciels de statistique : SPSS, Stat et SAS. Cela peut être grandement utile lorsque l'on ne dispose plus de ces logiciels pour convertir les données dans un format texte.

## Avec RSudio

L'importation des données peut aussi se faire en utilisant le menu *Import Dataset* de l'onglet Environment. Il s'agit d'une interface vers les packages cités précédemment. Le code équivalant à la manipulation de l'interface graphique est fourni à l'utilisateur.

Même si l'importation par le menu semble plus simple d'accès, il est à noter qu'une telle manipulation n'est pas reproductible, à l'inverse d'une ligne de commande que l'on pourra exécuter à nouveau (à condition de ne pas avoir déplacé le fichier à importer).


# Manipulation de tableaux de données

Récupérons, pour commencer, un data frame au nom plus court.

```{r}
MonDataFrame <- MonDataFrameLeRetourTxt
```


## Agir sur les lignes

### Ajouter des lignes

Pour ajouter des lignes à un tableau de données, on peut utiliser la fonction `rbind`.

```{r}
MonDataFrame2 <- data.frame(taille = round(runif(5,150,180),1),
                           masse = round(runif(5,50,90),1),
                           yeux = sample(coul.yeux,5,replace=T),
                           cheveux = sample(coul.cheveux, 5, rep = TRUE))
MonDataFrameComplet <- rbind(MonDataFrame, MonDataFrame2)
dim(MonDataFrameComplet)
MonDataFrameComplet
```

On a ainsi ajouter 5 lignes supplémentaires à l'objet `MonDataFrame` en concaténant `MonDataFrame` et `MonDataFrame2`. Cette opération n'est possible que parce que le nombre de colonnes est le même dans les 2 data.frame que l'on a collé en ligne.

```{r eval=FALSE}
rbind(MonDataFrame, MonDataFrame2[,1:3])
```

Cette commande renvoie un erreur car les 2 objets que l'on souhaite coller n'ont pas le même nombre de colonnes.

### Supprimer des lignes

La suppression de ligne se fait en écrasant le contenu du data.frame courant ou en le stockant dans un autre data.frame (ce qui semble plus sûr), en procédant par exemple ainsi :

```{r}
MonDataFrameSuppr <- MonDataFrame[-(1:5),]
MonDataFrameSuppr
```

Les 5 premières lignes ont été supprimées et le data.frame résultant stocké dans le fichier `MonDataFrameSuppr`.

Pour sélectionner des lignes non consécutives, on peut utiliser la fonction `c`.

```{r}
MonDataFrameSuppr <- MonDataFrame[-c(1,2,14,17),]
MonDataFrameSuppr
```

Le paragraphe qui suit permet également de filtrer les lignes d'un tableau de données selon différents critères.

### Sélectionner des lignes

Pour sélectionner des lignes, la fonction `filter` du package `dplyr` propose des solutions relativement simples et intuitives. Pour être certain d'utiliser la fonction du package `dplyr`, et pas une fonction portant le même nom dans un autre package, on peut le mentionner explicitement avec l'opérateur `::`.

```{r warning=FALSE, message=FALSE}
library(dplyr)
dplyr::filter(MonDataFrame, yeux=="noir")
filter(MonDataFrame, taille > 165)
filter(MonDataFrame, between(masse, 65, 70))
filter(MonDataFrame, taille < 170 & cheveux=="blond")
filter(MonDataFrame, taille < 170 & (cheveux=="blond" | cheveux=="chatain"))
dim(MonDataFrame)
```

Noter que ces commandes ne modifient pas l'objet `MonDataFrame` et, si on souhaite conserver un extrait des données dans un autre objet, il faut le demander avec l'opérateur `<-`.

```{r}
MonDataFrameExtraitTailleSup165 <- filter(MonDataFrame, taille > 165)
MonDataFrameExtraitTailleSup165
```


## Agir sur les colonnes

Les commandes vues ici sont similaires à celles vues précédemment pour la manipulation des lignes.

### Ajouter des colonnes

De façon analogue à `rbind`, la fonction `cbind` permet de coller côte-à-côte deux tableaux de données ayant le même nombre de lignes.

```{r}
ComplementMonDataFrame <- data.frame(
  Avis = sample(c("OK","NOK"), size=20, replace=TRUE),
  Note = sample(0:20, size=20, replace = TRUE))
MonDataFramePlusDeColonnes <- cbind(MonDataFrame, ComplementMonDataFrame)
MonDataFramePlusDeColonnes
```

### Supprimer des colonnes

La suppression de colonnes peut là aussi se gérer de la même façon que la suppression de lignes.

```{r}
MonDataFrameSupprCol <- MonDataFrame[,-c(1,3)]
MonDataFrameSupprCol
```


### Sélectionner des colonnes

La fonction `select` du package `dplyr`


```{r}
select(MonDataFrame, taille)
select(MonDataFrame, taille, masse)
select(MonDataFrame, ends_with("eux"))
```

Sur le jeu de données `iris`.

```{r}
select(iris, starts_with("Petal"))
select(iris.tib, starts_with("Petal"))
select(iris, contains("Width"))
```

Pour stocker les résultats d'une telle sélection, il suffit d'assigner le résultat de la commande à un objet.

```{r}
MonDataFrameCouleurs <- select(MonDataFrame, ends_with("eux"))
MonDataFrameCouleurs
```


## Fusionner des tableaux de données

Commençons par avoir deux tableaux de données avec un identifiant commun (`Prenom`) ; les 2 tableaux étant dans des ordres différents.

```{r}
Prenom <- c("Emmma","Gabriel","Louise","Raphael","Alice","Leo","Chloe","Louis",
            "Lina","Lucas","Rose","Adam","Lea","Arthur","Anna","Hugo","Mila",
            "Jules","Mia","Mael")
MonDataFramePrenom <- cbind(Prenom, MonDataFrame)
UnAutreDataFramePrenom <- data.frame(Prenom = sort(Prenom), Note = 1:20)
MonDataFramePrenom
UnAutreDataFramePrenom
```

La fusion des 2 tableaux de données peut se réaliser au moyen de la fonction `merge`.

```{r}
merge(MonDataFramePrenom, UnAutreDataFramePrenom)
merge(UnAutreDataFramePrenom, MonDataFramePrenom)
```

*By default the data frames are merged on the columns with names they both have.*

- Si les colonnes ne portent pas le même nom, il faut le préciser, sinon cela va poser problème...

```{r}
UnAutreDataFramePrenom <- data.frame(FirstName = sort(Prenom), Note = 1:20)
UnAutreDataFramePrenom
merge(MonDataFramePrenom, UnAutreDataFramePrenom)
merge(MonDataFramePrenom, UnAutreDataFramePrenom,
      by.x = "Prenom", by.y = "FirstName")
```

- Les 2 tableaux peuvent ne pas avoir le même nombre de lignes. Dans ce cas, il faut préciser sur quel tableau on souhaite s'aligner.

```{r}
UnAutreDataFramePrenom <- data.frame(FirstName = sort(Prenom[1:18]), Note = 1:18)
EssaiMerge1 <- merge(MonDataFramePrenom, UnAutreDataFramePrenom,
      by.x = "Prenom", by.y = "FirstName")
dim(EssaiMerge1)
EssaiMerge1
```

Noter ici que l'on a perdu 2 éléments car le data.frame `UnAutreDataFramePrenom` n'a que 18 lignes.

Pour conserver les 20 lignes du data.frame `MonDataFramePrenom`, il faut le spécifier.

```{r}
EssaiMerge2 <- merge(MonDataFramePrenom, UnAutreDataFramePrenom,
      by.x = "Prenom", by.y = "FirstName", all.x=TRUE)
dim(EssaiMerge2)
EssaiMerge2
```

On peut alors constater que les données correpondant aux 2 individus manquants ont été notées comme NA (données manquantes).


Le package `dplyr` propose un ensemble de fonctions permettant de fusionner des tableaux dans des circonstances plus spécifiques et moins favorables.

# Un peu de statistique

## Statistique univariée

### La fonction `summary`

```{r}
summary(MonDataFrame)
```

Si les variables sont enregistrées comme des facteurs, le summary est plus intéressant.

```{r}
MonDataFrame$yeux <- as.factor(MonDataFrame$yeux)
MonDataFrame$cheveux <- as.factor(MonDataFrame$cheveux)
summary(MonDataFrame)
```


### Tri à plat, tri croisé

```{r}
table(MonDataFrame$yeux)
table(MonDataFrame$yeux, MonDataFrame$cheveux)
```

### La fonction `apply`

```{r}
apply(MonDataFrame[,1:2], 2 , mean)
apply(MonDataFrame[,1:2], 2 , var)
apply(MonDataFrame[,1:2], 2 , sd)^2
```


## Statistique bivariée

Le calcul d'indicateurs de liaison entre deux variables quantitatives est possible à l'aide des fonctions `cov` et `cor`.

```{r}
cov(MonDataFrame$taille, MonDataFrame$masse)
MyCor <- cor(MonDataFrame$taille, MonDataFrame$masse)
round(MyCor, digits = 2)
cor(MonDataFrame$taille, MonDataFrame$masse, method="spearman")
cor(MonDataFrame$taille, MonDataFrame$masse, method="kendall")
```

Face à un data.frame, ces fonctions renvoient l'ensemble de la matrice de covariance ou de corrélation, entre les colonnes deux-à-deux.

Sur les données `iris` restreintes aux 4 premières colonnes (la cinquième n'étant pas quantitative), cela donne. 
```{r}
cov(iris[,1:4])
round(cor(iris[,-5]),3)
```

## Représentations graphiques

L'ensemble des représentations graphiques classiques sont disponibles dans R. 

### Pour les effectifs selon les modalités d'un variable qualitative

```{r}
EffectifCouleurYeux <- table(MonDataFrame$yeux)
barplot(EffectifCouleurYeux)
EffectifCouleurCheveux <- table(MonDataFrame$cheveux)
barplot(EffectifCouleurCheveux, col = c("yellow","brown","black"))
pie(EffectifCouleurCheveux, col = c("yellow","brown","black"))
```

Les graphiques sont très fortement personnalisables. Les exemples de l'aide en ligne des fonctions proposées en proposent des illustrations diverses et variées.

## Pour des variables quantitatives

```{r}
boxplot(MonDataFrame$taille)
hist(MonDataFrame$masse)
boxplot(iris[,-5])
boxplot(iris[,-5], las=3)
boxplot(iris$Sepal.Length~iris$Species)
```

Là aussi, de nombreuses options permettent de personnaliser ces graphiques.

### ggplot2

Le package `ggplot2` propose une autre approche pour la réalisation de graphiques. Elle est basée sur une nouvelle *grammar of graphics** (le gg de `ggplot2`). En voici une petite illustration.

```{r}
library(ggplot2)
ggplot(data = iris,aes(x=Sepal.Length, y=Sepal.Width)) + geom_point()
ggplot(data = iris,aes(x=Sepal.Length, y=Sepal.Width, colour=Species)) +
  geom_point()
```

Pour en savoir plus, un livre consacré à `ggplot2` est disponible en ligne : [ggplot2-book.org](https://ggplot2-book.org).

# Etude de cas

Les données que nous regardons ici sont disponibles et décrites à cette adresse : 
[data.enseignementsup-recherche.gouv.fr/explore/dataset/fr-esr-parcours-des-bacheliers-en-paces/information/](https://data.enseignementsup-recherche.gouv.fr/explore/dataset/fr-esr-parcours-des-bacheliers-en-paces/information/)

## Importation des données

```{r}
library(readr)
fr_esr_parcours_des_bacheliers_en_paces <- read_csv2("fr-esr-parcours-des-bacheliers-en-paces.csv")
```

## Premier aperçu

```{r}
fr_esr_parcours_des_bacheliers_en_paces
summary(fr_esr_parcours_des_bacheliers_en_paces)
```

Un souci vient du fait que les colonnes comportant des chaînes de caractères (ou des codes) ont été (logiquement) importées au format `character`. Or, il semblerait préférable d'avoir des colonnes de `factor`. On va reprendre l'importation en spécifiant cela au moyen du paramètre `col_types`.

## Importation des données : le retour

Utilisons donc l'argument `col_types`. L'aide en ligne de la fonction `read_delim` ou de la fonction `read_csv2` indique plusieurs façons de procéder. Nous utilisons ici l'option compacte en donnant une chaîne de caractères indiquant que les 9 premières colonnes contiennent des données de type `factor` et les 10 suivantes, des données de type `double`.

```{r}
fr_esr_parcours_des_bacheliers_en_paces <- read_csv2("fr-esr-parcours-des-bacheliers-en-paces.csv", 
                      col_types = "fffffffffdddddddddd")
```



## Premier aperçu : le retour

```{r}
fr_esr_parcours_des_bacheliers_en_paces
summary(fr_esr_parcours_des_bacheliers_en_paces)
```

Noter que les résultats de la fonction `summary` sont maintenant beaucoup plus informatifs notamment concernant les variables catégorielles.


## Quelques analyses descriptives

### Représentations graphiques

```{r}
Effectif_Serie <- table(fr_esr_parcours_des_bacheliers_en_paces$`Série ou type de Bac`)
Effectif_Serie
barplot(Effectif_Serie, las=3, cex.names=0.65)
pie(Effectif_Serie, las=3, cex.names=0.65)
```

### Tests statistiques

On peut par exemple tester l'égalité des proportions dans les séries selon le sexe.

```{r}
Effectif_Serie_Sexe <- table(fr_esr_parcours_des_bacheliers_en_paces$`Série ou type de Bac`, fr_esr_parcours_des_bacheliers_en_paces$Sexe)
Effectif_Serie_Sexe
chisq.test(Effectif_Serie_Sexe)
fisher.test(Effectif_Serie_Sexe)
```

# Conclusion

Il va de soi que le présent document ne présente qu'une infime partie des analyses statistiques qu'il est possible de réaliser avec R. Mais les principes de base étant maintenant présentés, il n'y a plus qu'à se lancer...