fusion-de-tables.Rmd

---
title: "Fusion de tables"
---

```{r options_communes, include=FALSE}
source("options_communes.R")
```

Lorsqu'on traite de grosses enquêtes, notamment les enquêtes de l'INSEE, on a souvent à gérer des
données réparties dans plusieurs tables, soit du fait de la construction du questionnaire, soit du fait de
contraintes techniques (fichiers **dbf** ou **Excel** limités à 256 colonnes, par exemple).

Cela arrive également lorsque l'on traitre de données d'une enquêtes réalisée à différents niveaux (par exemple, un questionnaire ménage et un questionnaire individu).

## La fonction merge

Une opération relativement courante consiste à 
<dfn data-index="fusion de tables">fusionner</dfn><dfn data-index="tableau de données, fusion"></dfn>
plusieurs tables pour regrouper tout ou
partie des données dans un unique tableau.

Nous allons simuler artificiellement une telle situation en créant deux tables à partir de l'extrait de
l'enquête *Histoire de vie* :

```{r}
library(questionr)
data(hdv2003)
d <- hdv2003
dim(d)
d1 <- subset(d, select = c("id", "age", "sexe"))
dim(d1)
d2 <- subset(d, select = c("id", "clso"))
dim(d2)
```

On a donc deux tableaux de données, `d1` et `d2`, comportant chacun 2000 lignes et respectivement 3 et
2 colonnes. Comment les rassembler pour n'en former qu'un ?

Intuitivement, cela paraît simple. Il suffit de « coller » `d2` à la droite de `d1`, comme dans l'exemple
suivant.

<style type="text/css">
table.exemple_df td, 
table.exemple_df th {
  text-align: center;
  padding: 3px 10px;
}
table.exemple_df th {
  border-bottom: solid 1px #999;
}

table.exemple_df td + td,
table.exemple_df th + th {
  border-left: solid 1px #999;
}

table.exemple_operateur td {
  font-size: 3em;
  padding: 20px;
}
</style>

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>12</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>17</td>
</tr>
<tr>
  <td>3</td><td>F</td><td>41</td>
</tr>
<tr>
  <td>4</td><td>F</td><td>9</td>
</tr>
<tr>
  <td>...</td><td>...</td><td>...</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v3</th>
</tr>
<tr>
  <td>1</td><td>rouge</td>
</tr>
<tr>
  <td>2</td><td>bleu</td>
</tr>
<tr>
  <td>3</td><td>bleu</td>
</tr>
<tr>
  <td>4</td><td>rouge</td>
</tr>
<tr>
  <td>...</td><td>...</td><td>...</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th><th>v3</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>12</td><td>rouge</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>17</td><td>bleu</td>
</tr>
<tr>
  <td>3</td><td>F</td><td>41</td><td>bleu</td>
</tr>
<tr>
  <td>4</td><td>F</td><td>9</td><td>rouge</td>
</tr>
<tr>
  <td>...</td><td>...</td><td>...</td><td>...</td>
</tr>
</table>
</td>

</tr>
</table>

Cela semble fonctionner. La fonction qui permet d'effectuer cette opération sous **R** 
s'appelle `cbind`{data-pkg="base"}, elle « colle » des tableaux côte à côte en regroupant 
leurs colonnes^[L'équivalent de `cbind`{data-pkg="base"} pour les lignes s'appelle 
`rbind`{data-pkg="base" data-rdoc="cbind"}.].

```{r}
head(cbind(d1, d2))
```

À part le fait qu'on a une colonne *id* en double, le résultat semble satisfaisant. À première vue
seulement. Imaginons maintenant que nous avons travaillé sur `d1` et `d2`, et que nous avons ordonné les
lignes de `d1` selon l'âge des enquêtés :

```{r}
d1 <- d1[order(d1$age), ]
```

Répétons l'opération de collage :

```{r}
head(cbind(d1, d2))
```

Que constate-t-on ? La présence de la variable *id* en double nous permet de voir que les identifiants
ne coïncident plus ! En regroupant nos colonnes nous avons donc attribué à des individus les réponses
d'autres individus.

La commande `cbind`{data-pkg="base"} ne peut en effet fonctionner que si les deux tableaux ont exactement
le même nombre de lignes, et dans le même ordre, ce qui n'est pas le cas ici.

