4 Manipuler les données

4.1 Des données propres et bien organisées

Contrairement à ce que l’on peut s’attendre lorsque l’on commence à faire des statistiques, la majorité de votre temps ne sera pas passée à effectuer des tests statistiques. La grande majorité de votre temps sera plutôt passée à nettoyer et organiser vos données.

À la différence de Excel où l’on peut organiser nos données plus ou moins comme bon nous semble, les logiciels spécialisés dans l’analyse de données comme R s’attendent à ce que les données soient dans un format particulier, toujours structuré de la même façon : on parlera de données propres et bien organisées (tidy data). Pour savoir si vos données sont propres et bien organisées, elles doivent répondre à trois grands principes :

Chaque variable est représentée par une colonne
Chaque observation est une ligne
Chaque type d’observation est dans son propre tableau de données

Voici un exemple de données bien organisées, décrivant des sites forestiers :

site	couvert_pct	pente_degres	traitement
A	20	3	Éclaircie
B	60	2	Contrôle
C	10	15	Éclaircie

4.2 Labo : Préparatifs

Il existe dans R de base un langage de manipulation de données, basé sur la façon dont les programmeurs manipulent leurs données. Selon l’avis de plusieurs (moi le premier!), cette approche n’est pas très appropriée lorsque notre but n’est pas de devenir programmeur, mais simplement de pouvoir jouer avec nos données le plus simplement possible. C’est avec l’idée de corriger cette lacune qu’a été créée la librairie de code dplyr (prononcez di-playeur, comme data-pliers, “pinces à données”), dont le but est de rendre les manipulations de données plus lisibles et intuitives. C’est cette bibliothèque que nous utiliserons pour manipuler les données.

Comme pour ggplot2, utilisez le code suivant pour installer la librairie dplyr :

install.packages("dplyr")

Cette opération pourrait prendre quelques minutes. Par la suite, n’oubliez pas d’activer la librairie dplyr chaque fois vous aurez besoin de l’utiliser, avec le code suivant :

library(dplyr)


Attaching package: 'dplyr'

The following objects are masked from 'package:stats':

    filter, lag

The following objects are masked from 'package:base':

    intersect, setdiff, setequal, union

Notez qu’à ce point, vous obtiendrez une série d’avertissements pour vous expliquer que dplyr cache certains objets de R (“the following objects are masked…” ). Il s’agit simplement d’un avertissement, nous indiquant que certaines fonctions de dplyr ont le même nom que des fonctions de base de R, et que ces dernières ont été cachées par dplyr.

Pour nos exemples de ce chapitre, nous utiliserons à nouveau le tableau de données penguins, n’oubliez donc pas sa librairie avant de commencer.

library(palmerpenguins)

Vous êtes maintenant prêtes à attaquer vos données!

4.3 Cinq opérations de base

Bien que la manipulation de données puisse devenir extrêmement complexe et pointue, elle peut en général se résumer à cinq opérations de base :

Filtrer des observations
Trier les observations (i.e. changer l’ordre)
Ajouter des variables
Sélectionner des variables
Résumer les données.

La grande majorité de ce que vous pourriez faire avec vos données peut se résumer à la combinaison de ces opérations.

4.4 Labo : Filtrer des observations

La fonction de dplyr permettant de filtrer les observations se nomme… filter! Elle reçoit deux arguments, le premier étant le tableau de données sur lequel appliquer le filtre, et le deuxième décrivant la condition que devront respecter les observations pour être conservées. P. ex. pour conserver uniquement les manchots dont le poids du corps est de plus de 4 kg, nous écrierions le code suivant :

filter(penguins, body_mass_g > 4000)

Suite à cette commande, R vous répond avec un aperçu du tableau de données modifié :

# A tibble: 172 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.2          19.6
 2 Adelie  Torgersen           42            20.2
 3 Adelie  Torgersen           34.6          21.1
 4 Adelie  Torgersen           42.5          20.7
 5 Adelie  Torgersen           46            21.5
 6 Adelie  Dream               39.2          21.1
 7 Adelie  Dream               39.8          19.1
 8 Adelie  Dream               44.1          19.7
 9 Adelie  Dream               39.6          18.8
