Partie 10 Manipuler les données avec dplyr

dplyr est une extension facilitant le traitement et la manipulation de données contenues dans une ou plusieurs tables (qu’il s’agisse de data frame ou de tibble). Elle propose une syntaxe claire et cohérente, sous formes de verbes, pour la plupart des opérations de ce type.

Par ailleurs, les fonctions de dplyr sont en général plus rapides que leur équivalent sous R de base, elles permettent donc de traiter des données de grande dimension.

dplyr part du principe que les données sont tidy (voir la section 6.3). Les fonctions de l’extension peuvent s’appliquer à des tableaux de type data.frame ou tibble, et elles retournent systématiquement un tibble (voir la section 6.4).

10.1 Préparation

dplyr fait partie du coeur du tidyverse, elle est donc chargée automatiquement avec :

library(tidyverse)

On peut également la charger individuellement avec :

library(dplyr)

Dans ce qui suit on va utiliser les données du jeu de données nycflights13, contenu dans l’extension du même nom (qu’il faut donc avoir installé). Celui-ci correspond aux données de tous les vols au départ d’un des trois aéroports de New-York en 2013. Il a la particularité d’être réparti en trois tables :

  • flights contient des informations sur les vols : date, départ, destination, horaires, retard…
  • airports contient des informations sur les aéroports
  • airlines contient des données sur les compagnies aériennes

On va charger les trois tables du jeu de données :

library(nycflights13)
## Chargement des trois tables du jeu de données
data(flights)
data(airports)
data(airlines)

Normalement trois objets correspondant aux trois tables ont dû apparaître dans votre environnement.

10.2 Les verbes de dplyr

La manipulation de données avec dplyr se fait en utilisant un nombre réduit de verbes, qui correspondent chacun à une action différente appliquée à un tableau de données.

10.2.1 slice

Le verbe slice sélectionne des lignes du tableau selon leur position. On lui passe un chiffre ou un vecteur de chiffres.

Si on souhaite sélectionner la 345e ligne du tableau airports :

slice(airports, 345)
# A tibble: 1 x 8
  faa   name                lat   lon   alt    tz dst   tzone            
  <chr> <chr>             <dbl> <dbl> <int> <dbl> <chr> <chr>            
1 CYF   Chefornak Airport  60.1  -164    40 -9.00 A     America/Anchorage

Si on veut sélectionner les 5 premières lignes :

slice(airports, 1:5)
# A tibble: 5 x 8
  faa   name                            lat   lon   alt    tz dst   tzone 
  <chr> <chr>                         <dbl> <dbl> <int> <dbl> <chr> <chr> 
1 04G   Lansdowne Airport              41.1 -80.6  1044 -5.00 A     Ameri…
2 06A   Moton Field Municipal Airport  32.5 -85.7   264 -6.00 A     Ameri…
3 06C   Schaumburg Regional            42.0 -88.1   801 -6.00 A     Ameri…
4 06N   Randall Airport                41.4 -74.4   523 -5.00 A     Ameri…
5 09J   Jekyll Island Airport          31.1 -81.4    11 -5.00 A     Ameri…

10.2.2 filter

filter sélectionne des lignes d’un tableau de données selon une condition. On lui passe en paramètre un test, et seules les lignes pour lesquelles ce test renvoit TRUE (vrai) sont conservées. Pour plus d’informations sur les tests et leur syntaxe, voir la section 9.2.

Par exemple, si on veut sélectionner les vols du mois de janvier, on peut filtrer sur la variable month de la manière suivante :

filter(flights, month == 1)
# A tibble: 27,004 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      533            529      4.00      850
 3  2013     1     1      542            540      2.00      923
 4  2013     1     1      544            545     -1.00     1004
 5  2013     1     1      554            600     -6.00      812
 6  2013     1     1      554            558     -4.00      740
 7  2013     1     1      555            600     -5.00      913
 8  2013     1     1      557            600     -3.00      709
 9  2013     1     1      557            600     -3.00      838
10  2013     1     1      558            600     -2.00      753
# ... with 26,994 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

Si on veut uniquement les vols avec un retard au départ (variable dep_delay) compris entre 10 et 15 minutes :

filter(flights, dep_delay >= 10 & dep_delay <= 15)
# A tibble: 14,919 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      611            600      11.0      945
 2  2013     1     1      623            610      13.0      920
 3  2013     1     1      743            730      13.0     1107
 4  2013     1     1      743            730      13.0     1059
 5  2013     1     1      851            840      11.0     1215
 6  2013     1     1      912            900      12.0     1241
 7  2013     1     1      914            900      14.0     1058
 8  2013     1     1      920            905      15.0     1039
 9  2013     1     1     1011           1001      10.0     1133
10  2013     1     1     1112           1100      12.0     1440
# ... with 14,909 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

Si on passe plusieurs arguments à filter, celui-ci rajoute automatiquement une condition et entre les conditions. La ligne ci-dessus peut donc également être écrite de la manière suivante, avec le même résultat :

filter(flights, dep_delay >= 10, dep_delay <= 15)

Enfin, on peut également placer des fonctions dans les tests, qui nous permettent par exemple de sélectionner les vols avec la plus grande distance :

filter(flights, distance == max(distance))
# A tibble: 342 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      857            900  -   3.00     1516
 2  2013     1     2      909            900      9.00     1525
 3  2013     1     3      914            900     14.0      1504
 4  2013     1     4      900            900      0        1516
 5  2013     1     5      858            900  -   2.00     1519
 6  2013     1     6     1019            900     79.0      1558
 7  2013     1     7     1042            900    102        1620
 8  2013     1     8      901            900      1.00     1504
 9  2013     1     9      641            900   1301        1242
10  2013     1    10      859            900  -   1.00     1449
# ... with 332 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

10.2.3 select et rename

select permet de sélectionner des colonnes d’un tableau de données. Ainsi, si on veut extraire les colonnes lat et lon du tableau airports :

select(airports, lat, lon)
# A tibble: 1,458 x 2
     lat    lon
   <dbl>  <dbl>
 1  41.1 - 80.6
 2  32.5 - 85.7
 3  42.0 - 88.1
 4  41.4 - 74.4
 5  31.1 - 81.4
 6  36.4 - 82.2
 7  41.5 - 84.5
 8  42.9 - 76.8
 9  39.8 - 76.6
10  48.1 -123  
# ... with 1,448 more rows

Si on fait précéder le nom d’un -, la colonne est éliminée plutôt que sélectionnée :

select(airports, -lat, -lon)
# A tibble: 1,458 x 6
   faa   name                             alt    tz dst   tzone           
   <chr> <chr>                          <int> <dbl> <chr> <chr>           
 1 04G   Lansdowne Airport               1044 -5.00 A     America/New_York
 2 06A   Moton Field Municipal Airport    264 -6.00 A     America/Chicago 
 3 06C   Schaumburg Regional              801 -6.00 A     America/Chicago 
 4 06N   Randall Airport                  523 -5.00 A     America/New_York
 5 09J   Jekyll Island Airport             11 -5.00 A     America/New_York
 6 0A9   Elizabethton Municipal Airport  1593 -5.00 A     America/New_York
 7 0G6   Williams County Airport          730 -5.00 A     America/New_York
 8 0G7   Finger Lakes Regional Airport    492 -5.00 A     America/New_York
 9 0P2   Shoestring Aviation Airfield    1000 -5.00 U     America/New_York
10 0S9   Jefferson County Intl            108 -8.00 A     America/Los_Ang…
# ... with 1,448 more rows

select comprend toute une série de fonctions facilitant la sélection de multiples colonnes. Par exemple, starts_with, ends_width, contains ou matches permettent d’exprimer des conditions sur les noms de variables :

select(flights, starts_with("dep_"))
# A tibble: 336,776 x 2
   dep_time dep_delay
      <int>     <dbl>
 1      517      2.00
 2      533      4.00
 3      542      2.00
 4      544     -1.00
 5      554     -6.00
 6      554     -4.00
 7      555     -5.00
 8      557     -3.00
 9      557     -3.00
10      558     -2.00
# ... with 336,766 more rows

La syntaxe colonne1:colonne2 permet de sélectionner toutes les colonnes situées entre colonne1 et colonne2 incluses14 :

select(flights, year:day)
# A tibble: 336,776 x 3
    year month   day
   <int> <int> <int>
 1  2013     1     1
 2  2013     1     1
 3  2013     1     1
 4  2013     1     1
 5  2013     1     1
 6  2013     1     1
 7  2013     1     1
 8  2013     1     1
 9  2013     1     1
10  2013     1     1
# ... with 336,766 more rows

select peut être utilisée pour réordonner les colonnes d’une table en utilisant la fonction everything(), qui sélectionne l’ensemble des colonnes non encore sélectionnées. Ainsi, si on souhaite faire passer la colonne name en première position de la table airports, on peut faire :

select(airports, name, everything())
# A tibble: 1,458 x 8
   name                 faa     lat    lon   alt    tz dst   tzone        
   <chr>                <chr> <dbl>  <dbl> <int> <dbl> <chr> <chr>        
 1 Lansdowne Airport    04G    41.1 - 80.6  1044 -5.00 A     America/New_…
 2 Moton Field Municip… 06A    32.5 - 85.7   264 -6.00 A     America/Chic…
 3 Schaumburg Regional  06C    42.0 - 88.1   801 -6.00 A     America/Chic…
 4 Randall Airport      06N    41.4 - 74.4   523 -5.00 A     America/New_…
 5 Jekyll Island Airpo… 09J    31.1 - 81.4    11 -5.00 A     America/New_…
 6 Elizabethton Munici… 0A9    36.4 - 82.2  1593 -5.00 A     America/New_…
 7 Williams County Air… 0G6    41.5 - 84.5   730 -5.00 A     America/New_…
 8 Finger Lakes Region… 0G7    42.9 - 76.8   492 -5.00 A     America/New_…
 9 Shoestring Aviation… 0P2    39.8 - 76.6  1000 -5.00 U     America/New_…
