11-stringr.qmd

# Manipuler du texte avec `stringr`

{{< include _setup.qmd >}}

Les fonctions de `forcats` vues précédemment permettent de modifier des modalités d'une variables qualitative globalement. Mais parfois on a besoin de manipuler le contenu même du texte d'une variable de type chaîne de caractères : combiner, rechercher, remplacer...

On va utiliser ici les fonctions de l'extension `stringr`. Celle-ci fait partie du coeur du *tidyverse*, elle est donc automatiquement chargée avec :

```{r}
library(tidyverse)
```

::: {.callout-note}
`stringr` est en fait une interface simplifiée aux fonctions d'une autre extension, `stringi`. Si les fonctions de `stringr` ne sont pas suffisantes ou si vous manipulez beaucoup de chaînes de caractères, n'hésitez pas à vous reporter à la documentation de `stringi`.
:::

Dans ce qui suit on va utiliser le court tableau d'exemple `d` suivant :

```{r}
d <- tibble(
  nom = c("Mr Félicien Machin", "Mme Raymonde Bidule", "M. Martial Truc", "Mme Huguette Chose"),
  adresse = c("3 rue des Fleurs", "47 ave de la Libération", "12 rue du 17 octobre 1961", "221 avenue de la Libération"),
  ville = c("Nouméa", "Marseille", "Vénissieux", "Marseille")
)
```

```{r echo=FALSE}
kable(d)
```

## Expressions régulières

Les fonctions présentées ci-dessous sont pour la plupart prévues pour fonctionner avec des *expressions régulières*. Celles-ci constituent un mini-langage, qui peut paraître assez cryptique, mais qui est très puissant pour spécifier des motifs de chaînes de caractères.

Elles permettent par exemple de sélectionner le dernier mot avant la fin d'une chaîne, l'ensemble des suites alphanumériques commençant par une majuscule, des nombres de 3 ou 4 chiffres situés en début de chaîne, et beaucoup beaucoup d'autres choses encore bien plus complexes.

Pour donner un exemple concret, l'expression régulière suivante permet de détecter une adresse de courrier électronique^[Il s'agit en fait d'une version très simplifiée, la "véritable" expression permettant de tester si une adresse mail est valide fait plus de 80 lignes...] :

`[\w\d+.-_]+@[\w\d.-]+\.[a-zA-Z]{2,}`

Par souci de simplicité, dans ce qui suit les exemples seront donnés autant que possible avec de simples chaînes de caractères, sans expression régulière. Mais si vous pensez manipuler des données textuelles, il peut être très utile de s'intéresser à cette syntaxe.


## Concaténer des chaînes {#sec-concat}

La première opération de base consiste à concaténer des chaînes de caractères entre elles. On peut le faire avec la fonction `paste`.

Par exemple, si on veut concaténer l'adresse et la ville :

```{r}
paste(d$adresse, d$ville)
```

Par défaut, `paste` concatène en ajoutant un espace entre les différentes chaînes. On peut spécifier un autre séparateur avec son argument `sep` :

```{r}
paste(d$adresse, d$ville, sep = " - ")
```

Il existe une variante, `paste0`, qui concatène sans mettre de séparateur, et qui est légèrement plus rapide :

```{r}
paste0(d$adresse, d$ville)
```

::: {.callout-note}
À noter que `paste` et `paste0` sont des fonctions R de base. L'équivalent pour `stringr` se nomme `str_c`.
:::

Parfois on cherche à concaténer les différents éléments d'un vecteur non pas avec ceux d'un autre vecteur, comme on l'a fait précédemment, mais *entre eux*. Dans ce cas `paste` seule ne fera rien :

```{r}
paste(d$ville)
```

Il faut lui ajouter un argument `collapse`, avec comme valeur la chaîne à utiliser pour concaténer les éléments :

```{r}
paste(d$ville, collapse = ", ")
```

## Convertir en majuscules / minuscules

Les fonctions `str_to_lower`, `str_to_upper` et `str_to_title` permettent respectivement de mettre en minuscules, mettre en majuscules, ou de capitaliser les éléments d'un vecteur de chaînes de caractères :

```{r}
str_to_lower(d$nom)
```

```{r}
str_to_upper(d$nom)
```
```{r}
str_to_title(d$nom)
```



## Découper des chaînes

La fonction `str_split` permet de "découper" une chaîne de caractère en fonction d'un délimiteur. On passe la chaîne en premier argument, et le délimiteur en second :