10 Adelie  Dream               42.3          21.2
# ℹ 162 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Vous constatez que ce tableau de données ne contient que 172 lignes plutôt que 344 initialement.

Avertissement

Mais attention, le tableau de données penguins original n’a pas été modifié par votre commande.

Il s’agit d’un principe extrêmement important à comprendre lorsque l’on travaille avec R. À moins qu’on le demande clairement, R ne touche pas à notre tableau de données original. Il nous affiche notre résultat, puis il l’oublie (c’est un peu bête, mais c’est comme ça!).

Pour conserver le résultat d’une opération dans R, il faut assigner ce résultat à un objet avec l’opérateur d’assignation (<-). P. ex. on pourrait se créer un tableau de données de petits manchots avec la commande suivante :

petits_manchots <- filter(penguins, body_mass_g < 4000)

On peut lire une telle commande comme : filtrer le tableau de données penguins, puis prendre le résultat et le pousser (<-) dans l’objet petits_manchots. Nous avons à ce moment deux objets dans notre environnement de travail : penguins, qui contient tous les manchots, et petits_manchots, qui en contient un sous-ensemble. Comme expliqué au Chapitre 3, on peut utiliser la commande View pour voir ces deux tableaux :

View(penguins)
View(petits_manchots)

4.5 Labo : Particularités des filtres

R, comme tous les autres langages de programmation, a certaines particularités qu’il est important de connaître. Nous en discuterons ici de quelques unes qui vous permettront d’éviter bien des ennuis au moment de filtrer les données.

Astuce

La première chose à savoir, est que le symbole = ne veut pas dire “égal”

(Encore là, c’est bête, mais c’est comme ça!). Il est utilisé dans R comme synonyme de <-, l’opérateur d’assignation. Pour tester l’égalité entre deux valeurs, il faut plutôt utiliser l’opérateur ==, comme ceci :

filter(penguins, species == "Adelie")

# A tibble: 152 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           NA            NA  
 5 Adelie  Torgersen           36.7          19.3
 6 Adelie  Torgersen           39.3          20.6
 7 Adelie  Torgersen           38.9          17.8
 8 Adelie  Torgersen           39.2          19.6
 9 Adelie  Torgersen           34.1          18.1
10 Adelie  Torgersen           42            20.2
# ℹ 142 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Vous obtenez ainsi la liste de tous les manchots Adélie de votre tableau de données.

Astuce

Deuxième particularité à connaître : l’opérateur == ne fonctionne PAS pour trouver les valeurs manquantes.

Dans R, les valeurs manquantes sont désignées par le code NA (sans guillemets). Il pourrait être tentant de faire :

filter(penguins, sex == NA)

pour trouver les manchots dont on ne connaît pas le sexe, mais cette opération n’aura pas le résultat attendu.

La logique de R est que, si je ne connais pas l’âge de Jacques, et que je ne connais pas l’âge de Jean, si on demande est-ce que Jean et Jacques ont le même âge, la réponse n’est pas oui, mais plutôt “je ne sais pas”. Il existe donc dans R une fonction spéciale qui permet de vérifier si une valeur est manquante, qui se nomme is.na :

filter(penguins, is.na(sex))

# A tibble: 11 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           NA            NA  
 2 Adelie  Torgersen           34.1          18.1
 3 Adelie  Torgersen           42            20.2
 4 Adelie  Torgersen           37.8          17.1
 5 Adelie  Torgersen           37.8          17.3
 6 Adelie  Dream               37.5          18.9
 7 Gentoo  Biscoe              44.5          14.3
 8 Gentoo  Biscoe              46.2          14.4
 9 Gentoo  Biscoe              47.3          13.8
10 Gentoo  Biscoe              44.5          15.7
11 Gentoo  Biscoe              NA            NA  
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Astuce

Une autre particularité intéressante est que l’on peut inverser une condition, à l’aide du point d’exclamation.

On peut, par exemple, chercher la liste de tous les manchots pour lesquels on connaît le sexe avec la commande :

filter(penguins, !is.na(sex))

# A tibble: 333 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           36.7          19.3
 5 Adelie  Torgersen           39.3          20.6
 6 Adelie  Torgersen           38.9          17.8
 7 Adelie  Torgersen           39.2          19.6
 8 Adelie  Torgersen           41.1          17.6
 9 Adelie  Torgersen           38.6          21.2
