Restart 4: Tableaux de données

Lise Vaudor

01/02/2021

Lecture de tables: trouver son fichier!

Pour lire un tableau de données il faudra indiquer le chemin du fichier…

Si vous travaillez sous forme de projets .Rproj alors le plus simple est d’indiquer le chemin relatif par rapport au dossier racine (celui qui contient le .Rproj).

Notez l’usage des slashs (/) et non d’antislashs, quel que soit votre système d’exploitation.

Par exemple,

path="data/data_brute/supertableau.csv"

Si pour une raison ou une autre vous avez besoin de remonter dans l’arborescence des fichiers (c’est généralement non recommandé mais ça peut arriver), vous pouvez le faire avec “../”.

Par exemple “../../donnees_hydro” vous fait remonter de deux niveaux dans l’arborescence avant de vous faire redescendre dans un dossier “donnees_hydro”.

Vous pouvez également utiliser la fonction file.path() pour écrire votre chemin:

path=file.path("data","data_brute","supertableau.csv")
path
[1] "data/data_brute/supertableau.csv"

Lecture de tables: Fonctions read_csv() ou read_delim()

Examinons la commande suivante:

catdata <- readr::read_delim(file.path(file.path("..","datasets","catdata.csv")),
                             delim=";")

── Column specification ────────────────────────────────────
cols(
  haircolor = col_character(),
  hairpattern = col_character(),
  sex = col_character(),
  weight = col_double(),
  age = col_double(),
  foodtype = col_character()
)
head(catdata,3)  # 3 premieres lignes du tableau
# A tibble: 3 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    12 other   
2 black     tabby       female    5.5     6 dry     
3 white     tabby       female    5.6     8 wet

Notez que le format csv correspond à des valeurs séparées par une virgule (“csv”= Coma Separated Values).

Pour lire une table qui comprendrait un type de séparateur différent (par exemple, un espace, ou un point-virgule), on peut utiliser la fonction read_delim().

Jeu de données illustratif

Dans la suite de ce document nous allons utiliser un jeu de données catdata comprenant un certain nombre de variables relatives à des chats 🐱.

Il s’agit de données fictives, créées de toute pièce dans un but pédagogique… 

catdata <- readr::read_delim(file.path("..","datasets","catdata.csv"), delim=";")

── Column specification ────────────────────────────────────
cols(
  haircolor = col_character(),
  hairpattern = col_character(),
  sex = col_character(),
  weight = col_double(),
  age = col_double(),
  foodtype = col_character()
)
catdata
# A tibble: 153 x 6
   haircolor hairpattern sex    weight   age foodtype
   <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
 1 red       solid       female    4.6    12 other   
 2 black     tabby       female    5.5     6 dry     
 3 white     tabby       female    5.6     8 wet     
 4 red       tabby       female    6.1     5 dry     
 5 brown     solid       female    5.3     7 dry     
 6 black     tabby       male      6.9     5 wet     
 7 brown     solid       male      6.3     5 dry     
 8 black     colorpoint  female    5.5     4 wet     
 9 white     tortoise    male      4.3     5 wet     
10 red       solid       female    2.3     3 dry     
# … with 143 more rows

Les variables de ce jeu de données sont les suivantes:

  • haircolor: la couleur du poil (catégoriel)
  • hairpattern: le “pattern” coloré du poil (catégoriel)
  • sex: le sexe du chat (catégoriel)
  • weight: son poids (quantitatif)
  • age: son âge (quantitatif)
  • foodtype: le type d’alimentation (catégoriel)

Nettoyer ses données

Attention, utilisateurs de tableurs, cette diapo est pour vous…

Si vous avez des difficultés à lire votre tableau des données, c’est sans doute parce que celui-ci n’est pas un tableau de données brutes.

Pour lire un tableau de données sous R, il convient d’abord de nettoyer ce tableau:

  • Vérifier que les noms de colonnes ne contiennent pas de caractères spéciaux ou des espaces, avoir des noms de variables courts mais explicites
  • Vérifier si certains champs correspondent en fait à des commentaires, si votre tableur contient des graphiques, etc..

Ceci n’est pas de la donnée brute!

Tidy data

illustration: Allison Horst

Tidy data

illustration: Allison Horst