On va donc être obligé de pocéder à une <dfn>fusion</dfn> des deux tableaux, qui va permettre de rendre à
chaque ligne ce qui lui appartient. Pour cela nous avons besoin d'un identifiant qui permet d'identifier
chaque ligne de manière unique et qui doit être présent dans tous les tableaux. Dans notre cas, c'est
plutôt rapide, il s'agit de la variable *id*.

Une fois l'identifiant identifié^[Si vous me passez l'expression...], 
on peut utiliser la commande `merge`{data-pkg="base"}. Celle-ci va fusionner les deux
tableaux en supprimant les colonnes en double et en regroupant les lignes selon leurs identifiants :

```{r}
d.complet <- merge(d1, d2, by = "id")
head(d.complet)
```

Ici l'utilisation de la fonction `merge`{data-pkg="base"} est plutôt simple car nous sommes 
dans le cas de figure idéal : les lignes correspondent parfaitement et l'identifiant est clairement 
identifié. Parfois les choses peuvent être un peu plus compliquées :

* parfois les identifiants n'ont pas le même nom dans les deux tableaux. On peut alors les spécifier
  par les options `by.x` et `by.y` ;
* parfois les deux tableaux comportent des colonnes (hors identifiants) ayant le même nom. 
  `merge`{data-pkg="base"} conserve dans ce cas ces deux colonnes mais les renomme en 
  les suffixant par *.x* pour celles provenant du premier tableau et *.y* pour celles du second ;
* parfois on n'a pas d'identifiant unique préétabli, mais on en construit un à partir de plusieurs
  variables. On peut alors donner un vecteur en paramètres de l'option `by`, par exemple
  `by=c("nom","prenom","date.naissance")`.
  
Une subtilité supplémentaire intervient lorsque les deux tableaux fusionnés n'ont pas exactement les
mêmes lignes. Par défaut, `merge`{data-pkg="base"} ne conserve que les lignes présentes dans les deux tableaux :

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th>
</tr>
<tr>
  <td>1</td><td>H</td>
</tr>
<tr>
  <td>2</td><td>H</td>
</tr>
<tr>
  <td>3</td><td>F</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>15</td>
</tr>
<tr>
  <td>5</td><td>31</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>15</td>
</tr>
</table>
</td>

</tr>
</table>

On peut cependant modifier ce comportement avec les options `all.x` et `all.y`.

Ainsi, `all.x=TRUE` indique de conserver toutes les lignes du premier tableau. 
Dans ce cas `merge`{data-pkg="base"} donne une valeur `NA`
pour ces lignes aux colonnes provenant du second tableau. Ce qui donnerait :

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th>
</tr>
<tr>
  <td>1</td><td>H</td>
</tr>
<tr>
  <td>2</td><td>H</td>
</tr>
<tr>
  <td>3</td><td>F</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>15</td>
</tr>
<tr>
  <td>5</td><td>31</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>15</td>
</tr>
<tr>
  <td>3</td><td>F</td><td>`NA`</td>
</tr>
</table>
</td>

</tr>
</table>

L'option `all.y=TRUE` fait la même chose en conservant toutes les lignes du second tableau. 

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th>
</tr>
<tr>
  <td>1</td><td>H</td>
</tr>
<tr>
  <td>2</td><td>H</td>
</tr>
<tr>
  <td>3</td><td>F</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>15</td>
</tr>
<tr>
  <td>5</td><td>31</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>15</td>
</tr>
<tr>
  <td>5</td><td>`NA`</td><td>31</td>
</tr>
</table>
</td>

</tr>
</table>

Enfin, on peut décider de conserver toutes les lignes des deux tableaux en utilisant à la 
fois `all.x=TRUE` et `all.y=TRUE`, ce qui donne :

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th>
</tr>
<tr>
  <td>1</td><td>H</td>
</tr>
<tr>
  <td>2</td><td>H</td>
</tr>
<tr>
  <td>3</td><td>F</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>15</td>
</tr>
<tr>
  <td>5</td><td>31</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>10</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>15</td>
</tr>
<tr>
  <td>3</td><td>F</td><td>`NA`</td>
</tr>
<tr>
  <td>5</td><td>`NA`</td><td>31</td>
</tr>
</table>
</td>

</tr>
</table>