10 Adelie  Torgersen           34.6          21.1
# ℹ 323 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Une fois ces subtilités comprises, vous serez probablement contente d’apprendre qu’il existe une façon plus lisible d’éliminer les lignes contenant des données manquantes. Vous aurez par contre besoin d’installer et activer une librairie de code supplémentaire nommée tidyr (prononcer tayediyeur, comme dans “mieux organisé”), qui a été conçue spécifiquement pour nettoyer les données.

install.packages("tidyr")

library(tidyr)

Une fois la librairie activée, vous pouvez l’utiliser pour créer un tableau sans les lignes où des valeurs étaient manquantes dans la colonne, comme ceci :

drop_na(penguins, sex)

# A tibble: 333 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           36.7          19.3
 5 Adelie  Torgersen           39.3          20.6
 6 Adelie  Torgersen           38.9          17.8
 7 Adelie  Torgersen           39.2          19.6
 8 Adelie  Torgersen           41.1          17.6
 9 Adelie  Torgersen           38.6          21.2
10 Adelie  Torgersen           34.6          21.1
# ℹ 323 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Vous pouvez aussi, avec la même fonction, éliminer toutes les lignes qui contiennent des données manquantes dans l’une ou l’autre des colonnes, pour conserver uniquement les lignes dont l’information est complète. Dans ce cas, vous n’avez qu’à ne pas nommer de colonne comme deuxième argument :

drop_na(penguins)

# A tibble: 333 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           36.7          19.3
 5 Adelie  Torgersen           39.3          20.6
 6 Adelie  Torgersen           38.9          17.8
 7 Adelie  Torgersen           39.2          19.6
 8 Adelie  Torgersen           41.1          17.6
 9 Adelie  Torgersen           38.6          21.2
10 Adelie  Torgersen           34.6          21.1
# ℹ 323 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Assurez-vous avant d’effectuer ce genre d’opération que seules les colonnes qui vous intéressent sont présentes dans le tableau de données. Pensez par exemple que si vous avez une colonne de notes qui ne contient rien sur la majorité des lignes, appeler drop_na de cette façon éliminera toutes les lignes qui n’ont pas de notes…

Astuce

La dernière particularité concernant les filtres est que l’on peut combiner plusieurs conditions avec des OU ou des ET.

Pour se faire, on énumère chacune des conditions, en les séparant par le bon opérateur, respectivement | pour les OU et & pour les ET. Par exemple, pour avoir tous les manchots Adélie et Gentoo, on ferait comme ceci :

filter(penguins, species == "Adelie" | species == "Gentoo")

# A tibble: 276 × 8
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           NA            NA  
 5 Adelie  Torgersen           36.7          19.3
 6 Adelie  Torgersen           39.3          20.6
 7 Adelie  Torgersen           38.9          17.8
 8 Adelie  Torgersen           39.2          19.6
 9 Adelie  Torgersen           34.1          18.1
10 Adelie  Torgersen           42            20.2
# ℹ 266 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Remarquez que, verbalement, on aurait tendance à dire “je veux les Adélie et les Gentoo”, mais qu’en termes d’algèbre booléen, on doit dire : “je veux les lignes où species a la valeur Adelie ou la valeur Gentoo”.

Enfin, rappelez-vous que cette fonction, comme toutes les autres, ne modifie pas le tableau de données original. Vous devez assigner le contenu à un nouvel objet si vous voulez conserver le résultat de l’opération.

4.6 Labo : Trier les observations

Dans R, lorsque nous demandons de voir le contenu d’un tableau de données, les observations seront toujours présentées dans le même ordre, celui dans lequel les observations ont été saisies dans le tableau. Pour modifier cet ordre, il faut utiliser la fonction arrange, comme ceci :

arrange(penguins, body_mass_g)

# A tibble: 344 × 8
   species   island    bill_length_mm bill_depth_mm
   <fct>     <fct>              <dbl>         <dbl>
 1 Chinstrap Dream               46.9          16.6
 2 Adelie    Biscoe              36.5          16.6
 3 Adelie    Biscoe              36.4          17.1
 4 Adelie    Biscoe              34.5          18.1
 5 Adelie    Dream               33.1          16.1
 6 Adelie    Torgersen           38.6          17  
 7 Chinstrap Dream               43.2          16.6
 8 Adelie    Biscoe              37.9          18.6
 9 Adelie    Dream               37.5          18.9