10 Jefferson County In… 0S9    48.1 -123     108 -8.00 A     America/Los_…
# ... with 1,448 more rows

Une variante de select est rename15, qui permet de renommer facilement des colonnes. On l’utilise en lui passant des paramètres de la forme nouveau_nom = ancien_nom. Ainsi, si on veut renommer les colonnes lon et lat de airports en longitude et latitude :

rename(airports, longitude = lon, latitude = lat)
# A tibble: 1,458 x 8
   faa   name             latitude longitude   alt    tz dst   tzone      
   <chr> <chr>               <dbl>     <dbl> <int> <dbl> <chr> <chr>      
 1 04G   Lansdowne Airpo…     41.1    - 80.6  1044 -5.00 A     America/Ne…
 2 06A   Moton Field Mun…     32.5    - 85.7   264 -6.00 A     America/Ch…
 3 06C   Schaumburg Regi…     42.0    - 88.1   801 -6.00 A     America/Ch…
 4 06N   Randall Airport      41.4    - 74.4   523 -5.00 A     America/Ne…
 5 09J   Jekyll Island A…     31.1    - 81.4    11 -5.00 A     America/Ne…
 6 0A9   Elizabethton Mu…     36.4    - 82.2  1593 -5.00 A     America/Ne…
 7 0G6   Williams County…     41.5    - 84.5   730 -5.00 A     America/Ne…
 8 0G7   Finger Lakes Re…     42.9    - 76.8   492 -5.00 A     America/Ne…
 9 0P2   Shoestring Avia…     39.8    - 76.6  1000 -5.00 U     America/Ne…
10 0S9   Jefferson Count…     48.1    -123     108 -8.00 A     America/Lo…
# ... with 1,448 more rows