```{r}
str_split("un-deux-trois", "-")
```

On peut appliquer la fonction à un vecteur, dans ce cas le résultat sera une liste :

```{r}
str_split(d$nom, " ")
```

Ou un tableau (plus précisément une matrice) si on ajoute `simplify = TRUE`.

```{r}
str_split(d$nom, " ", simplify = TRUE)
```

Si on souhaite créer de nouvelles colonnes dans un tableau de données en découpant une colonne de type texte, on pourra utiliser la fonction `separate` de l'extension `tidyr`. Celle-ci est expliquée @sec-separate.

Voici juste un exemple de son utilisation :

```{r}
library(tidyr)
d %>% separate(nom, c("genre", "prenom", "nom"), sep = " ")
```


## Extraire des sous-chaînes par position

La fonction `str_sub` permet d'extraire des sous-chaînes par position, en indiquant simplement les positions des premier et dernier caractères :

```{r}
str_sub(d$ville, 1, 3)
```


## Détecter des motifs {#sec-str-detect}

`str_detect` permet de détecter la présence d'un motif parmi les élements d'un vecteur. Par exemple, si on souhaite identifier toutes les adresses contenant "Libération" :

```{r}
str_detect(d$adresse, "Libération")
```

`str_detect` renvoie un vecteur de valeurs logiques et peut donc être utilisée, par exemple, avec le verbe `filter` de `dplyr` pour extraire des sous-populations.

Une variante, `str_count`, compte le nombre d'occurrences d'une chaîne pour chaque élément d'un vecteur :

```{r}
str_count(d$ville, "s")
```

::: {.callout-warning}
Attention, les fonctions de `stringr` étant prévues pour fonctionner avec des expressions régulières, certains caractères n'auront pas le sens habituel dans la chaîne indiquant le motif à rechercher. Par exemple, le `.` ne sera pas un point mais le symbole représentant "n'importe quel caractère".

La section sur les modificateurs de motifs explique comment utiliser des chaîne "classiques" au lieu d'expressions régulières.
:::


On peut aussi utiliser `str_subset` pour ne garder d'un vecteur que les éléments correspondant au motif :

```{r}
str_subset(d$adresse, "Libération")
```


## Extraire des motifs

`str_extract` permet d'extraire les valeurs correspondant à un motif. Si on lui passe comme motif une chaîne de caractère, cela aura peu d'intérêt :

```{r}
str_extract(d$adresse, "Libération")
```

C'est tout de suite plus intéressant si on utilise des expressions régulières. Par exemple la commande suivante permet d'isoler les numéros de rue.

```{r}
str_extract(d$adresse, "^\\d+")
```

`str_extract` ne récupère que la première occurrence du motif. Si on veut toutes les extraire on peut utiliser `str_extract_all`. Ainsi, si on veut extraire l'ensemble des nombres présents dans les adresses :


```{r}
str_extract_all(d$adresse, "\\d+")
```

::: {.callout-note}
Si on veut faire de l'extraction de groupes dans des expressions régulières (identifiés avec des parenthèses), on pourra utiliser `str_match`.
:::

À noter que si on souhaite extraire des valeurs d'une colonne texte d'un tableau de données pour créer de nouvelles variables, on pourra utiliser la fonction `extract` de l'extension `tidyr`, décrite @sec-extract.

Par exemple :

```{r}
library(tidyr)
d %>% extract(adresse, "type_rue", "^\\d+ (.*?) ", remove = FALSE)
```


## Remplacer des motifs

La fonction `str_replace_all` permet de remplacer une chaîne ou un motif par une autre.

Par exemple, on peut remplacer les occurrence de "Mr" par "M." dans notre variable `nom` :

```{r}
str_replace_all(d$nom, "Mr", "M.")
```

On peut également spécifier plusieurs remplacements en une seule fois :

```{r}
str_replace_all(
    d$adresse,
    c("avenue" = "Avenue", "ave" = "Avenue", "rue" = "Rue")
)
```

## Modificateurs de motifs {#sec-modificateurs}

Par défaut, les motifs passés aux fonctions comme `str_detect`, `str_extract` ou `str_replace` sont des expressions régulières classiques.

On peut spécifier qu'un motif n'est pas une expression régulière mais une chaîne de caractères normale en lui appliquant la fonction `fixed`. Par exemple, si on veut compter le nombre de points dans les noms de notre tableau, le paramétrage par défaut ne fonctionnera pas car dans une expression régulière le `.` est un symbole signifiant "n'importe quel caractère" :