10 Adelie    Dream               37            16.9
# ℹ 334 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

Cette fonction reçoit deux arguments, soit le tableau de données sur lequel s’appliquer, et le nom de la colonne sur laquelle trier. Si on ne dit rien, R nous trie notre tableau en ordre croissant. Rappelez-vous cependant que l’ordre dans votre tableau original ne sera pas affecté par cette opération. Vous devrez assigner le résultat à un nouvel objet pour conserver cet ordre et l’utiliser ailleurs :

manchots_tries <- arrange(penguins, body_mass_g)

Si au contraire vous voulez obtenir vos données en ordre décroissant, il faut apporter une petite modification au code, comme ceci :

arrange(penguins, desc(body_mass_g))

# A tibble: 344 × 8
   species island bill_length_mm bill_depth_mm
   <fct>   <fct>           <dbl>         <dbl>
 1 Gentoo  Biscoe           49.2          15.2
 2 Gentoo  Biscoe           59.6          17  
 3 Gentoo  Biscoe           51.1          16.3
 4 Gentoo  Biscoe           48.8          16.2
 5 Gentoo  Biscoe           45.2          16.4
 6 Gentoo  Biscoe           49.8          15.9
 7 Gentoo  Biscoe           48.4          14.6
 8 Gentoo  Biscoe           49.3          15.7
 9 Gentoo  Biscoe           55.1          16  
10 Gentoo  Biscoe           49.5          16.2
# ℹ 334 more rows
# ℹ 4 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>

4.7 Labo : Sélectionner certaines colonnes

Parfois il arrivera que votre tableau de données contiendra beaucoup d’informations, qui ne sont pas nécessairement intéressantes pour la question que vous voulez traiter. Il convient alors de simplifier le tableau de données en sélectionnant uniquement certaines variables, comme ceci :

select(penguins, body_mass_g, flipper_length_mm, sex)

# A tibble: 344 × 3
   body_mass_g flipper_length_mm sex   
         <int>             <int> <fct> 
 1        3750               181 male  
 2        3800               186 female
 3        3250               195 female
 4          NA                NA <NA>  
 5        3450               193 female
 6        3650               190 male  
 7        3625               181 female
 8        4675               195 male  
 9        3475               193 <NA>  
10        4250               190 <NA>  
# ℹ 334 more rows

La commande select reçoit une série d’arguments. Le premier est toujours le tableau de données, puis ensuite, les autres sont le nom de toutes les colonnes que l’on désire sélectionner. Dans l’exemple précédent, nous avons créé un tableau de données contenant trois colonnes : body_mass_g, flipper_length_mm et sex.

On peut aussi sélectionner tout, sauf certaines variables, en utilisant un - devant chaque nom, comme ceci :

select(penguins, -body_mass_g, -bill_length_mm, -sex)

# A tibble: 344 × 5
   species island bill_depth_mm flipper_length_mm  year
   <fct>   <fct>          <dbl>             <int> <int>
 1 Adelie  Torge…          18.7               181  2007
 2 Adelie  Torge…          17.4               186  2007
 3 Adelie  Torge…          18                 195  2007
 4 Adelie  Torge…          NA                  NA  2007
 5 Adelie  Torge…          19.3               193  2007
 6 Adelie  Torge…          20.6               190  2007
 7 Adelie  Torge…          17.8               181  2007
 8 Adelie  Torge…          19.6               195  2007
 9 Adelie  Torge…          18.1               193  2007
10 Adelie  Torge…          20.2               190  2007
# ℹ 334 more rows

4.8 Labo : Ajouter des variables

Il est possible d’ajouter des variables à votre tableau de données, sur le même principe que les formules dans Excel.

La fonction qui permet d’ajouter une variable à un tableau de données se nomme mutate. Il s’agit, tristement, du nom de fonction le moins intuitif de la librairie dplyr. Essayez d’imaginer que votre tableau subit une mutation, qu’il lui pousse un nouveau morceau… une nouvelle variable.