Parfois, l'un des identifiants est présent à plusieurs reprises dans l'un des tableaux (par exemple
lorsque l'une des tables est un ensemble de ménages et que l'autre décrit l'ensemble des individus de ces
ménages). Dans ce cas les lignes de l'autre table sont dupliquées autant de fois que nécessaires :

<table style="margin: 11px auto;">
<tr>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th>
</tr>
<tr>
  <td>1</td><td>H</td>
</tr>
<tr>
  <td>2</td><td>H</td>
</tr>
<tr>
  <td>3</td><td>F</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>+</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>10</td>
</tr>
<tr>
  <td>1</td><td>18</td>
</tr>
<tr>
  <td>1</td><td>21</td>
</tr>
<tr>
  <td>2</td><td>15</td>
</tr>
<tr>
  <td>3</td><td>42</td>
</tr>
</table>
</td>

<td>
<table class="exemple_operateur">
<tr><td>=</td></tr>
</table>
</td>

<td>
<table class="exemple_df">
<tr>
  <th>id</th><th>v1</th><th>v2</th>
</tr>
<tr>
  <td>1</td><td>H</td><td>10</td>
</tr>
<tr>
  <td>1</td><td>H</td><td>18</td>
</tr>
<tr>
  <td>1</td><td>H</td><td>21</td>
</tr>
<tr>
  <td>2</td><td>H</td><td>15</td>
</tr>
<tr>
  <td>3</td><td>F</td><td>42</td>
</tr>
</table>
</td>

</tr>
</table>


## Extension dplyr


```{r}
library(dplyr)
library(nycflights13)
data(flights)
data(airports)
data(airlines)
```


### Clés implicites

Très souvent, les données relatives à une analyse sont réparties dans plusieurs tables différentes. Dans notre exemple, on peut voir que la table `flights` contient seulement le code de la compagnie aérienne du vol dans la variable <var>carrier</var> :

```{r}
flights %>% select(carrier)
```

Et que par ailleurs la table `airlines` contient une information supplémentaire relative à ces compagnies, à savoir le nom complet.

```{r}
airlines
```

Il est donc naturel de vouloir associer les deux, en l'occurrence pour ajouter les noms complets des compagnies à la table `flights`. Dans ce cas on va faire une *jointure* : les lignes d'une table seront associées à une autre en se basant non pas sur leur position, mais sur les valeurs d'une ou plusieurs colonnes. Ces colonnes sont appelées des *clés*.

Pour faire une jointure de ce type, on va utiliser la fonction `left_join`{data-pkg="dplyr" data-rdoc="join"} :

```{r eval = FALSE}
left_join(flights, airlines)
```

Pour faciliter la lecture, on va afficher seulement certaines colonnes du résultat :

```{r}
left_join(flights, airlines) %>% 
  select(month, day, carrier, name)
```

On voit que la table résultat est bien la fusion des deux tables d'origine selon les valeurs des deux colonnes clés <var>carrier</var>. On est parti de la table `flights`, et pour chaque ligne on a ajouté les colonnes de `airlines` pour lesquelles la valeur de <var>carrier</var> est la même. On a donc bien une nouvelle colonne `name` dans notre table résultat, avec le nom complet de la compagnie aérienne.

<div class="note">
À noter qu'on peut tout à fait utiliser le *pipe* avec les fonctions de jointure : 

`flights %>% left_join(airlines)`.
</div>

Nous sommes ici dans le cas le plus simple concernant les clés de jointure : les deux clés sont uniques et portent le même nom dans les deux tables. Par défaut, si on ne lui spécifie pas explicitement les clés, `dplyr`{.pkg} fusionne en utilisant l'ensemble des colonnes communes aux deux tables. On peut d'ailleurs voir dans cet exemple qu'un message a été affiché précisant que la jointure s'est faite sur la variable <var>carrier</var>.

### Clés explicites

La table `airports`, elle, contient des informations supplémentaires sur les aéroports : nom complet, altitude, position géographique, etc. Chaque aéroport est identifié par un code contenu dans la colonne <var>faa</var>.

Si on regarde la table `flights`, on voit que le code d'identification des aéroports apparaît à deux endroits différents : pour l'aéroport de départ dans la colonne <var>origin</var>, et pour celui d'arrivée dans la colonne <var>dest</var>. On a donc deux clés de jointures possibles, et qui portent un nom différent de la clé de `airports`.