Si les noms de colonnes comportent des espaces ou des caractères spéciaux, on peut les entourer de guillemets (") ou de quotes inverses (`) :

tmp <- rename(flights, 
              "retard départ" = dep_delay,
              "retard arrivée" = arr_delay)
select(tmp, `retard départ`, `retard arrivée`)
# A tibble: 336,776 x 2
   `retard départ` `retard arrivée`
             <dbl>            <dbl>
 1            2.00            11.0 
 2            4.00            20.0 
 3            2.00            33.0 
 4           -1.00           -18.0 
 5           -6.00           -25.0 
 6           -4.00            12.0 
 7           -5.00            19.0 
 8           -3.00           -14.0 
 9           -3.00           - 8.00
10           -2.00             8.00
# ... with 336,766 more rows

10.2.4 arrange

arrange réordonne les lignes d’un tableau selon une ou plusieurs colonnes.

Ainsi, si on veut trier le tableau flights selon le retard au départ croissant :

arrange(flights, dep_delay)
# A tibble: 336,776 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013    12     7     2040           2123     -43.0       40
 2  2013     2     3     2022           2055     -33.0     2240
 3  2013    11    10     1408           1440     -32.0     1549
 4  2013     1    11     1900           1930     -30.0     2233
 5  2013     1    29     1703           1730     -27.0     1947
 6  2013     8     9      729            755     -26.0     1002
 7  2013    10    23     1907           1932     -25.0     2143
 8  2013     3    30     2030           2055     -25.0     2213
 9  2013     3     2     1431           1455     -24.0     1601
10  2013     5     5      934            958     -24.0     1225
# ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

On peut trier selon plusieurs colonnes. Par exemple selon le mois, puis selon le retard au départ :

arrange(flights, month, dep_delay)
# A tibble: 336,776 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1    11     1900           1930     -30.0     2233
 2  2013     1    29     1703           1730     -27.0     1947
 3  2013     1    12     1354           1416     -22.0     1606
 4  2013     1    21     2137           2159     -22.0     2232
 5  2013     1    20      704            725     -21.0     1025
 6  2013     1    12     2050           2110     -20.0     2310
 7  2013     1    12     2134           2154     -20.0        4
 8  2013     1    14     2050           2110     -20.0     2329
 9  2013     1     4     2140           2159     -19.0     2241
10  2013     1    11     1947           2005     -18.0     2209
# ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

Si on veut trier selon une colonne par ordre décroissant, on lui applique la fonction desc() :

arrange(flights, desc(dep_delay))
# A tibble: 336,776 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     9      641            900      1301     1242
 2  2013     6    15     1432           1935      1137     1607
 3  2013     1    10     1121           1635      1126     1239
 4  2013     9    20     1139           1845      1014     1457
 5  2013     7    22      845           1600      1005     1044
 6  2013     4    10     1100           1900       960     1342
 7  2013     3    17     2321            810       911      135
 8  2013     6    27      959           1900       899     1236
 9  2013     7    22     2257            759       898      121
10  2013    12     5      756           1700       896     1058
# ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>

Combiné avec slice, arrange permet par exemple de sélectionner les trois vols ayant eu le plus de retard :

tmp <- arrange(flights, desc(dep_delay)) 
slice(tmp, 1:3)
# A tibble: 3 x 19
   year month   day dep_time sched_dep_time dep_delay arr_time
  <int> <int> <int>    <int>          <int>     <dbl>    <int>
1  2013     1     9      641            900      1301     1242
2  2013     6    15     1432           1935      1137     1607
3  2013     1    10     1121           1635      1126     1239
# ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
#   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
#   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
#   time_hour <dttm>

10.2.5 mutate

mutate permet de créer de nouvelles colonnes dans le tableau de données, en général à partir de variables existantes.

Par exemple, la table airports contient l’altitude de l’aéroport en pieds. Si on veut créer une nouvelle variable alt_m avec l’altitude en mètres, on peut faire :

airports <- mutate(airports, alt_m = alt / 3.2808)
select(airports, name, alt, alt_m)
# A tibble: 1,458 x 3
   name                             alt  alt_m
   <chr>                          <int>  <dbl>
 1 Lansdowne Airport               1044 318   
 2 Moton Field Municipal Airport    264  80.5 
 3 Schaumburg Regional              801 244   
 4 Randall Airport                  523 159   
 5 Jekyll Island Airport             11   3.35
 6 Elizabethton Municipal Airport  1593 486   
 7 Williams County Airport          730 223   
 8 Finger Lakes Regional Airport    492 150   
 9 Shoestring Aviation Airfield    1000 305   
10 Jefferson County Intl            108  32.9 
# ... with 1,448 more rows

On peut créer plusieurs nouvelles colonnes en une seule fois, et les expressions successives peuvent prendre en compte les résultats des calculs précédents. L’exemple suivant convertit d’abord la distance en kilomètres dans une variable distance_km, puis utilise cette nouvelle colonne pour calculer la vitesse en km/h.

flights <- mutate(flights, 
                  distance_km = distance / 0.62137,
                  vitesse = distance_km / air_time * 60)
select(flights, distance, distance_km, vitesse)
# A tibble: 336,776 x 3
   distance distance_km vitesse
      <dbl>       <dbl>   <dbl>
 1     1400        2253     596
 2     1416        2279     602
 3     1089        1753     657
 4     1576        2536     832
 5      762        1226     634
 6      719        1157     463
 7     1065        1714     651
 8      229         369     417
 9      944        1519     651
10      733        1180     513
# ... with 336,766 more rows

À noter que mutate est évidemment parfaitement compatible avec les fonctions vues dans le chapitre 9 sur les recodages : fonctions de forcats, if_else, case_when

L’avantage d’utiliser mutate est double. D’abord il permet d’éviter d’avoir à saisir le nom du tableau de données dans les conditions d’un if_else ou d’un case_when :

flights <- mutate(flights,
                  type_retard = case_when(
                    dep_delay > 0 & arr_delay > 0 ~ "Retard départ et arrivée",
                    dep_delay > 0 & arr_delay <= 0 ~ "Retard départ",
                    dep_delay <= 0 & arr_delay > 0 ~ "Retard arrivée",
                    TRUE ~ "Aucun retard"))

Utiliser mutate pour les recodages permet aussi de les intégrer dans un pipeline de traitement de données, concept présenté dans la section suivante.

10.3 Enchaîner les opérations avec le pipe

Quand on manipule un tableau de données, il est très fréquent d’enchaîner plusieurs opérations. On va par exemple filtrer pour extraire une sous-population, sélectionner des colonnes puis trier selon une variable.

Dans ce cas on peut le faire de deux manières différentes. La première est d’effectuer toutes les opérations en une fois en les “emboîtant” :

arrange(select(filter(flights, dest == "LAX"), dep_delay, arr_delay), dep_delay)

Cette notation a plusieurs inconvénients :

  • elle est peu lisible
  • les opérations apparaissent dans l’ordre inverse de leur réalisation. Ici on effectue d’abord le filter, puis le select, puis le arrange, alors qu’à la lecture du code c’est le arrange qui apparaît en premier.
  • Il est difficile de voir quel paramètre se rapporte à quelle fonction

Une autre manière de faire est d’effectuer les opérations les unes après les autres, en stockant les résultats intermédiaires dans un objet temporaire :

tmp <- filter(flights, dest == "LAX")
tmp <- select(tmp, dep_delay, arr_delay)
arrange(tmp, dep_delay)

C’est nettement plus lisible, l’ordre des opérations est le bon, et les paramètres sont bien rattachés à leur fonction. Par contre, ça reste un peu “verbeux”, et on crée un objet temporaire tmp dont on n’a pas réellement besoin.

Pour simplifier et améliorer encore la lisibilité du code, on va utiliser un nouvel opérateur, baptisé pipe16. Le pipe se note %>%, et son fonctionnement est le suivant : si j’exécute expr %>% f, alors le résultat de l’expression expr, à gauche du pipe, sera passé comme premier argument à la fonction f, à droite du pipe, ce qui revient à exécuter f(expr).

Ainsi les deux expressions suivantes sont rigoureusement équivalentes :

filter(flights, dest == "LAX")
flights %>% filter(dest == "LAX")

Ce qui est intéressant dans cette histoire, c’est qu’on va pouvoir enchaîner les pipes. Plutôt que d’écrire :

select(filter(flights, dest == "LAX"), dep_delay, arr_delay)

On va pouvoir faire :

flights %>% filter(dest == "LAX") %>% select(dep_delay, arr_delay)

À chaque fois, le résultat de ce qui se trouve à gauche du pipe est passé comme premier argument à ce qui se trouve à droite : on part de l’objet flights, qu’on passe comme premier argument à la fonction filter, puis on passe le résultat de ce filter comme premier argument du select.

Le résultat final est le même avec les deux syntaxes, mais avec le pipe l’ordre des opérations correspond à l’ordre naturel de leur exécution, et on n’a pas eu besoin de créer d’objet intermédiaire.

Si la liste des fonctions enchaînées est longue, on peut les répartir sur plusieurs lignes à condition que l’opérateur %>% soit en fin de ligne :

flights %>% 
  filter(dest == "LAX") %>% 
  select(dep_delay, arr_delay) %>% 
  arrange(dep_delay)

On appelle une suite d’instructions de ce type un pipeline.

Évidemment, il est naturel de vouloir récupérer le résultat final d’un pipeline pour le stocker dans un objet. Par exemple, on peut stocker le résultat du pipeline ci-dessus dans un nouveau tableau delay_la de la manière suivante :

delay_la <- flights %>% 
  filter(dest == "LAX") %>% 
  select(dep_delay, arr_delay) %>% 
  arrange(dep_delay)

Dans ce cas, delay_la contiendra le tableau final, obtenu après application des trois instructions filter, select et arrange.

Cette notation n’est pas forcément très intuitive au départ. Il faut bien comprendre que c’est le résultat final, une fois application de toutes les opérations du pipeline, qui est renvoyé et stocké dans l’objet en début de ligne.

Une manière de le comprendre peut être de voir que la notation suivante :

delay_la <- flights %>% 
  filter(dest == "LAX") %>% 
  select(dep_delay, arr_delay)

est équivalente à :

delay_la <- (flights %>% filter(dest == "LAX") %>% select(dep_delay, arr_delay))

L’utilisation du pipe n’est pas obligatoire, mais elle rend les scripts plus lisibles et plus rapides à saisir. On l’utilisera donc dans ce qui suit.

10.4 Opérations groupées

10.4.1 group_by

Un élément très important de dplyr est la fonction group_by. Elle permet de définir des groupes de lignes à partir des valeurs d’une ou plusieurs colonnes. Par exemple, on peut grouper les vols selon leur mois :

flights %>% group_by(month)
# A tibble: 336,776 x 21
# Groups:   month [12]
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      533            529      4.00      850
 3  2013     1     1      542            540      2.00      923
 4  2013     1     1      544            545     -1.00     1004
 5  2013     1     1      554            600     -6.00      812
 6  2013     1     1      554            558     -4.00      740
 7  2013     1     1      555            600     -5.00      913
 8  2013     1     1      557            600     -3.00      709
 9  2013     1     1      557            600     -3.00      838
10  2013     1     1      558            600     -2.00      753
# ... with 336,766 more rows, and 14 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

Par défaut ceci ne fait rien de visible, à part l’apparition d’une mention Groups dans l’affichage du résultat. Mais à partir du moment où des groupes ont été définis, les verbes comme slice, mutate ou summarise vont en tenir compte lors de leurs opérations.

Par exemple, si on applique slice à un tableau préalablement groupé, il va sélectionner les lignes aux positions indiquées pour chaque groupe. Ainsi la commande suivante affiche le premier vol de chaque mois, selon leur ordre d’apparition dans le tableau :

flights %>% group_by(month) %>% slice(1)
# A tibble: 12 x 21
# Groups:   month [12]
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     2     1      456            500   -  4.00      652
 3  2013     3     1        4           2159    125         318
 4  2013     4     1      454            500   -  6.00      636
 5  2013     5     1        9           1655    434         308
 6  2013     6     1        2           2359      3.00      341
 7  2013     7     1        1           2029    212         236
 8  2013     8     1       12           2130    162         257
 9  2013     9     1        9           2359     10.0       343
10  2013    10     1      447            500   - 13.0       614
11  2013    11     1        5           2359      6.00      352
12  2013    12     1       13           2359     14.0       446
# ... with 14 more variables: sched_arr_time <int>, arr_delay <dbl>,
#   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
#   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
#   time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

Idem pour mutate : les opérations appliquées lors du calcul des valeurs des nouvelles colonnes sont aplliquée groupe de lignes par groupe de lignes. Dans l’exemple suivant, on ajoute une nouvelle colonne qui contient le retard moyen du mois correspondant :

flights %>% 
  group_by(month) %>% 
  mutate(mean_delay_month = mean(dep_delay, na.rm = TRUE)) %>% 
  select(dep_delay, month, mean_delay_month)
# A tibble: 336,776 x 3
# Groups:   month [12]
   dep_delay month mean_delay_month
       <dbl> <int>            <dbl>
 1      2.00     1             10.0
 2      4.00     1             10.0
 3      2.00     1             10.0
 4     -1.00     1             10.0
 5     -6.00     1             10.0
 6     -4.00     1             10.0
 7     -5.00     1             10.0
 8     -3.00     1             10.0
 9     -3.00     1             10.0
10     -2.00     1             10.0
# ... with 336,766 more rows

Ceci peut permettre, par exemple, de déterminer si un retard donné est supérieur ou inférieur au retard moyen du mois en cours.

group_by peut aussi être utile avec filter, par exemple pour sélectionner les vols avec le retard au départ le plus important pour chaque mois :

flights %>% 
  group_by(month) %>% 
  filter(dep_delay == max(dep_delay, na.rm = TRUE))
# A tibble: 12 x 21
# Groups:   month [12]
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     9      641            900      1301     1242
 2  2013    10    14     2042            900       702     2255
 3  2013    11     3      603           1645       798      829
 4  2013    12     5      756           1700       896     1058
 5  2013     2    10     2243            830       853      100
 6  2013     3    17     2321            810       911      135
 7  2013     4    10     1100           1900       960     1342
 8  2013     5     3     1133           2055       878     1250
 9  2013     6    15     1432           1935      1137     1607
10  2013     7    22      845           1600      1005     1044
11  2013     8     8     2334           1454       520      120
12  2013     9    20     1139           1845      1014     1457
# ... with 14 more variables: sched_arr_time <int>, arr_delay <dbl>,
#   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
#   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
#   time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

Attention : la clause group_by marche pour les verbes déjà vus précédemment, sauf pour arrange, qui par défaut trie la table sans tenir compte des groupes. Pour obtenir un tri par groupe, il faut lui ajouter l’argument .by_group = TRUE.

On peut voir la différence en comparant les deux résultats suivants :

flights %>% 
  group_by(month) %>% 
  arrange(desc(dep_delay))
# A tibble: 336,776 x 21
# Groups:   month [12]
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     9      641            900      1301     1242
 2  2013     6    15     1432           1935      1137     1607
 3  2013     1    10     1121           1635      1126     1239
 4  2013     9    20     1139           1845      1014     1457
 5  2013     7    22      845           1600      1005     1044
 6  2013     4    10     1100           1900       960     1342
 7  2013     3    17     2321            810       911      135
 8  2013     6    27      959           1900       899     1236
 9  2013     7    22     2257            759       898      121
10  2013    12     5      756           1700       896     1058
# ... with 336,766 more rows, and 14 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, distance_km <dbl>, vitesse <dbl>
flights %>% 
  group_by(month) %>% 
  arrange(desc(dep_delay), .by_group = TRUE)
# A tibble: 336,776 x 21
# Groups:   month [12]
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     9      641            900      1301     1242
 2  2013     1    10     1121           1635      1126     1239
 3  2013     1     1      848           1835       853     1001
 4  2013     1    13     1809            810       599     2054
 5  2013     1    16     1622            800       502     1911
 6  2013     1    23     1551            753       478     1812
 7  2013     1    10     1525            900       385     1713
 8  2013     1     1     2343           1724       379      314
 9  2013     1     2     2131           1512       379     2340
10  2013     1     7     2021           1415       366     2332
# ... with 336,766 more rows, and 14 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

10.4.2 summarise et count

summarise permet d’agréger les lignes du tableau en effectuant une opération “résumée” sur une ou plusieurs colonnes. Par exemple, si on souhaite connaître les retards moyens au départ et à l’arrivée pour l’ensemble des vols du tableau flights :

flights %>% 
  summarise(retard_dep = mean(dep_delay, na.rm=TRUE),
            retard_arr = mean(arr_delay, na.rm=TRUE))
# A tibble: 1 x 2
  retard_dep retard_arr
       <dbl>      <dbl>
1       12.6       6.90

Cette fonction est en général utilisée avec group_by, puisqu’elle permet du coup d’agréger et résumer les lignes du tableau groupe par groupe. Si on souhaite calculer le délai maximum, le délai minimum et le délai moyen au départ pour chaque mois, on pourra faire :

flights %>%
  group_by(month) %>%
  summarise(max_delay = max(dep_delay, na.rm=TRUE),
            min_delay = min(dep_delay, na.rm=TRUE),
            mean_delay = mean(dep_delay, na.rm=TRUE))
# A tibble: 12 x 4
   month max_delay min_delay mean_delay
   <int>     <dbl>     <dbl>      <dbl>
 1     1      1301     -30.0      10.0 
 2     2       853     -33.0      10.8 
 3     3       911     -25.0      13.2 
 4     4       960     -21.0      13.9 
 5     5       878     -24.0      13.0 
 6     6      1137     -21.0      20.8 
 7     7      1005     -22.0      21.7 
 8     8       520     -26.0      12.6 
 9     9      1014     -24.0       6.72
10    10       702     -25.0       6.24
11    11       798     -32.0       5.44
12    12       896     -43.0      16.6 

summarise dispose d’un opérateur spécial, n(), qui retourne le nombre de lignes du groupe. Ainsi si on veut le nombre de vols par destination, on peut utiliser :

flights %>%
  group_by(dest) %>%
  summarise(nb = n())
# A tibble: 105 x 2
   dest     nb
   <chr> <int>
 1 ABQ     254
 2 ACK     265
 3 ALB     439
 4 ANC       8
 5 ATL   17215
 6 AUS    2439
 7 AVL     275
 8 BDL     443
 9 BGR     375
10 BHM     297
# ... with 95 more rows

n() peut aussi être utilisée avec filter et mutate.

À noter que quand on veut compter le nombre de lignes par groupe, on peut utiliser directement la fonction count. Ainsi le code suivant est identique au précédent :

flights %>%
  count(dest)
# A tibble: 105 x 2
   dest      n
   <chr> <int>
 1 ABQ     254
 2 ACK     265
 3 ALB     439
 4 ANC       8
 5 ATL   17215
 6 AUS    2439
 7 AVL     275
 8 BDL     443
 9 BGR     375
10 BHM     297
# ... with 95 more rows

10.4.3 Grouper selon plusieurs variables

On peut grouper selon plusieurs variables à la fois, il suffit de les indiquer dans la clause du group_by :

flights %>%
  group_by(month, dest) %>%
  summarise(nb = n()) %>%
  arrange(desc(nb))
# A tibble: 1,113 x 3
# Groups:   month [12]
   month dest     nb
   <int> <chr> <int>
 1     8 ORD    1604
 2    10 ORD    1604
 3     5 ORD    1582
 4     9 ORD    1582
 5     7 ORD    1573
 6     6 ORD    1547
 7     7 ATL    1511
 8     8 ATL    1507
 9     8 LAX    1505
10     7 LAX    1500
# ... with 1,103 more rows

On peut également compter selon plusieurs variables :

flights %>% 
  count(origin, dest) %>% 
  arrange(desc(n))
# A tibble: 224 x 3
   origin dest      n
   <chr>  <chr> <int>
 1 JFK    LAX   11262
 2 LGA    ATL   10263
 3 LGA    ORD    8857
 4 JFK    SFO    8204
 5 LGA    CLT    6168
 6 EWR    ORD    6100
 7 JFK    BOS    5898
 8 LGA    MIA    5781
 9 JFK    MCO    5464
10 EWR    BOS    5327
# ... with 214 more rows

On peut utiliser plusieurs opérations de groupage dans le même pipeline. Ainsi, si on souhaite déterminer le couple origine/destination ayant le plus grand nombre de vols selon le mois de l’année, on devra procéder en deux étapes :

  • d’abord grouper selon mois, origine et destination pour calculer le nombre de vols
  • puis grouper uniquement selon le mois pour sélectionner la ligne avec la valeur maximale.

Au final, on obtient le code suivant :

flights %>%
  group_by(month, origin, dest) %>%
  summarise(nb = n()) %>%
  group_by(month) %>%
  filter(nb == max(nb))
# A tibble: 12 x 4
# Groups:   month [12]
   month origin dest     nb
   <int> <chr>  <chr> <int>
 1     1 JFK    LAX     937
 2     2 JFK    LAX     834
 3     3 JFK    LAX     960
 4     4 JFK    LAX     935
 5     5 JFK    LAX     960
 6     6 JFK    LAX     928
 7     7 JFK    LAX     985
 8     8 JFK    LAX     979
 9     9 JFK    LAX     925
10    10 JFK    LAX     965
11    11 JFK    LAX     907
12    12 JFK    LAX     947

Lorsqu’on effectue un group_by suivi d’un summarise, le tableau résultat est automatiquement dégroupé de la dernière variable de regroupement. Ainsi le tableau généré par le code suivant est groupé par month et origin :

flights %>%
  group_by(month, origin, dest) %>%
  summarise(nb = n())
# A tibble: 2,313 x 4
# Groups:   month, origin [?]
   month origin dest     nb
   <int> <chr>  <chr> <int>
 1     1 EWR    ALB      64
 2     1 EWR    ATL     362
 3     1 EWR    AUS      51
 4     1 EWR    AVL       2
 5     1 EWR    BDL      37
 6     1 EWR    BNA     111
 7     1 EWR    BOS     430
 8     1 EWR    BQN      31
 9     1 EWR    BTV     100
10     1 EWR    BUF     119
# ... with 2,303 more rows

Cela peut permettre “d’enchaîner” les opérations groupées. Dans l’exemple suivant on calcule le pourcentage des trajets pour chaque destination par rapport à tous les trajets du mois :

flights %>%
  group_by(month, dest) %>%
  summarise(nb = n()) %>% 
  mutate(pourcentage = nb / sum(nb) * 100)
# A tibble: 1,113 x 4
# Groups:   month [12]
   month dest     nb pourcentage
   <int> <chr> <int>       <dbl>
 1     1 ALB      64     0.237  
 2     1 ATL    1396     5.17   
 3     1 AUS     169     0.626  
 4     1 AVL       2     0.00741
 5     1 BDL      37     0.137  
 6     1 BHM      25     0.0926 
 7     1 BNA     399     1.48   
 8     1 BOS    1245     4.61   
 9     1 BQN      93     0.344  
10     1 BTV     223     0.826  
# ... with 1,103 more rows

On peut à tout moment “dégrouper” un tableau à l’aide de ungroup. Ce serait par exemple nécessaire, dans l’exemple précédent, si on voulait calculer le pourcentage sur le nombre total de vols plutôt que sur le nombre de vols par mois :

flights %>%
  group_by(month, dest) %>%
  summarise(nb = n()) %>% 
  ungroup() %>% 
  mutate(pourcentage = nb / sum(nb) * 100)
# A tibble: 1,113 x 4
   month dest     nb pourcentage
   <int> <chr> <int>       <dbl>
 1     1 ALB      64    0.0190  
 2     1 ATL    1396    0.415   
 3     1 AUS     169    0.0502  
 4     1 AVL       2    0.000594
 5     1 BDL      37    0.0110  
 6     1 BHM      25    0.00742 
 7     1 BNA     399    0.118   
 8     1 BOS    1245    0.370   
 9     1 BQN      93    0.0276  
10     1 BTV     223    0.0662  
# ... with 1,103 more rows

À noter que count, par contre, renvoit un tableau non groupé :

flights %>% 
  count(month, dest)
# A tibble: 1,113 x 3
   month dest      n
   <int> <chr> <int>
 1     1 ALB      64
 2     1 ATL    1396
 3     1 AUS     169
 4     1 AVL       2
 5     1 BDL      37
 6     1 BHM      25
 7     1 BNA     399
 8     1 BOS    1245
 9     1 BQN      93
10     1 BTV     223
# ... with 1,103 more rows

10.5 Autres fonctions utiles

dplyr contient beaucoup d’autres fonctions utiles pour la manipulation de données.

10.5.1 sample_n, sample_frac

Ces verbes permettent de sélectionner un nombre de lignes ou une fraction des lignes d’un tableau aléatoirement. Ainsi si on veut choisir 5 lignes au hasard dans le tableau airports :

airports %>% sample_n(5)
# A tibble: 5 x 9
  faa   name                lat    lon   alt    tz dst   tzone       alt_m
  <chr> <chr>             <dbl>  <dbl> <int> <dbl> <chr> <chr>       <dbl>
1 UT3   Hite Airport       37.9 -110    3840 -7.00 A     America/D… 1.17e³
2 BIS   Bismarck Municip…  46.8 -101    1661 -6.00 A     America/C… 5.06e²
3 LPR   Lorain County Re…  41.3 - 82.2   793 -5.00 A     America/N… 2.42e²
4 CAE   Columbia Metropo…  33.9 - 81.1   236 -5.00 A     America/N… 7.19e¹
5 MTH   Florida Keys Mar…  24.7 - 81.1     7 -5.00 A     America/N… 2.13e⁰

Si on veut tirer au hasard 10% des lignes de flights :

flights %>% sample_frac(0.1)
# A tibble: 33,678 x 21
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     9    27      738            740    - 2.00      853
 2  2013     8     1     1352           1300     52.0      1600
 3  2013    12    12     1153           1100     53.0      1439
 4  2013     9    20     1903           1905    - 2.00     2038
 5  2013     4     1     2105           1945     80.0      2349
 6  2013    12    27     2023           2030    - 7.00     2136
 7  2013     8     7     1039           1040    - 1.00     1238
 8  2013     9    10     1529           1530    - 1.00     1832
 9  2013     6     4     1641           1650    - 9.00     1835
10  2013     6    21      654            700    - 6.00      848
# ... with 33,668 more rows, and 14 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

Ces fonctions sont utiles notamment pour faire de “l’échantillonnage” en tirant au hasard un certain nombre d’observations du tableau.

10.5.2 lead et lag

lead et lag permettent de décaler les observations d’une variable d’un cran vers l’arrière (pour lead) ou vers l’avant (pour lag).

lead(1:5)
[1]  2  3  4  5 NA
lag(1:5)
[1] NA  1  2  3  4

Ceci peut être utile pour des données de type “séries temporelles”. Par exemple, on peut facilement calculer l’écart entre le retard au départ de chaque vol et celui du vol précédent :

flights %>%
  mutate(dep_delay_prev = lead(dep_delay),
         dep_delay_diff = dep_delay - dep_delay_prev) %>%
  select(dep_delay_prev, dep_delay, dep_delay_diff)
# A tibble: 336,776 x 3
   dep_delay_prev dep_delay dep_delay_diff
            <dbl>     <dbl>          <dbl>
 1           4.00      2.00          -2.00
 2           2.00      4.00           2.00
 3          -1.00      2.00           3.00
 4          -6.00     -1.00           5.00
 5          -4.00     -6.00          -2.00
 6          -5.00     -4.00           1.00
 7          -3.00     -5.00          -2.00
 8          -3.00     -3.00           0   
 9          -2.00     -3.00          -1.00
10          -2.00     -2.00           0   
# ... with 336,766 more rows

10.5.3 tally

tally est une fonction qui permet de compter le nombre d’observations d’un groupe :

flights %>% 
  group_by(month, origin, dest) %>% 
  tally
# A tibble: 2,313 x 4
# Groups:   month, origin [?]
   month origin dest      n
   <int> <chr>  <chr> <int>
 1     1 EWR    ALB      64
 2     1 EWR    ATL     362
 3     1 EWR    AUS      51
 4     1 EWR    AVL       2
 5     1 EWR    BDL      37
 6     1 EWR    BNA     111
 7     1 EWR    BOS     430
 8     1 EWR    BQN      31
 9     1 EWR    BTV     100
10     1 EWR    BUF     119
# ... with 2,303 more rows

Lors de son premier appel, elle sera équivalente à un summarise(n = n()) ou à un count(). Là où la fonction est intelligente, c’est que si on l’appelle plusieurs fois successivement, elle prendra en compte l’existence d’un n déjà calculé et effectuera automatiquement un summarise(n = sum(n)) :

flights %>% 
  group_by(month, origin, dest) %>% 
  tally %>%
  tally
Using `n` as weighting variable
# A tibble: 36 x 3
# Groups:   month [?]
   month origin    nn
   <int> <chr>  <int>
 1     1 EWR     9893
 2     1 JFK     9161
 3     1 LGA     7950
 4     2 EWR     9107
 5     2 JFK     8421
 6     2 LGA     7423
 7     3 EWR    10420
 8     3 JFK     9697
 9     3 LGA     8717
10     4 EWR    10531
# ... with 26 more rows

10.5.4 distinct

distinct filtre les lignes du tableau pour ne conserver que les lignes distinctes, en supprimant toutes les lignes en double.

flights %>%
  select(day, month) %>%
  distinct
# A tibble: 365 x 2
     day month
   <int> <int>
 1     1     1
 2     2     1
 3     3     1
 4     4     1
 5     5     1
 6     6     1
 7     7     1
 8     8     1
 9     9     1
10    10     1
# ... with 355 more rows

On peut lui spécifier une liste de variables : dans ce cas, pour toutes les observations ayant des valeurs identiques pour les variables en question, distinct ne conservera que la première d’entre elles.

flights %>%
  distinct(month, day)
# A tibble: 365 x 2
   month   day
   <int> <int>
 1     1     1
 2     1     2
 3     1     3
 4     1     4
 5     1     5
 6     1     6
 7     1     7
 8     1     8
 9     1     9
10     1    10
# ... with 355 more rows

L’option .keep_all permet, dans l’opération précédente, de conserver l’ensemble des colonnes du tableau :

flights %>%
  distinct(month, day, .keep_all = TRUE) 
# A tibble: 365 x 21
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     2       42           2359     43.0       518
 3  2013     1     3       32           2359     33.0       504
 4  2013     1     4       25           2359     26.0       505
 5  2013     1     5       14           2359     15.0       503
 6  2013     1     6       16           2359     17.0       451
 7  2013     1     7       49           2359     50.0       531
 8  2013     1     8      454            500    - 6.00      625
 9  2013     1     9        2           2359      3.00      432
10  2013     1    10        3           2359      4.00      426
# ... with 355 more rows, and 14 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, distance_km <dbl>, vitesse <dbl>

10.6 Tables multiples

Le jeu de données nycflights13 est un exemple de données réparties en plusieurs tables. Ici on en a trois : les informations sur les vols, celles sur les aéroports et celles sur les compagnies aériennes sont dans trois tables distinctes.

dplyr propose différentes fonctions permettant de travailler avec des données structurées de cette manière.

10.6.1 Concaténation : bind_rows et bind_cols

Les fonctions bind_rows et bind_cols permettent d’ajouter des lignes (respectivement des colonnes) à une table à partir d’une ou plusieurs autres tables.

L’exemple suivant (certes très artificiel) montre l’utilisation de bind_rows. On commence par créer trois tableaux t1, t2 et t3 :

t1 <- airports %>% 
  select(faa, name, lat, lon) %>% 
  slice(1:2)
t1
# A tibble: 2 x 4
  faa   name                            lat   lon
  <chr> <chr>                         <dbl> <dbl>
1 04G   Lansdowne Airport              41.1 -80.6
2 06A   Moton Field Municipal Airport  32.5 -85.7
t2 <- airports %>% 
  select(faa, name, lat, lon) %>% 
  slice(5:6)

t2
# A tibble: 2 x 4
  faa   name                             lat   lon
  <chr> <chr>                          <dbl> <dbl>
1 09J   Jekyll Island Airport           31.1 -81.4
2 0A9   Elizabethton Municipal Airport  36.4 -82.2
t3 <- airports %>% 
  select(faa, name) %>% 
  slice(100:101)
t3
# A tibble: 2 x 2
  faa   name             
  <chr> <chr>            
1 ADW   Andrews Afb      
2 AET   Allakaket Airport

On concaténe ensuite les trois tables avec bind_rows :

bind_rows(t1, t2, t3)
# A tibble: 6 x 4
  faa   name                             lat   lon
  <chr> <chr>                          <dbl> <dbl>
1 04G   Lansdowne Airport               41.1 -80.6
2 06A   Moton Field Municipal Airport   32.5 -85.7
3 09J   Jekyll Island Airport           31.1 -81.4
4 0A9   Elizabethton Municipal Airport  36.4 -82.2
5 ADW   Andrews Afb                     NA    NA  
6 AET   Allakaket Airport               NA    NA  

On remarquera que si des colonnes sont manquantes pour certaines tables, comme les colonnes lat et lon de t3, des NA sont automatiquement insérées.

Il peut être utile, quand on concatène des lignes, de garder une trace du tableau d’origine de chacune des lignes dans le tableau final. C’est possible grâce à l’argument .id de bind_rows. On passe à cet argument le nom d’une colonne qui contiendra l’indicateur d’origine des lignes :

bind_rows(t1, t2, t3, .id = "source")
# A tibble: 6 x 5
  source faa   name                             lat   lon
  <chr>  <chr> <chr>                          <dbl> <dbl>
1 1      04G   Lansdowne Airport               41.1 -80.6
2 1      06A   Moton Field Municipal Airport   32.5 -85.7
3 2      09J   Jekyll Island Airport           31.1 -81.4
4 2      0A9   Elizabethton Municipal Airport  36.4 -82.2
5 3      ADW   Andrews Afb                     NA    NA  
6 3      AET   Allakaket Airport               NA    NA  

Par défaut la colonne .id ne contient qu’un nombre, différent pour chaque tableau. On peut lui spécifier des valeurs plus explicites en “nommant” les tables dans bind_rows de la manière suivante :

bind_rows(table1 = t1, table2 = t2, table3 = t3, .id = "source")
# A tibble: 6 x 5
  source faa   name                             lat   lon
  <chr>  <chr> <chr>                          <dbl> <dbl>
1 table1 04G   Lansdowne Airport               41.1 -80.6
2 table1 06A   Moton Field Municipal Airport   32.5 -85.7
3 table2 09J   Jekyll Island Airport           31.1 -81.4
4 table2 0A9   Elizabethton Municipal Airport  36.4 -82.2
5 table3 ADW   Andrews Afb                     NA    NA  
6 table3 AET   Allakaket Airport               NA    NA  

bind_cols permet de concaténer des colonnes et fonctionne de manière similaire :

t1 <- flights %>% slice(1:5) %>% select(dep_delay, dep_time)
t2 <- flights %>% slice(1:5) %>% select(origin, dest)
t3 <- flights %>% slice(1:5) %>% select(arr_delay, arr_time)
bind_cols(t1, t2, t3)
# A tibble: 5 x 6
  dep_delay dep_time origin dest  arr_delay arr_time
      <dbl>    <int> <chr>  <chr>     <dbl>    <int>
1      2.00      517 EWR    IAH        11.0      830
2      4.00      533 LGA    IAH        20.0      850
3      2.00      542 JFK    MIA        33.0      923
4     -1.00      544 JFK    BQN       -18.0     1004
5     -6.00      554 LGA    ATL       -25.0      812

À noter que bind_cols associe les lignes uniquement par position. Les lignes des différents tableaux associés doivent donc correspondre (et leur nombre doit être identique). Pour associer des tables par valeur, on doit utiliser les jointures.

10.6.2 Jointures

10.6.2.1 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 carrier :

flights %>% select(carrier)
# A tibble: 336,776 x 1
   carrier
   <chr>  
 1 UA     
 2 UA     
 3 AA     
 4 B6     
 5 DL     
 6 UA     
 7 B6     
 8 EV     
 9 B6     
10 AA     
# ... with 336,766 more rows

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

airlines
# A tibble: 16 x 2
   carrier name                       
   <chr>   <chr>                      
 1 9E      Endeavor Air Inc.          
 2 AA      American Airlines Inc.     
 3 AS      Alaska Airlines Inc.       
 4 B6      JetBlue Airways            
 5 DL      Delta Air Lines Inc.       
 6 EV      ExpressJet Airlines Inc.   
 7 F9      Frontier Airlines Inc.     
 8 FL      AirTran Airways Corporation
 9 HA      Hawaiian Airlines Inc.     
10 MQ      Envoy Air                  
11 OO      SkyWest Airlines Inc.      
12 UA      United Air Lines Inc.      
13 US      US Airways Inc.            
14 VX      Virgin America             
15 WN      Southwest Airlines Co.     
16 YV      Mesa Airlines Inc.         

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 :

left_join(flights, airlines)

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

left_join(flights, airlines) %>% 
  select(month, day, carrier, name)
Joining, by = "carrier"
# A tibble: 336,776 x 4
   month   day carrier name                    
   <int> <int> <chr>   <chr>                   
 1     1     1 UA      United Air Lines Inc.   
 2     1     1 UA      United Air Lines Inc.   
 3     1     1 AA      American Airlines Inc.  
 4     1     1 B6      JetBlue Airways         
 5     1     1 DL      Delta Air Lines Inc.    
 6     1     1 UA      United Air Lines Inc.   
 7     1     1 B6      JetBlue Airways         
 8     1     1 EV      ExpressJet Airlines Inc.
 9     1     1 B6      JetBlue Airways         
10     1     1 AA      American Airlines Inc.  
# ... with 336,766 more rows

On voit que la table résultat est bien la fusion des deux tables d’origine selon les valeurs des deux colonnes clés carrier. On est parti de la table flights, et pour chaque ligne on a ajouté les colonnes de airlines pour lesquelles la valeur de carrier 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.

À noter qu’on peut tout à fait utiliser le pipe avec les fonctions de jointure :

flights %>% left_join(airlines).

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 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 carrier.

10.6.2.2 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 faa.

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 origin, et pour celui d’arrivée dans la colonne dest. 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 :

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

Si on se contente d’un left_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 :

left_join(flights_ex, airports_ex)
Error: `by` required, because the data sources have no common variables

On doit donc spécifier explicitement les clés avec l’argument by de left_join. Ici la clé est nommée origin dans la première table, et faa dans la seconde. La syntaxe est donc la suivante :

left_join(flights_ex, airports_ex, by = c("origin" = "faa"))
# A tibble: 336,776 x 6
   month   day origin dest    alt name               
   <int> <int> <chr>  <chr> <int> <chr>              
 1     1     1 EWR    IAH      18 Newark Liberty Intl
 2     1     1 LGA    IAH      22 La Guardia         
 3     1     1 JFK    MIA      13 John F Kennedy Intl
 4     1     1 JFK    BQN      13 John F Kennedy Intl
 5     1     1 LGA    ATL      22 La Guardia         
 6     1     1 EWR    ORD      18 Newark Liberty Intl
 7     1     1 EWR    FLL      18 Newark Liberty Intl
 8     1     1 LGA    IAD      22 La Guardia         
 9     1     1 JFK    MCO      13 John F Kennedy Intl
10     1     1 LGA    ORD      22 La Guardia         
# ... with 336,766 more rows

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

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

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 dest dans la première table, et faa dans la deuxième. La syntaxe est donc la suivante :

left_join(flights_ex, airports_ex, by=c("dest" = "faa"))
# A tibble: 336,776 x 8
   month   day origin dest  alt.x name.x              alt.y name.y        
   <int> <int> <chr>  <chr> <int> <chr>               <int> <chr>         
 1     1     1 EWR    IAH      18 Newark Liberty Intl    97 George Bush I…
 2     1     1 LGA    IAH      22 La Guardia             97 George Bush I…
 3     1     1 JFK    MIA      13 John F Kennedy Intl     8 Miami Intl    
 4     1     1 JFK    BQN      13 John F Kennedy Intl    NA <NA>          
 5     1     1 LGA    ATL      22 La Guardia           1026 Hartsfield Ja…
 6     1     1 EWR    ORD      18 Newark Liberty Intl   668 Chicago Ohare…
 7     1     1 EWR    FLL      18 Newark Liberty Intl     9 Fort Lauderda…
 8     1     1 LGA    IAD      22 La Guardia            313 Washington Du…
 9     1     1 JFK    MCO      13 John F Kennedy Intl    96 Orlando Intl  
10     1     1 LGA    ORD      22 La Guardia            668 Chicago Ohare…
# ... with 336,766 more rows

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 name et alt. Comme on ne peut pas avoir deux colonnes avec le même nom dans un tableau, dplyr 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, mais on peut aussi utiliser l’argument suffix de left_join, qui permet d’indiquer les suffixes à ajouter aux colonnes. Ainsi, on peut faire :

left_join(flights_ex, airports_ex, 
          by = c("dest" = "faa"), 
          suffix = c("_depart", "_arrivee"))
# A tibble: 336,776 x 8
   month   day origin dest  alt_depart name_depart         alt_arrivee
   <int> <int> <chr>  <chr>      <int> <chr>                     <int>
 1     1     1 EWR    IAH           18 Newark Liberty Intl          97
 2     1     1 LGA    IAH           22 La Guardia                   97
 3     1     1 JFK    MIA           13 John F Kennedy Intl           8
 4     1     1 JFK    BQN           13 John F Kennedy Intl          NA
 5     1     1 LGA    ATL           22 La Guardia                 1026
 6     1     1 EWR    ORD           18 Newark Liberty Intl         668
 7     1     1 EWR    FLL           18 Newark Liberty Intl           9
 8     1     1 LGA    IAD           22 La Guardia                  313
 9     1     1 JFK    MCO           13 John F Kennedy Intl          96
10     1     1 LGA    ORD           22 La Guardia                  668
# ... with 336,766 more rows, and 1 more variable: name_arrivee <chr>

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

10.6.3 Types de jointures

Jusqu’à présent nous avons utilisé la fonction left_join, mais il existe plusieurs types de jointures.

Partons de deux tables d’exemple, personnes et voitures :

personnes <- data_frame(nom = c("Sylvie", "Sylvie", "Monique", "Gunter", "Rayan", "Rayan"),
                        voiture = c("Twingo", "Ferrari", "Scenic", "Lada", "Twingo", "Clio"))
nom voiture
Sylvie Twingo
Sylvie Ferrari
Monique Scenic
Gunter Lada
Rayan Twingo
Rayan Clio
voitures <- data_frame(voiture = c("Twingo", "Ferrari", "Clio", "Lada", "208"),
                       vitesse = c("140", "280", "160", "85", "160"))
voiture vitesse
Twingo 140
Ferrari 280
Clio 160
Lada 85
208 160

10.6.3.1 left_join

Si on fait un left_join de voitures sur personnes :

left_join(personnes, voitures)
Joining, by = "voiture"
nom voiture vitesse
Sylvie Twingo 140
Sylvie Ferrari 280
Monique Scenic NA
Gunter Lada 85
Rayan Twingo 140
Rayan Clio 160

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 cette fois de personnes sur voitures, c’est l’inverse :

left_join(voitures, personnes)
Joining, by = "voiture"
voiture vitesse nom
Twingo 140 Sylvie
Twingo 140 Rayan
Ferrari 280 Sylvie
Clio 160 Rayan
Lada 85 Gunter
208 160 NA

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 sera le type de jointures le plus fréquemment utilisé.

10.6.3.2 right_join

La jointure right_join est l’exacte symétrique de left_join, c’est-à dire que right_join(x, y) est équivalent à left_join(x,y) :

right_join(personnes, voitures)
Joining, by = "voiture"
nom voiture vitesse
Sylvie Twingo 140
Rayan Twingo 140
Sylvie Ferrari 280
Rayan Clio 160
Gunter Lada 85
NA 208 160

10.6.3.3 inner_join

Dans le cas de inner_join(x, y), 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 :

inner_join(personnes, voitures)
Joining, by = "voiture"
nom voiture vitesse
Sylvie Twingo 140
Sylvie Ferrari 280
Gunter Lada 85
Rayan Twingo 140
Rayan Clio 160

Ici la ligne 208 est absente, ainsi que la ligne Monique, qui dans le cas d’un left_join avait été conservée et s’était vue attribuer une vitesse à NA.

10.6.3.4 full_join

Dans le cas de full_join(x, y), 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 :

full_join(personnes, voitures)
Joining, by = "voiture"
nom voiture vitesse
Sylvie Twingo 140
Sylvie Ferrari 280
Monique Scenic NA
Gunter Lada 85
Rayan Twingo 140
Rayan Clio 160
NA 208 160

10.6.3.5 semi_join et anti_join

semi_join et anti_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 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 :

semi_join(personnes, voitures)
Joining, by = "voiture"
nom voiture
Sylvie Twingo
Sylvie Ferrari
Gunter Lada
Rayan Twingo
Rayan Clio

Un anti_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 :

anti_join(personnes, voitures)
Joining, by = "voiture"
nom voiture
Monique Scenic

10.7 Ressources

Toutes les ressources ci-dessous sont en anglais…

Le livre R for data science, librement accessible en ligne, contient plusieurs chapitres très complets sur la manipulation des données, notamment :

Le site de l’extension comprend une liste des fonctions et les pages d’aide associées, mais aussi une introduction au package et plusieurs articles dont un spécifiquement sur les jointures.

Enfin, une “antisèche” très synthétique est également accessible depuis RStudio, en allant dans le menu Help puis Cheatsheets et Data Transformation with dplyr.

10.8 Exercices

On commence par charger les extensions et les données nécessaires.

library(tidyverse)
library(nycflights13)
data(flights)
data(airports)
data(airlines)

10.8.1 Les verbes de base de dplyr

Exercice 1.1

Sélectionner les lignes 100 à 105 du tableau des vols (flights).

# A tibble: 6 x 19
   year month   day dep_time sched_dep_time dep_delay arr_time
  <int> <int> <int>    <int>          <int>     <dbl>    <int>
1  2013     1     1      752            759     -7.00      955
2  2013     1     1      753            755     -2.00     1056
3  2013     1     1      754            759     -5.00     1039
4  2013     1     1      754            755     -1.00     1103
5  2013     1     1      758            800     -2.00     1053
6  2013     1     1      759            800     -1.00     1057
# ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
#   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
#   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
#   time_hour <dttm>
slice(flights, 100:105)

Exercice 1.2

Sélectionnez les vols du mois de juillet (variable month).

# A tibble: 29,425 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     7     1        1           2029    212         236
 2  2013     7     1        2           2359      3.00      344
 3  2013     7     1       29           2245    104         151
 4  2013     7     1       43           2130    193         322
 5  2013     7     1       44           2150    174         300
 6  2013     7     1       46           2051    235         304
 7  2013     7     1       48           2001    287         308
 8  2013     7     1       58           2155    183         335
 9  2013     7     1      100           2146    194         327
10  2013     7     1      100           2245    135         337
# ... with 29,415 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>
filter(flights, month == 7)

Sélectionnez les vols avec un retard à l’arrivée (variable arr_delay) compris entre 5 et 15 minutes.

# A tibble: 36,392 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      554            558    - 4.00      740
 3  2013     1     1      558            600    - 2.00      753
 4  2013     1     1      558            600    - 2.00      924
 5  2013     1     1      600            600      0         837
 6  2013     1     1      611            600     11.0       945
 7  2013     1     1      623            610     13.0       920
 8  2013     1     1      624            630    - 6.00      840
 9  2013     1     1      629            630    - 1.00      824
10  2013     1     1      632            608     24.0       740
# ... with 36,382 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>
filter(flights, arr_delay >= 5 & arr_delay <= 15)

Sélectionnez les vols des compagnies Delta, United et American (codes AA, DL et UA).

# A tibble: 139,504 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      533            529      4.00      850
 3  2013     1     1      542            540      2.00      923
 4  2013     1     1      554            600     -6.00      812
 5  2013     1     1      554            558     -4.00      740
 6  2013     1     1      558            600     -2.00      753
 7  2013     1     1      558            600     -2.00      924
 8  2013     1     1      558            600     -2.00      923
 9  2013     1     1      559            600     -1.00      941
10  2013     1     1      559            600     -1.00      854
# ... with 139,494 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>
filter(flights, carrier %in% c("AA", "DL", "UA"))

Exercice 1.3

Triez la table flights par retard au départ décroissant.

# A tibble: 336,776 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     9      641            900      1301     1242
 2  2013     6    15     1432           1935      1137     1607
 3  2013     1    10     1121           1635      1126     1239
 4  2013     9    20     1139           1845      1014     1457
 5  2013     7    22      845           1600      1005     1044
 6  2013     4    10     1100           1900       960     1342
 7  2013     3    17     2321            810       911      135
 8  2013     6    27      959           1900       899     1236
 9  2013     7    22     2257            759       898      121
10  2013    12     5      756           1700       896     1058
# ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>
arrange(flights, desc(dep_delay))

Exercice 1.4

Sélectionnez les colonnes name, lat et lon de la table airports

# A tibble: 1,458 x 3
   name                             lat    lon
   <chr>                          <dbl>  <dbl>
 1 Lansdowne Airport               41.1 - 80.6
 2 Moton Field Municipal Airport   32.5 - 85.7
 3 Schaumburg Regional             42.0 - 88.1
 4 Randall Airport                 41.4 - 74.4
 5 Jekyll Island Airport           31.1 - 81.4
 6 Elizabethton Municipal Airport  36.4 - 82.2
 7 Williams County Airport         41.5 - 84.5
 8 Finger Lakes Regional Airport   42.9 - 76.8
 9 Shoestring Aviation Airfield    39.8 - 76.6
10 Jefferson County Intl           48.1 -123  
# ... with 1,448 more rows
select(airports, name, lat, lon)

Sélectionnez toutes les colonnes de la table airports sauf les colonnes tz et tzone

# A tibble: 1,458 x 6
   faa   name                             lat    lon   alt dst  
   <chr> <chr>                          <dbl>  <dbl> <int> <chr>
 1 04G   Lansdowne Airport               41.1 - 80.6  1044 A    
 2 06A   Moton Field Municipal Airport   32.5 - 85.7   264 A    
 3 06C   Schaumburg Regional             42.0 - 88.1   801 A    
 4 06N   Randall Airport                 41.4 - 74.4   523 A    
 5 09J   Jekyll Island Airport           31.1 - 81.4    11 A    
 6 0A9   Elizabethton Municipal Airport  36.4 - 82.2  1593 A    
 7 0G6   Williams County Airport         41.5 - 84.5   730 A    
 8 0G7   Finger Lakes Regional Airport   42.9 - 76.8   492 A    
 9 0P2   Shoestring Aviation Airfield    39.8 - 76.6  1000 U    
10 0S9   Jefferson County Intl           48.1 -123     108 A    
# ... with 1,448 more rows
select(airports, -tz, -tzone)

Toujours dans la table airports, renommez la colonne lat en latitude et lon en longitude.

# A tibble: 1,458 x 8
   faa   name             latitude longitude   alt    tz dst   tzone      
   <chr> <chr>               <dbl>     <dbl> <int> <dbl> <chr> <chr>      
 1 04G   Lansdowne Airpo…     41.1    - 80.6  1044 -5.00 A     America/Ne…
 2 06A   Moton Field Mun…     32.5    - 85.7   264 -6.00 A     America/Ch…
 3 06C   Schaumburg Regi…     42.0    - 88.1   801 -6.00 A     America/Ch…
 4 06N   Randall Airport      41.4    - 74.4   523 -5.00 A     America/Ne…
 5 09J   Jekyll Island A…     31.1    - 81.4    11 -5.00 A     America/Ne…
 6 0A9   Elizabethton Mu…     36.4    - 82.2  1593 -5.00 A     America/Ne…
 7 0G6   Williams County…     41.5    - 84.5   730 -5.00 A     America/Ne…
 8 0G7   Finger Lakes Re…     42.9    - 76.8   492 -5.00 A     America/Ne…
 9 0P2   Shoestring Avia…     39.8    - 76.6  1000 -5.00 U     America/Ne…
10 0S9   Jefferson Count…     48.1    -123     108 -8.00 A     America/Lo…
# ... with 1,448 more rows
rename(airports, latitude = lat, longitude = lon)

Exercice 1.5

Dans la table flights, créer une nouvelle variable duree_h contenant la durée du vol (variable air_time) en heures. Sélectionner dans la table obtenue uniquement les deux colonnes air_time et duree_h.

# A tibble: 336,776 x 2
   air_time duree_h
      <dbl>   <dbl>
 1    227     3.78 
 2    227     3.78 
 3    160     2.67 
 4    183     3.05 
 5    116     1.93 
 6    150     2.50 
 7    158     2.63 
 8     53.0   0.883
 9    140     2.33 
10    138     2.30 
# ... with 336,766 more rows
tmp <- mutate(flights, duree_h = air_time / 60)
select(tmp, air_time, duree_h)

10.8.2 Enchaîner des opérations

Exercice 2.1

Réécrire le code de l’exercice précédent en utilisant le pipe %>%.

flights %>% 
  mutate(duree_h = air_time / 60) %>% 
  select(air_time, duree_h)

Exercice 2.2

Sélectionnez les vols à destination de San Francico (code SFO de la variable dest) et triez-les selon le retard au départ décroissant (variable dep_delay).

# A tibble: 13,331 x 19
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     9    20     1139           1845      1014     1457
 2  2013     7     7     2123           1030       653       17
 3  2013     7     7     2059           1030       629      106
 4  2013     7     6      149           1600       589      456
 5  2013     7    10      133           1800       453      455
 6  2013     7    10     2342           1630       432      312
 7  2013     7     7     2204           1525       399      107
 8  2013     7     7     2306           1630       396      250
 9  2013     6    23     1833           1200       393       NA
10  2013     7    10     2232           1609       383      138
# ... with 13,321 more rows, and 12 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>
flights %>% 
  filter(dest == "SFO") %>% 
  arrange(desc(dep_delay))

Exercice 2.3

Sélectionnez les vols des mois de septembre et octobre, conservez les colonnes dest et dep_delay, créez une nouvelle variable retard_h contenant le retard au départ en heures, triez selon retard_h par ordre décroissant et conservez uniquement les 5 premières lignes.

# A tibble: 5 x 3
  dest  dep_delay retard_h
  <chr>     <dbl>    <dbl>
1 SFO        1014    16.9 
2 ATL         702    11.7 
3 DTW         696    11.6 
4 ATL         602    10.0 
5 MSP         593     9.88
flights %>% 
  filter(month %in% c(9, 10)) %>% 
  select(dest, dep_delay) %>% 
  mutate(retard_h = dep_delay / 60) %>% 
  arrange(desc(retard_h)) %>% 
  slice(1:5)

10.8.3 group_by et summarise

Exercice 3.1

Affichez le nombre de vols par mois.

# A tibble: 12 x 2
   month     n
   <int> <int>
 1     1 27004
 2     2 24951
 3     3 28834
 4     4 28330
 5     5 28796
 6     6 28243
 7     7 29425
 8     8 29327
 9     9 27574
10    10 28889
11    11 27268
12    12 28135
flights %>% 
  group_by(month) %>% 
  summarise(n = n())

Triez la table résultat selon le nombre de vols croissant.

# A tibble: 12 x 2
   month     n
   <int> <int>
 1     2 24951
 2     1 27004
 3    11 27268
 4     9 27574
 5    12 28135
 6     6 28243
 7     4 28330
 8     5 28796
 9     3 28834
10    10 28889
11     8 29327
12     7 29425
flights %>% 
  group_by(month) %>% 
  summarise(n = n()) %>% 
  arrange(n)

Exercice 3.2

Calculer le retard au départ moyen selon le mois.

# A tibble: 12 x 2
   month retard_moyen
   <int>        <dbl>
 1     1        10.0 
 2     2        10.8 
 3     3        13.2 
 4     4        13.9 
 5     5        13.0 
 6     6        20.8 
 7     7        21.7 
 8     8        12.6 
 9     9         6.72
10    10         6.24
11    11         5.44
12    12        16.6 
flights %>%
  group_by(month) %>% 
  summarise(retard_moyen = mean(dep_delay, na.rm = TRUE))

Exercice 3.3

Calculer le nombre de vols à destination de Los Angeles (code LAX) pour chaque mois de l’année.

# A tibble: 12 x 2
   month     n
   <int> <int>
 1     1  1159
 2     2  1030
 3     3  1178
 4     4  1382
 5     5  1453
 6     6  1430
 7     7  1500
 8     8  1505
 9     9  1384
10    10  1409
11    11  1336
12    12  1408
flights %>% 
  filter(dest == "LAX") %>% 
  count(month)

Exercice 3.4

Calculer le nombre de vols selon le mois et la destination.

# A tibble: 1,113 x 3
   month dest      n
   <int> <chr> <int>
 1     1 ALB      64
 2     1 ATL    1396
 3     1 AUS     169
 4     1 AVL       2
 5     1 BDL      37
 6     1 BHM      25
 7     1 BNA     399
 8     1 BOS    1245
 9     1 BQN      93
10     1 BTV     223
# ... with 1,103 more rows
flights %>% 
  count(month, dest)

Ne conserver, pour chaque mois, que la destination avec le nombre maximal de vols.

# A tibble: 12 x 3
# Groups:   month [12]
   month dest      n
   <int> <chr> <int>
 1     1 ATL    1396
 2     2 ATL    1267
 3     3 ATL    1448
 4     4 ATL    1490
 5     5 ORD    1582
 6     6 ORD    1547
 7     7 ORD    1573
 8     8 ORD    1604
 9     9 ORD    1582
10    10 ORD    1604
11    11 ATL    1384
12    12 ATL    1463
flights %>% 
  count(month, dest) %>% 
  group_by(month) %>% 
  filter(n == max(n))

Exercice 3.5

Calculer le nombre de vols selon le mois. Ajouter une colonne comportant le pourcentage de vols annuels réalisés par mois.

# A tibble: 12 x 3
   month     n pourcentage
   <int> <int>       <dbl>
 1     1 27004        8.02
 2     2 24951        7.41
 3     3 28834        8.56
 4     4 28330        8.41
 5     5 28796        8.55
 6     6 28243        8.39
 7     7 29425        8.74
 8     8 29327        8.71
 9     9 27574        8.19
10    10 28889        8.58
11    11 27268        8.10
12    12 28135        8.35
flights %>% 
  count(month) %>% 
  mutate(pourcentage = n/sum(n) * 100) 

Exercice 3.6

Calculer, pour chaque destination et chaque mois, le retard moyen à l’arrivée. Pour chaque mois, trier les destinations selon ce retard moyen décroissant, et (toujours pour chaque mois) ne conserver que les trois destinations avec le retard le plus important.

# A tibble: 36 x 3
# Groups:   month [12]
   month dest  retard_moyen
   <int> <chr>        <dbl>
 1     1 TUL           68.1
 2     1 OKC           57.7
 3     1 CAE           55.9
 4     2 DSM           48.2
 5     2 TUL           33.5
 6     2 GSP           32.9
 7     3 DSM           60.6
 8     3 CAE           46.9
 9     3 PVD           44.3
10     4 CAE           71.3
# ... with 26 more rows
flights %>% 
  group_by(month, dest) %>% 
  summarise(retard_moyen = mean(arr_delay, na.rm = TRUE)) %>% 
  group_by(month) %>% 
  arrange(desc(retard_moyen), .by_group = TRUE) %>% 
  slice(1:3)

10.8.4 Jointures

Exercice 4.1

Faire la jointure de la table airlines sur la table flights à l’aide de left_join.

# A tibble: 336,776 x 20
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      533            529      4.00      850
 3  2013     1     1      542            540      2.00      923
 4  2013     1     1      544            545     -1.00     1004
 5  2013     1     1      554            600     -6.00      812
 6  2013     1     1      554            558     -4.00      740
 7  2013     1     1      555            600     -5.00      913
 8  2013     1     1      557            600     -3.00      709
 9  2013     1     1      557            600     -3.00      838
10  2013     1     1      558            600     -2.00      753
# ... with 336,766 more rows, and 13 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, name <chr>
flights %>% 
  left_join(airlines)

Exercice 4.2

À partir de la table résultat de l’exercice précédent, calculer le retard moyen au départ pour chaque compagnie, trier selon ce retard décroissant et afficher le nom de la compagnie et le retard correspondant.

# A tibble: 16 x 2
   name                        retard_moyen
   <chr>                              <dbl>
 1 Frontier Airlines Inc.             20.2 
 2 ExpressJet Airlines Inc.           20.0 
 3 Mesa Airlines Inc.                 19.0 
 4 AirTran Airways Corporation        18.7 
 5 Southwest Airlines Co.             17.7 
 6 Endeavor Air Inc.                  16.7 
 7 JetBlue Airways                    13.0 
 8 Virgin America                     12.9 
 9 SkyWest Airlines Inc.              12.6 
10 United Air Lines Inc.              12.1 
11 Envoy Air                          10.6 
12 Delta Air Lines Inc.                9.26
13 American Airlines Inc.              8.59
14 Alaska Airlines Inc.                5.80
15 Hawaiian Airlines Inc.              4.90
16 US Airways Inc.                     3.78
flights %>% 
  left_join(airlines) %>% 
  group_by(name) %>% 
  summarise(retard_moyen = mean(dep_delay, na.rm = TRUE)) %>% 
  arrange(desc(retard_moyen))

Exercice 4.3

Faire la jointure de la table airports sur la table flights en utilisant comme clé le code de l’aéroport de destination.

# A tibble: 336,776 x 26
    year month   day dep_time sched_dep_time dep_delay arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>
 1  2013     1     1      517            515      2.00      830
 2  2013     1     1      533            529      4.00      850
 3  2013     1     1      542            540      2.00      923
 4  2013     1     1      544            545     -1.00     1004
 5  2013     1     1      554            600     -6.00      812
 6  2013     1     1      554            558     -4.00      740
 7  2013     1     1      555            600     -5.00      913
 8  2013     1     1      557            600     -3.00      709
 9  2013     1     1      557            600     -3.00      838
10  2013     1     1      558            600     -2.00      753
# ... with 336,766 more rows, and 19 more variables: sched_arr_time <int>,
#   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
#   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
#   minute <dbl>, time_hour <dttm>, name <chr>, lat <dbl>, lon <dbl>,
#   alt <int>, tz <dbl>, dst <chr>, tzone <chr>
flights %>% 
  left_join(airports, by = c("dest" = "faa"))

À partir de cette table, afficher pour chaque mois le nom de l’aéroport de destination ayant eu le plus petit nombre de vol.

# A tibble: 14 x 3
# Groups:   month [12]
   month name                      n
   <int> <chr>                 <int>
 1     1 Key West Intl             1
 2     2 Jackson Hole Airport      3
 3     3 Bangor Intl               2
 4     4 Key West Intl             1
 5     4 Myrtle Beach Intl         1
 6     5 Columbia Metropolitan     9
 7     6 Myrtle Beach Intl         1
 8     7 La Guardia                1
 9     8 South Bend Rgnl           1
10     9 South Bend Rgnl           5
11    10 Albany Intl               1
12    10 South Bend Rgnl           1
13    11 Blue Grass                1
14    12 South Bend Rgnl           1
flights %>% 
  left_join(airports, by = c("dest" = "faa")) %>% 
  count(month, name) %>% 
  group_by(month) %>% 
  filter(n == min(n))

Exercice 4.4

Créer une table indiquant, pour chaque trajet, le nom de l’aéroport de départ et celui de l’aéroport d’arrivée.

# A tibble: 336,776 x 2
   orig_name           dest_name                      
   <chr>               <chr>                          
 1 Newark Liberty Intl George Bush Intercontinental   
 2 La Guardia          George Bush Intercontinental   
 3 John F Kennedy Intl Miami Intl                     
 4 John F Kennedy Intl <NA>                           
 5 La Guardia          Hartsfield Jackson Atlanta Intl
 6 Newark Liberty Intl Chicago Ohare Intl             
 7 Newark Liberty Intl Fort Lauderdale Hollywood Intl 
 8 La Guardia          Washington Dulles Intl         
 9 John F Kennedy Intl Orlando Intl                   
10 La Guardia          Chicago Ohare Intl             
# ... with 336,766 more rows
flights %>% 
  left_join(airports, by = c("dest" = "faa")) %>% 
  rename(dest_name = name) %>% 
  left_join(airports, by = c("origin" = "faa")) %>% 
  rename(orig_name = name) %>% 
  select(orig_name, dest_name) 

10.8.5 Bonus

Exercice 5.1

Calculer le nombre de vols selon l’aéroport de destination, et fusionnez la table airports sur le résultat avec left_join. Stocker le résultat final dans un objet nommé flights_dest.

# A tibble: 105 x 9
   dest      n name                lat    lon   alt    tz dst   tzone     
   <chr> <int> <chr>             <dbl>  <dbl> <int> <dbl> <chr> <chr>     
 1 ABQ     254 Albuquerque Inte…  35.0 -107    5355 -7.00 A     America/D…
 2 ACK     265 Nantucket Mem      41.3 - 70.1    48 -5.00 A     America/N…
 3 ALB     439 Albany Intl        42.7 - 73.8   285 -5.00 A     America/N…
 4 ANC       8 Ted Stevens Anch…  61.2 -150     152 -9.00 A     America/A…
 5 ATL   17215 Hartsfield Jacks…  33.6 - 84.4  1026 -5.00 A     America/N…
 6 AUS    2439 Austin Bergstrom…  30.2 - 97.7   542 -6.00 A     America/C…
 7 AVL     275 Asheville Region…  35.4 - 82.5  2165 -5.00 A     America/N…
 8 BDL     443 Bradley Intl       41.9 - 72.7   173 -5.00 A     America/N…
 9 BGR     375 Bangor Intl        44.8 - 68.8   192 -5.00 A     America/N…
10 BHM     297 Birmingham Intl    33.6 - 86.8   644 -6.00 A     America/C…
# ... with 95 more rows
flights_dest <- flights %>% 
  count(dest) %>% 
  left_join(airports, by = c("dest"="faa"))

Créez une carte interactive des résultats avec leaflet et le code suivant :

library(leaflet)
leaflet(data = flights_dest) %>%
  addTiles %>%
  addCircles(lng=~lon, lat=~lat, radius=~n * 10, popup=~name)

Créez une carte statique des résultats avec ggmap et le code suivant :

library(ggmap)
map <- get_map(location = "Kansas", zoom=4, color="bw")
ggmap(map, extent = "device") +
  geom_point(data = flights_dest, aes(x=lon, y=lat, size=n), 
             color = "red", alpha = 0.2)

  1. À noter que cette opération est un peu plus “fragile” que les autres, car si l’ordre des colonnes change elle peut renvoyer un résultat différent.

  2. Il est également possible de renommer des colonnes directement avec select, avec la même syntaxe que pour rename.

  3. Le pipe a été introduit à l’origine par l’extension magrittr, et repris par dplyr