Pour ajouter une colonne de poids des manchots en kg plutôt qu’en g, nous pouvons utiliser le code suivant :

mutate(penguins, body_mass_kg = body_mass_g / 1000)

# A tibble: 344 × 9
   species island    bill_length_mm bill_depth_mm
   <fct>   <fct>              <dbl>         <dbl>
 1 Adelie  Torgersen           39.1          18.7
 2 Adelie  Torgersen           39.5          17.4
 3 Adelie  Torgersen           40.3          18  
 4 Adelie  Torgersen           NA            NA  
 5 Adelie  Torgersen           36.7          19.3
 6 Adelie  Torgersen           39.3          20.6
 7 Adelie  Torgersen           38.9          17.8
 8 Adelie  Torgersen           39.2          19.6
 9 Adelie  Torgersen           34.1          18.1
10 Adelie  Torgersen           42            20.2
# ℹ 334 more rows
# ℹ 5 more variables: flipper_length_mm <int>,
#   body_mass_g <int>, sex <fct>, year <int>,
#   body_mass_kg <dbl>

La fonction mutate doit recevoir comme premier argument le nom du tableau de données sur lequel travailler, puis le nom de la nouvelle colonne, suivi d’un = et du détail du calcul pour construire la variable.

Malheureusement, les nouvelles colonnes sont ajoutés à la fin (à droite) du tableau et donc, pas visibles ici.

On peut cependant apercevoir notre nouvelle colonne avec la fonction View, ou sinon, on peut utiliser un argument supplémentaire de la fonction mutate, pour lui dire d’insérer notre nouvelle colonne à gauche plutôt qu’à droite :

mutate(
  penguins, 
  body_mass_kg = body_mass_g / 1000,
  .before = 1
)

# A tibble: 344 × 9
   body_mass_kg species island    bill_length_mm
          <dbl> <fct>   <fct>              <dbl>
 1         3.75 Adelie  Torgersen           39.1
 2         3.8  Adelie  Torgersen           39.5
 3         3.25 Adelie  Torgersen           40.3
 4        NA    Adelie  Torgersen           NA  
 5         3.45 Adelie  Torgersen           36.7
 6         3.65 Adelie  Torgersen           39.3
 7         3.62 Adelie  Torgersen           38.9
 8         4.68 Adelie  Torgersen           39.2
 9         3.48 Adelie  Torgersen           34.1
10         4.25 Adelie  Torgersen           42  
# ℹ 334 more rows
# ℹ 5 more variables: bill_depth_mm <dbl>,
#   flipper_length_mm <int>, body_mass_g <int>,
#   sex <fct>, year <int>

Notez qu’il est possible d’utiliser plus d’une variable à l’intérieur du calcul. On pourrait p. ex. ajouter une colonne contenant le rapport entre la longueur et l’épaisseur du bec, comme ceci :

de poids relatif du cerveau, comme ceci :

mutate(
  penguins, 
  body_mass_kg = body_mass_g / 1000,
  ratio_bec = bill_length_mm / bill_depth_mm,
  .before = 1
)

# A tibble: 344 × 10
   body_mass_kg ratio_bec species island bill_length_mm
          <dbl>     <dbl> <fct>   <fct>           <dbl>
 1         3.75      2.09 Adelie  Torge…           39.1
 2         3.8       2.27 Adelie  Torge…           39.5
 3         3.25      2.24 Adelie  Torge…           40.3
 4        NA        NA    Adelie  Torge…           NA  
 5         3.45      1.90 Adelie  Torge…           36.7
 6         3.65      1.91 Adelie  Torge…           39.3
 7         3.62      2.19 Adelie  Torge…           38.9
 8         4.68      2    Adelie  Torge…           39.2
 9         3.48      1.88 Adelie  Torge…           34.1
10         4.25      2.08 Adelie  Torge…           42  
# ℹ 334 more rows
# ℹ 5 more variables: bill_depth_mm <dbl>,
#   flipper_length_mm <int>, body_mass_g <int>,
#   sex <fct>, year <int>

Plus ce ratio est élevé, plus les manchots ont des becs proportionnellement étroits.

Rappelez-vous, comme pour les opérations précédentes, que le tableau original n’est pas modifié par la commande. Il faut utiliser l’opérateur d’assignation (<-) pour conserver le résultat dans un nouvel objet.