On va commencer par fusionner les données concernant l'aéroport de départ. Pour simplifier l'affichage des résultats, on va se contenter d'un sous-ensemble des deux tables :

```{r}
flights_ex <- flights %>% select(month, day, origin, dest)
airports_ex <- airports %>% select(faa, alt, name)
```

Si on se contente d'un `left_join`{data-pkg="dplyr" data-rdoc="join"} comme à l'étape précédente, on obtient un message d'erreur car aucune colonne commune ne peut être identifiée comme clé de jointure :

```{r error=TRUE}
left_join(flights_ex, airports_ex)
```

On doit donc spécifier explicitement les clés avec l'argument `by` de `left_join`{data-pkg="dplyr" data-rdoc="join"}. Ici la clé est nommée `origin` dans la première table, et `faa` dans la seconde. La syntaxe est donc la suivante :

```{r}
left_join(flights_ex, airports_ex, by = c("origin" = "faa"))
```

On constate que les deux nouvelles colonnes <var>name</var> et <var>alt</var> contiennent bien les données correspondant à l'aéroport de départ.

On va stocker le résultat de cette jointure dans `flights_ex` :

```{r}
flights_ex <- flights_ex %>% 
  left_join(airports_ex, by = c("origin" = "faa"))
```

Supposons qu'on souhaite maintenant fusionner à nouveau les informations de la table `airports`, mais cette fois pour les aéroports d'arrivée de notre nouvelle table `flights_ex`. Les deux clés sont donc désormais <var>dest</var> dans la première table, et <var>faa</var> dans la deuxième. La syntaxe est donc la suivante :

```{r}
left_join(flights_ex, airports_ex, by=c("dest" = "faa"))
```

Cela fonctionne, les informations de l'aéroport d'arrivée ont bien été ajoutées, mais on constate que les colonnes ont été renommées. En effet, ici les deux tables fusionnées contenaient toutes les deux des colonnes <var>name</var> et <var>alt</var>. Comme on ne peut pas avoir deux colonnes avec le même nom dans un tableau, `dplyr`{.pkg} a renommé les colonnes de la première table en `name.x` et `alt.x`, et celles de la deuxième en `name.y` et `alt.y`.

C'est pratique, mais pas forcément très parlant. On pourrait renommer manuellement les colonnes pour avoir des intitulés plus explicites avec `rename`{data-pkg="dplyr" data-rdoc="select"}, mais on peut aussi utiliser l'argument `suffix` de `left_join`{data-pkg="dplyr" data-rdoc="join"}, qui permet d'indiquer les suffixes à ajouter aux colonnes. Ainsi, on peut faire :

```{r}
left_join(flights_ex, airports_ex, 
          by = c("dest" = "faa"), 
          suffix = c("_depart", "_arrivee"))
```

On obtient ainsi directement des noms de colonnes nettement plus clairs.


### Types de jointures

Jusqu'à présent nous avons utilisé la fonction `left_join`{data-pkg="dplyr" data-rdoc="join"}, mais il existe plusieurs types de jointures.

Partons de deux tables d'exemple, `personnes` et `voitures` :

```{r}
personnes <- data_frame(nom = c("Sylvie", "Sylvie", "Monique", "Gunter", "Rayan", "Rayan"),
                        voiture = c("Twingo", "Ferrari", "Scenic", "Lada", "Twingo", "Clio"))
```

```{r, echo=FALSE, eval=TRUE}
library(knitr)
kable(personnes)
```


```{r}
voitures <- data_frame(voiture = c("Twingo", "Ferrari", "Clio", "Lada", "208"),
                       vitesse = c("140", "280", "160", "85", "160"))
```

```{r, echo=FALSE, eval=TRUE}
kable(voitures)
```


#### left_join

Si on fait un `left_join`{data-pkg="dplyr" data-rdoc="join"} de `voitures` sur `personnes` :

```{r, echo=TRUE, eval=FALSE}
left_join(personnes, voitures)
```

```{r, echo=FALSE, eval=TRUE}
kable(left_join(personnes, voitures))
```

On voit que chaque ligne de `personnes` est bien présente, et qu'on lui a ajouté une ligne de `voitures` correspondante si elle existe. Dans le cas du `Scenic`, il n'y a avait pas de ligne dans `voitures`, donc `vitesse` a été mise à `NA`. Dans le cas de `208`, présente dans `voitures` mais pas dans `personnes`, la ligne n'apparaît pas.