```{r}
str_count(d$nom, ".")
```

Il faut donc spécifier que notre point est bien un point avec `fixed` :

```{r}
str_count(d$nom, fixed("."))
```

On peut aussi modifier le comportement des expressions régulières à l'aide de la fonction `regex`. On peut ainsi rendre les motifs insensibles à la casse avec `ignore_case` :

```{r}
str_detect(d$nom, "mme")
```

```{r}
str_detect(d$nom, regex("mme", ignore_case = TRUE))
```

On peut également permettre aux regex d'être multilignes avec l'option `multiline = TRUE`, etc.


## Ressources

L'ouvrage *R for Data Science*, accessible en ligne, contient [un chapitre entier](http://r4ds.had.co.nz/strings.html) sur les chaînes de caractères et les expressions régulières (en anglais).

Le [site officiel de stringr](http://stringr.tidyverse.org/) contient une [liste des fonctions](http://stringr.tidyverse.org/reference/index.html) et les pages d'aide associées, ainsi qu'un [article dédié aux expressions régulières](http://stringr.tidyverse.org/articles/regular-expressions.html).

Pour des besoins plus pointus, on pourra aussi utiliser [l'extension stringi](http://www.gagolewski.com/software/stringi/) sur laquelle est elle-même basée `stringr`.


## Exercices

Dans ces exercices on utilise un tableau `d`, généré par le code suivant :

```{r}
d <- tibble(
  nom = c("M. rené Bézigue", "Mme Paulette fouchin", "Mme yvonne duluc", "M. Jean-Yves Pernoud"),
  naissance = c("18/04/1937 Vesoul", "En 1947 à Grenoble (38)", "Le 5 mars 1931 à Bar-le-Duc", "Marseille, juin 1938"),
  profession = c("Ouvrier agric", "ouvrière qualifiée", "Institutrice", "Exploitant agric")
)
```

```{r echo = FALSE}
kable(d)
```


**Exercice 1**

Capitalisez les noms des personnes avec `str_to_title` :

```{r echo = FALSE, ref.label='str1'}
```

::: {.solution-exo}
```{r str1, eval=FALSE}
str_to_title(d$nom)
```
:::



**Exercice 2**

Dans la variable `profession`, remplacer toutes les occurrences de l'abbréviation "agric" par "agricole" :

```{r echo = FALSE, ref.label='str2'}
```

::: {.solution-exo}
```{r str2, eval=FALSE}
str_replace(d$profession, "agric", "agricole")
```
:::



**Exercice 3**

À l'aide de `str_detect`, identifier les personnes de catégorie professionnelle "Ouvrier". Indication : pensez au modificateur `ignore_case`.

```{r echo = FALSE, ref.label='str3'}
```

::: {.solution-exo}
```{r str3, eval=FALSE}
str_detect(d$profession, regex("Ouvr", ignore_case = TRUE))
```
:::



**Exercice 4**

À l'aide de `case_when` et de `str_detect`, créer une nouvelle variable `sexe` identifiant le sexe de chaque personne en fonction de la présence de `M.` ou de `Mme` dans son nom.

```{r echo = FALSE, ref.label='str4'}
```

::: {.solution-exo}
```{r str4, eval=FALSE}
d %>%
  mutate(sexe = case_when(
          str_detect(nom, fixed("Mme")) ~ "Femme",
          str_detect(nom, fixed("M.")) ~ "Homme"
      )
  )
```
:::



**Exercice 5**

Extraire l'année de naissance de chaque individu avec `str_extract`. Vous pouvez utiliser le regex `"\\d\\d\\d\\d"` qui permet d'identifier les nombres de quatre chiffres.

Vous devez obtenir le vecteur suivant :

```{r echo = FALSE, ref.label='str5'}
```

::: {.solution-exo}
```{r str5, eval=FALSE}
str_extract(d$naissance, "\\d\\d\\d\\d")
```
:::



À l'aide de la fonction `extract` de l'extension `tidyr` et du regex précédent, créez une nouvelle variable `annee` dans le tableau, qui contient l'année de naissance (pour plus d'informations sur `extract`, voir @sec-extract).

```{r echo = FALSE, ref.label='str5b'}
```

::: {.solution-exo}
```{r str5b, eval=FALSE}
library(tidyr)
d %>%
    extract(
        naissance,
        "annee",
        "(\\d\\d\\d\\d)",
        remove = FALSE
    )
```
:::