4.9 Labo : Résumer les données

Résumer les données est une opération que l’on fait tout naturellement, souvent sans s’en rendre compte : compter le nombre d’observations, calculer la moyenne d’une variable, etc. Dans la librairie dplyr, la fonction qui permet d’effectuer ces opérations se nomme summarize. Si l’on voulait connaître le poids moyen des manchots dans notre tableau de données, nous pourrions lancer ceci :

summarize (penguins, poids_moyen = mean(body_mass_g))

# A tibble: 1 × 1
  poids_moyen
        <dbl>
1          NA

Ici, R nous répond NA puisque la colonne body_mass_g contient des données manquantes. Une façon rapide de contourner le problème est de mentionner à la fonction mean d’ignorer les données manquantes dans son calcul.

summarize (penguins, poids_moyen = mean(body_mass_g, na.rm = TRUE))

# A tibble: 1 × 1
  poids_moyen
        <dbl>
1       4202.

Remarquez que dans un vrai projet, les données manquantes doivent être gérées en amont des analyses. na.rm est plus un diachylon (plaster) qu’une vraie solution.

La fonction summarize attend deux arguments, soit le tableau de données sur lequel appliquer la fonction, puis l’opération à effectuer. Ici, on calcule la moyenne (mean) de la variable body_mass_g, et on stocke le résultat dans une colonne nommée poids_moyen.

Il existe plusieurs fonctions pour résumer les données dans R, donc voici un aperçu non-exhaustif :

mean : calculer la moyenne
max : trouver la valeur la plus élevée
min : trouver la valeur la plus faible
sd : l’écart-type (nous verrons à la Section 5.2 l’utilité de l’écart-type et le détail de son calcul)
n : trouver le nombre de valeurs

Nous en verrons aussi quelques autres dans le Chapitre 5.

Enfin, pour calculer à la fois plusieurs choses, sur plusieurs variables différentes, on peut ajouter des arguments à summarize :

summarize (
  penguins, 
  poids_moyen = mean(body_mass_g, na.rm = TRUE),
  plus_grande_aile = max(flipper_length_mm, na.rm = TRUE),
  nb_observations = n()
)

# A tibble: 1 × 3
  poids_moyen plus_grande_aile nb_observations
        <dbl>            <int>           <int>
1       4202.              231             344

Il faut à ce moment séparer chacun des calculs par une virgule.

Notez que la sortie de la fonction summarize est aussi un tableau de données, qui peut être assigné à un objet et manipulé comme tout le reste.

4.10 Exercices

Tout d’abord, partir du tableau de données penguins, trouvez en ordre croissant de poids (body_mass_g), la liste de tous les manchots Gentoo mâles.

Préparez ensuite un petit tableau de données nommé petits_pas_adelie contenant tous les manchots Gentoo et Chinstrap, dont le poids est inférieur à 3000g. Combien de manchots correspondent à cette description?

Produisez ensuite un graphique, au meilleur de votre connaissance, permettant de valider si la réponse précédente a du sens.

Enfin, calculez le poids moyen des manchots Gentoo. Effectuez la même opération pour les manchots Adélie. En moyenne, quelle espèce est la plus lourde?

Notez que vous pouvez, pour cet exercice, créer des petits tableaux de données intermédiaires, par exemple contenant uniquement les Gentoo, pour répondre à la question en plusieurs étapes. Nous verrons à la Section 6.3 comment nous aurions pu répondre à cette question en une seule commande ultra-compacte.

4.11 En résumé

Nous avons donc défini dans ce chapitre cinq opérations de base qui nous permettront de manipuler des tableaux de données, soit :

filter : conserver les observations qui correspondent à certaines conditions
arrange : modifier l’ordre des observations dans un tableau de données (i.e. trier)
select : simplifier un tableau de données en conservant uniquement certaines variables
mutate : ajouter une variable au tableau de données, basée sur un calcul
summarize : résumer les données d’un tableau

Toutes ces fonctions reçoivent comme premier argument le tableau de données sur lequel elles doivent s’appliquer. Et dans tous les cas, le tableau de données original n’est pas modifié, il faut utiliser l’opérateur d’assignation (<-) pour conserver le résultat.