Si on fait un `left_join`{data-pkg="dplyr" data-rdoc="join"} cette fois de `personnes` sur `voitures`, c'est l'inverse :

```{r, echo=TRUE, eval=FALSE}
left_join(voitures, personnes)
```

```{r, echo=FALSE, eval=TRUE}
kable(left_join(voitures, personnes))
```

La ligne `208` est là, mais `nom` est à `NA`. Par contre `Monique` est absente. Et on remarquera que la ligne `Twingo`, présente deux fois dans `personnes`, a été dupliquée pour être associée aux deux lignes de données de `Sylvie` et `Rayan`.

En résumé, quand on fait un `left_join(x, y)`, toutes les lignes de `x` sont présentes, et dupliquées si nécessaire quand elles apparaissent plusieurs fois dans `y`. Les lignes de `y` non présentes dans `x` disparaissent. Les lignes de `x` non présentes dans `y` se voient attribuer des `NA` pour les nouvelles colonnes.

Intuitivement, on pourrait considérer que `left_join(x, y)` signifie "ramener l'information de la table `y` sur la table `x`".

En général, `left_join`{data-pkg="dplyr" data-rdoc="join"} sera le type de jointures le plus fréquemment utilisé.

#### right_join

La jointure `right_join`{data-pkg="dplyr" data-rdoc="join"} est l'exacte symétrique de `left_join`{data-pkg="dplyr" data-rdoc="join"}, c'est-à dire que `right_join(x, y)` est équivalent à `left_join(x,y)` :

```{r, echo=TRUE, eval=FALSE}
right_join(personnes, voitures)
```


```{r, echo=FALSE, eval=TRUE}
kable(right_join(personnes, voitures))
```


#### inner_join

Dans le cas de `inner_join`{data-pkg="dplyr" data-rdoc="join"}, seules les lignes présentes à la fois dans `x` et `y` sont présentes (et si nécessaire dupliquées) dans la table résultat :

```{r, echo=TRUE, eval=FALSE}
inner_join(personnes, voitures)
```


```{r, echo=FALSE, eval=TRUE}
kable(inner_join(personnes, voitures))
```

Ici la ligne `208` est absente, ainsi que la ligne `Monique`, qui dans le cas d'un `left_join`{data-pkg="dplyr" data-rdoc="join"} avait été conservée et s'était vue attribuer une `vitesse` à `NA`.

#### full_join

Dans le cas de `full_join`{data-pkg="dplyr" data-rdoc="join"}, toutes les lignes de `x` et toutes les lignes de `y` sont conservées (avec des `NA` ajoutés si nécessaire) même si elles sont absentes de l'autre table :

```{r, echo=TRUE, eval=FALSE}
full_join(personnes, voitures)
```

```{r, echo=FALSE, eval=TRUE}
kable(full_join(personnes, voitures))
```


#### semi_join et anti_join

`semi_join`{data-pkg="dplyr" data-rdoc="join"} et `anti_join`{data-pkg="dplyr" data-rdoc="join"} sont des jointures *filtrantes*, c'est-à-dire qu'elles sélectionnent les lignes de `x` sans ajouter les colonnes de `y`.

Ainsi, `semi_join`{data-pkg="dplyr" data-rdoc="join"} ne conservera que les lignes de `x` pour lesquelles une ligne de `y` existe également, et supprimera les autres. Dans notre exemple, la ligne `Monique` est donc supprimée :

```{r, echo=TRUE, eval=FALSE}
semi_join(personnes, voitures)
```

```{r, echo=FALSE, eval=TRUE}
kable(semi_join(personnes, voitures))
```


Un `anti_join`{data-pkg="dplyr" data-rdoc="join"} fait l'inverse, il ne conserve que les lignes de `x` absentes de `y`. Dans notre exemple, on ne garde donc que la ligne `Monique` :

```{r, echo=TRUE, eval=FALSE}
anti_join(personnes, voitures)
```

```{r, echo=FALSE, eval=TRUE}
kable(anti_join(personnes, voitures))
```


## Extension data.table

`data.table`{.pkg} fourni une fonction `merge`{data-pkg="data.table"} beaucoup plus rapide que celle standard de R mais fonctionnant de manière identique.