Lecture de tables: en passant par RStudio

On peut également utiliser les fonctionnalités de RStudio pour afficher et modifier la table.

Ecriture de tables: Fonction write.table()

A l’inverse, il est possible d’écrire des fichiers depuis R. Pour écrire une table, par exemple:

t1
# A tibble: 4 x 3
  Espece  `Nom <- c("Lassie", "Flipp… `Date <- c(1940, 1964…
  <chr>   <chr>                                        <dbl>
1 Chien   Lassie                                        1940
2 Dauphin Flipper                                       1964
3 Chat    Garfield                                      1978
4 Eponge  Bob                                           1999
readr::write_csv(t1,
          "datasets/table_animaux_stars.csv")

Cette-fois les arguments principaux sont:

  • x: l’objet tibble à écrire
  • file: le nom de fichier de votre choix (ou chemin, si vous ne souhaitez pas écrire le fichier directement dans le répertoire de travail)

Structure et dimensions d’une table

str(catdata) # structure du tableau
tibble [153 × 6] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
 $ haircolor  : chr [1:153] "red" "black" "white" "red" ...
 $ hairpattern: chr [1:153] "solid" "tabby" "tabby" "tabby" ...
 $ sex        : chr [1:153] "female" "female" "female" "female" ...
 $ weight     : num [1:153] 4.6 5.5 5.6 6.1 5.3 6.9 6.3 5.5 4.3 2.3 ...
 $ age        : num [1:153] 12 6 8 5 7 5 5 4 5 3 ...
 $ foodtype   : chr [1:153] "other" "dry" "wet" "dry" ...
 - attr(*, "spec")=
  .. cols(
  ..   haircolor = col_character(),
  ..   hairpattern = col_character(),
  ..   sex = col_character(),
  ..   weight = col_double(),
  ..   age = col_double(),
  ..   foodtype = col_character()
  .. )
colnames(catdata) # nom des colonnes
[1] "haircolor"   "hairpattern" "sex"         "weight"     
[5] "age"         "foodtype"   
dim(catdata) # dimensions
[1] 153   6
nrow(catdata) # nombre de lignes
[1] 153
ncol(catdata) #nombre de colonnes
[1] 6

Pour afficher les premières lignes du tableau:

head(catdata)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    12 other   
2 black     tabby       female    5.5     6 dry     
3 white     tabby       female    5.6     8 wet     
4 red       tabby       female    6.1     5 dry     
5 brown     solid       female    5.3     7 dry     
6 black     tabby       male      6.9     5 wet

Pour afficher les dernières lignes du tableau:

tail(catdata)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 black     tabby       female    4.1     3 wet     
2 brown     tabby       female    6.3     3 dry     
3 black     tabby       female    5.2     5 wet     
4 brown     tabby       female    4.3     3 other   
5 red       tabby       male      3.8     4 wet     
6 black     tortoise    male      4.2     6 dry

RStudio view data

dplyr: Introduction()

dplyr est un package qui permet de faire simplement diverses opérations sur les tableaux de données:

  • select() permet de sélectionner des variables (colonnes)
  • filter() permet de filtrer les individus (lignes)
  • arrange() permet de réarranger le tableau selon l’ordre des variables
  • mutate() permet de créer et ajouter de nouvelles variables (colonnes)
  • summarise() permet de résumer plusieurs valeurs en une seule

dplyr: select()

select() permet de sélectionner des variables

Par exemple, on peut sélectionner des variables de la table air

head(catdata)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    12 other   
2 black     tabby       female    5.5     6 dry     
3 white     tabby       female    5.6     8 wet     
4 red       tabby       female    6.1     5 dry     
5 brown     solid       female    5.3     7 dry     
6 black     tabby       male      6.9     5 wet
  • en spécifiant les noms ou numéros des variables à conserver
data <- select(catdata,weight, age)
head(data,2)
# A tibble: 2 x 2
  weight   age
   <dbl> <dbl>
1    4.6    12
2    5.5     6
data <- select(catdata,4,5)
head(data,2)
# A tibble: 2 x 2
  weight   age
   <dbl> <dbl>
1    4.6    12
2    5.5     6
  • en spécifiant le nom ou les numéros des variables à écarter avec le signe -
data <- select(catdata,-hairpattern,-haircolor)
head(data,2)
# A tibble: 2 x 4
  sex    weight   age foodtype
  <chr>   <dbl> <dbl> <chr>   
1 female    4.6    12 other   
2 female    5.5     6 dry

dplyr: select()

select() permet de sélectionner des variables en passant par des fonctions auxiliaires. On peut citer par exemple:

  • starts_with pour les variables qui commencent par un texte donné
  • ends_with pour les variables qui terminent par un texte donné
  • contains pour les variables qui contiennent un texte donné
  • etc.

Par exemple:

head(catdata)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    12 other   
2 black     tabby       female    5.5     6 dry     
3 white     tabby       female    5.6     8 wet     
4 red       tabby       female    6.1     5 dry     
5 brown     solid       female    5.3     7 dry     
6 black     tabby       male      6.9     5 wet     
data <- select(catdata,starts_with("hair"))
head(data)
# A tibble: 6 x 2
  haircolor hairpattern
  <chr>     <chr>      
1 red       solid      
2 black     tabby      
3 white     tabby      
4 red       tabby      
5 brown     solid      
6 black     tabby

dplyr: filter()

filter() permet de filtrer les lignes du tableau en fonction des valeurs de telle ou telle variable.

Ici, par exemple, on cherche toutes les lignes qui correspondent au mois de juillet:

data <- filter(catdata,haircolor=="red")
nrow(data)
[1] 29
head(data)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    12 other   
2 red       tabby       female    6.1     5 dry     
3 red       solid       female    2.3     3 dry     
4 red       colorpoint  female    3.9     8 dry     
5 red       tabby       female    4.6     7 dry     
6 red       tortoise    female    5.9     8 wet

On peut combiner plusieurs conditions logiques (ET logique, par une virgule ou un &, OU logique, par l’opérateur |).

Par exemple,

  • pour ne conserver que les lignes qui telles que age>10 et weight>5:
data <- filter(catdata, age>10, weight>5)
data
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 black     colorpoint  female    5.4    12 other   
2 black     solid       male      5.9    11 dry     
3 red       colorpoint  male      5.9    17 wet     
4 black     tabby       male      5.7    11 dry     
5 black     tabby       male      5.9    11 dry     
6 black     solid       female    6.2    17 dry
  • pour ne conserver que les lignes telles que haircolor soit “red” ou “black”:
data <- filter(catdata, haircolor=="red"|haircolor=="black")
nrow(data)
[1] 108

Vous pouvez également utiliser l’opérateur %in%:

data <- filter(catdata, haircolor %in% c("red","black"))
nrow(data)
[1] 108

dplyr: arrange()

Pour réarranger un tableau selon l’ordre d’une variable, on peut faire appel à la fonction arrange (ici, par exemple on réordonne catdata selon l’ordre croissant de age et weight):

data <- arrange(catdata,age, weight)
head(data)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 white     tabby       male      5.1     2 dry     
2 red       solid       female    2.3     3 dry     
3 white     solid       male      2.5     3 wet     
4 black     tabby       male      3.5     3 dry     
5 black     colorpoint  male      3.7     3 wet     
6 black     tipped      male      4       3 wet

et pour ordonner par ordre décroissant, on utilise desc():

data <- arrange(catdata,desc(age))
head(data)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       colorpoint  male      5.9    17 wet     
2 black     tabby       female    1.9    17 dry     
3 black     solid       female    6.2    17 dry     
4 red       tortoise    female    3.4    13 wet     
5 red       solid       female    4.6    12 other   
6 black     colorpoint  female    5.4    12 other

dplyr: mutate()

Pour créer de nouvelles variables et les ajouter au tableau de données on peut utiliser la fonction mutate().

Voici par exemple comment procéder si je souhaite créer une nouvelle variable, age_humain, à partir de age:

data=mutate(catdata,
            age_humain=age*7)
head(data)
# A tibble: 6 x 7
  haircolor hairpattern sex   weight   age foodtype
  <chr>     <chr>       <chr>  <dbl> <dbl> <chr>   
1 red       solid       fema…    4.6    12 other   
2 black     tabby       fema…    5.5     6 dry     
3 white     tabby       fema…    5.6     8 wet     
4 red       tabby       fema…    6.1     5 dry     
5 brown     solid       fema…    5.3     7 dry     
6 black     tabby       male     6.9     5 wet     
# … with 1 more variable: age_humain <dbl>

Je peux créer une nouvelle variable hair en collant haircolor et hairpattern

data <- mutate(catdata,
               hair=paste(haircolor,"-",hairpattern,sep=""))
head(data)
# A tibble: 6 x 7
  haircolor hairpattern sex    weight   age foodtype hair   
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>    <chr>  
1 red       solid       female    4.6    12 other    red-so…
2 black     tabby       female    5.5     6 dry      black-…
3 white     tabby       female    5.6     8 wet      white-…
4 red       tabby       female    6.1     5 dry      red-ta…
5 brown     solid       female    5.3     7 dry      brown-…
6 black     tabby       male      6.9     5 wet      black-…

Si je réutilise un nom de colonne déjà présent dans la table, la colonne est “écrasée”:

data <- mutate(catdata,
               age=age*7)
head(data)
# A tibble: 6 x 6
  haircolor hairpattern sex    weight   age foodtype
  <chr>     <chr>       <chr>   <dbl> <dbl> <chr>   
1 red       solid       female    4.6    84 other   
2 black     tabby       female    5.5    42 dry     
3 white     tabby       female    5.6    56 wet     
4 red       tabby       female    6.1    35 dry     
5 brown     solid       female    5.3    49 dry     
6 black     tabby       male      6.9    35 wet

dplyr: mutate() et auxiliaires… case_when()

illustration Allison Horst

On peut effectuer une transformation de manière conditionnelle à l’aide de la fonction case_when()

Par exemple:

data <- mutate(catdata,
               classe_age=case_when(age>10~"old",
                                    age>5 & age<=10~"medium",
                                    age<=5~"young"))
data
# A tibble: 153 x 7
   haircolor hairpattern sex   weight   age foodtype
   <chr>     <chr>       <chr>  <dbl> <dbl> <chr>   
 1 red       solid       fema…    4.6    12 other   
 2 black     tabby       fema…    5.5     6 dry     
 3 white     tabby       fema…    5.6     8 wet     
 4 red       tabby       fema…    6.1     5 dry     
 5 brown     solid       fema…    5.3     7 dry     
 6 black     tabby       male     6.9     5 wet     
 7 brown     solid       male     6.3     5 dry     
 8 black     colorpoint  fema…    5.5     4 wet     
 9 white     tortoise    male     4.3     5 wet     
10 red       solid       fema…    2.3     3 dry     
# … with 143 more rows, and 1 more variable:
#   classe_age <chr>

On peut également simplifier l’écriture de la condition complémentaire (ici age<=5) en la remplaçant par TRUE:

data <- mutate(catdata,
               classe_age=case_when(age>10~"old",
                                    age>5 & age<=10~"medium",
                                    TRUE~"young"))

dplyr: summarise()

Si l’on souhaite calculer quelques statistiques un peu basiques sur un jeu de données, on peut utiliser la fonction summarise().

Par exemple:

data <- summarise(catdata,
                  mean_age=mean(age),
                  nb_patterns=n_distinct(hairpattern),
                  nb_Mesures=n())
data
# A tibble: 1 x 3
  mean_age nb_patterns nb_Mesures
     <dbl>       <int>      <int>
1     6.12           5        153

Et surtout, si je souhaite calculer une statistique pour différents groupes (définis ici, par exemple, par la variable Month), je vais le spécifier dans l’argument spécifiant la table de données, à l’aide de group_by():

data <- summarise(group_by(catdata,foodtype),
                  mean_age=mean(age),
                  nb_Mesures=n())
data
# A tibble: 3 x 3
  foodtype mean_age nb_Mesures
  <chr>       <dbl>      <int>
1 dry          6.02        102
2 other        6.56          9
3 wet          6.29         42

dplyr: Chaînage

Vous avez vu que les fonctions de dplyr permettaient de faire toutes sortes d’opérations sur les tableaux de données. Il est bien entendu possible de les combiner pour réaliser des opérations complexes…

Imaginons par exemple que l’on souhaite répondre à une question telle que

“Quelle est le poids moyen des chats de plus de 10 ans en fonction de leur type de nourriture”

Pour répondre à cette question, je pourrais par exemple (il y a en fait plusieurs possibilités):

  • filtrer pour ne garder que les chats de plus de 10 ans
  • grouper par type de nourriture
  • résumer l’information en moyenne de poids

dplyr: Chaînage

Classiquement, pour coder cette chaîne d’opérations sous R, on procéderait de la manière suivante:

data1 <- filter(catdata, age>10)
data2 <- group_by(data1, foodtype)
data3 <- summarise(data2,
                   mean_weight=mean(weight),
                   .groups="drop")

dplyr: Chaînage

Si je souhaitais réaliser cet enchaînement de commandes en une seule opération, et ainsi éviter la création d’objets intermédiaires data1, data2, etc., voici (classiquement) comment il faudrait procéder:

data <-summarise(group_by(filter(catdata,
                          age>10),
                 foodtype),
          mean_weight=mean(weight),
          .groups="drop")
data
# A tibble: 3 x 2
  foodtype mean_weight
  <chr>          <dbl>
1 dry             4.73
2 other           5   
3 wet             4.65

dplyr: Chaînage

dplyr permet d’inverser l’ordre de cette syntaxe en permettant d’utiliser un opérateur (l’opérateur “pipe”) qui s’écrit de la manière suivante : %>% et que l’on pourrait (en gros) traduire par “et puis”…

Voyez plutôt comment le code ci-dessus peut être simplifié par l’usage de cet opérateur:

data <- catdata %>%
  filter(age>10) %>% 
  group_by(foodtype) %>% 
  summarise(mean_age=mean(age))

dplyr: summarise() et auxiliaires… across()

illustration Allison Horst 
summary_by_hair=catdata %>% 
  group_by(haircolor,hairpattern) %>% 
  summarise(across(where(is.numeric),mean),
            .groups="drop")
summary_by_hair
# A tibble: 19 x 4
   haircolor hairpattern weight   age
   <chr>     <chr>        <dbl> <dbl>
 1 black     colorpoint    4.94  5.5 
 2 black     solid         5.13  7.06
 3 black     tabby         4.91  6.43
 4 black     tipped        5.29  4.6 
 5 black     tortoise      4.63  6.36
 6 brown     colorpoint    5     5   
 7 brown     solid         5.76  5.8 
 8 brown     tabby         4.79  6   
 9 brown     tipped        4.73  5.33
10 red       colorpoint    5.1  10   
11 red       solid         4.28  6.67
12 red       tabby         5.02  5.54
13 red       tipped        4.15  3.5 
14 red       tortoise      4.48  8.8 
15 white     colorpoint    4.2   5   
16 white     solid         4.24  5.6 
17 white     tabby         4.52  6   
18 white     tipped        5.55  6   
19 white     tortoise      5.33  4.33

Allonger/ élargir ses tableaux

Le principe des “tidy data” est le suivant:

  • une ligne = une observation
  • une colonne = une variable
Mais dans certains cas, la définition même des observations et des variables peut être fluctuante en fonction de l’analyse qu’on souhaite réaliser.

Considérons par exemple la table suivante, où chaque ligne correspond à l’observation d’un poisson au niveau d’une station de mesure: 

# A tibble: 6 x 3
  fish  station  seen
  <fct> <fct>   <int>
1 4842  Release     1
2 4842  I80_1       1
3 4842  Lisbon      1
4 4842  Rstr        1
5 4842  Base_TD     1
6 4842  BCE         1

On pourrait aussi considérer qu’une observation correspond à un poisson donné, et les différentes variables aux différentes stations de mesure: 

# A tibble: 6 x 12
  fish  Release I80_1 Lisbon  Rstr Base_TD   BCE   BCW  BCE2
  <fct>   <int> <int>  <int> <int>   <int> <int> <int> <int>
1 4842        1     1      1     1       1     1     1     1
2 4843        1     1      1     1       1     1     1     1
3 4844        1     1      1     1       1     1     1     1
4 4845        1     1      1     1       1     0     0     0
5 4847        1     1      1     0       0     0     0     0
6 4848        1     1      1     1       0     0     0     0
# … with 3 more variables: BCW2 <int>, MAE <int>, MAW <int>
Ici, on a “élargi” le tableau à l’aide de la fonction pivot_wider() du package tidyr

Elargir ses tableaux avec pivot_wider:

library(tidyr)
fish_encounters
# A tibble: 114 x 3
   fish  station  seen
   <fct> <fct>   <int>
 1 4842  Release     1
 2 4842  I80_1       1
 3 4842  Lisbon      1
 4 4842  Rstr        1
 5 4842  Base_TD     1
 6 4842  BCE         1
 7 4842  BCW         1
 8 4842  BCE2        1
 9 4842  BCW2        1
10 4842  MAE         1
# … with 104 more rows
 
fish_wide=fish_encounters %>% 
    pivot_wider(names_from = station,
                values_from = seen,
                values_fill = 0,
                names_prefix="st_")
fish_wide
# A tibble: 19 x 12
   fish  st_Release st_I80_1 st_Lisbon st_Rstr st_Base_TD
   <fct>      <int>    <int>     <int>   <int>      <int>
 1 4842           1        1         1       1          1
 2 4843           1        1         1       1          1
 3 4844           1        1         1       1          1
 4 4845           1        1         1       1          1
 5 4847           1        1         1       0          0
 6 4848           1        1         1       1          0
 7 4849           1        1         0       0          0
 8 4850           1        1         0       1          1
 9 4851           1        1         0       0          0
10 4854           1        1         0       0          0
11 4855           1        1         1       1          1
12 4857           1        1         1       1          1
13 4858           1        1         1       1          1
14 4859           1        1         1       1          1
15 4861           1        1         1       1          1
16 4862           1        1         1       1          1
17 4863           1        1         0       0          0
18 4864           1        1         0       0          0
19 4865           1        1         1       0          0
# … with 6 more variables: st_BCE <int>, st_BCW <int>,
#   st_BCE2 <int>, st_BCW2 <int>, st_MAE <int>,
#   st_MAW <int>

Allonger ses tableaux avec pivot_longer:

library(tidyr)
fish_wide
# A tibble: 19 x 12
   fish  st_Release st_I80_1 st_Lisbon st_Rstr st_Base_TD
   <fct>      <int>    <int>     <int>   <int>      <int>
 1 4842           1        1         1       1          1
 2 4843           1        1         1       1          1
 3 4844           1        1         1       1          1
 4 4845           1        1         1       1          1
 5 4847           1        1         1       0          0
 6 4848           1        1         1       1          0
 7 4849           1        1         0       0          0
 8 4850           1        1         0       1          1
 9 4851           1        1         0       0          0
10 4854           1        1         0       0          0
11 4855           1        1         1       1          1
12 4857           1        1         1       1          1
13 4858           1        1         1       1          1
14 4859           1        1         1       1          1
15 4861           1        1         1       1          1
16 4862           1        1         1       1          1
17 4863           1        1         0       0          0
18 4864           1        1         0       0          0
19 4865           1        1         1       0          0
# … with 6 more variables: st_BCE <int>, st_BCW <int>,
#   st_BCE2 <int>, st_BCW2 <int>, st_MAE <int>,
#   st_MAW <int>
 
fish_long=fish_wide %>% 
    pivot_longer(cols=starts_with("st_"),
                 names_to = "station",
                 values_to="seen")
fish_long
# A tibble: 209 x 3
   fish  station     seen
   <fct> <chr>      <int>
 1 4842  st_Release     1
 2 4842  st_I80_1       1
 3 4842  st_Lisbon      1
 4 4842  st_Rstr        1
 5 4842  st_Base_TD     1
 6 4842  st_BCE         1
 7 4842  st_BCW         1
 8 4842  st_BCE2        1
 9 4842  st_BCW2        1
10 4842  st_MAE         1
# … with 199 more rows

On récapitule!

On a parlé de quoi, déjà?
  • chemins, répertoires de travail
  • lecture/écriture de tables (nature du séparateur de colonnes, du séparateur décimal)
  • description sommaire & affichage de tables
  • manipulation de tables avec dplyr
    • sélection de variables (select)
    • filtre des lignes (filter)
    • tri des lignes (arrange)
    • transformation des colonnes (mutate)
    • agrégation de l’information (summarise)
  • chaînage des instructions avec le pipe : %>%