Une version actualisée de ce chapitre est disponible sur guide-R : Chaînes de texte avec stringr

La version originale de ce chapitre a été écrite par Julien Barnier dans le cadre de son Introduction à R et au tidyverse.

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 :

library(tidyverse)

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 on manipule beaucoup de chaînes de caractères, ne pas hésiter à se reporter à la documentation de stringi.

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

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")
)
nom adresse ville
Mr Félicien Machin 3 rue des Fleurs Nouméa
Mme Raymonde Bidule 47 ave de la Libération Marseille
M. Martial Truc 12 rue du 17 octobre 1961 Vénissieux
Mme Huguette Chose 221 avenue de la Libération Marseille

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 électronique1 :

[\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, 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

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 :

paste(d$adresse, d$ville)
[1] "3 rue des Fleurs Nouméa"              
[2] "47 ave de la Libération Marseille"    
[3] "12 rue du 17 octobre 1961 Vénissieux" 
[4] "221 avenue de la Libération Marseille"

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 :

paste(d$adresse, d$ville, sep = " - ")
[1] "3 rue des Fleurs - Nouméa"              
[2] "47 ave de la Libération - Marseille"    
[3] "12 rue du 17 octobre 1961 - Vénissieux" 
[4] "221 avenue de la Libération - Marseille"

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

paste0(d$adresse, d$ville)
[1] "3 rue des FleursNouméa"              
[2] "47 ave de la LibérationMarseille"    
[3] "12 rue du 17 octobre 1961Vénissieux" 
[4] "221 avenue de la LibérationMarseille"

À 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 :

paste(d$ville)
[1] "Nouméa"     "Marseille"  "Vénissieux" "Marseille"

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

paste(d$ville, collapse = ", ")
[1] "Nouméa, Marseille, Vénissieux, Marseille"

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 :

str_to_lower(d$nom)
[1] "mr félicien machin"  "mme raymonde bidule"
[3] "m. martial truc"     "mme huguette chose" 
str_to_upper(d$nom)
[1] "MR FÉLICIEN MACHIN"  "MME RAYMONDE BIDULE"
[3] "M. MARTIAL TRUC"     "MME HUGUETTE CHOSE" 
str_to_title(d$nom)
[1] "Mr Félicien Machin"  "Mme Raymonde Bidule"
[3] "M. Martial Truc"     "Mme Huguette Chose"

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 :

str_split("un-deux-trois", "-")
[[1]]
[1] "un"    "deux"  "trois"

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

str_split(d$nom, " ")
[[1]]
[1] "Mr"       "Félicien" "Machin"  

[[2]]
[1] "Mme"      "Raymonde" "Bidule"  

[[3]]
[1] "M."      "Martial" "Truc"   

[[4]]
[1] "Mme"      "Huguette" "Chose"

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

str_split(d$nom, " ", simplify = TRUE)
     [,1]  [,2]       [,3]    
[1,] "Mr"  "Félicien" "Machin"
[2,] "Mme" "Raymonde" "Bidule"
[3,] "M."  "Martial"  "Truc"  
[4,] "Mme" "Huguette" "Chose"

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 section @ref(separate).

Voici juste un exemple de son utilisation :

library(tidyr)
d %>% separate(nom, c("genre", "prenom", "nom"))
Warning: Expected 3 pieces. Additional pieces discarded in 1 rows
[1].

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 :

str_sub(d$ville, 1, 3)
[1] "Nou" "Mar" "Vén" "Mar"

Détecter des motifs

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 :

str_detect(d$adresse, "Libération")
[1] FALSE  TRUE FALSE  TRUE

str_detect renvoit 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 :

str_count(d$ville, "s")
[1] 0 1 2 1

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 :

str_subset(d$adresse, "Libération")
[1] "47 ave de la Libération"    
[2] "221 avenue de la 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 :

str_extract(d$adresse, "Libération")
[1] NA           "Libération" NA           "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.

str_extract(d$adresse, "^\\d+")
[1] "3"   "47"  "12"  "221"

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 :

str_extract_all(d$adresse, "\\d+")
[[1]]
[1] "3"

[[2]]
[1] "47"

[[3]]
[1] "12"   "17"   "1961"

[[4]]
[1] "221"

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 plus haut.

Par exemple :

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

Remplacer des motifs

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

Par exemple, on peut remplace les occurrence de “Mr” par “M.” dans les noms de notre tableau :

str_replace(d$nom, "Mr", "M.")
[1] "M. Félicien Machin"  "Mme Raymonde Bidule"
[3] "M. Martial Truc"     "Mme Huguette Chose"

La variante str_replace_all permet de spécifier plusieurs remplacements d’un coup :

str_replace_all(d$adresse, c("avenue" = "Avenue", "ave" = "Avenue", "rue" = "Rue"))
[1] "3 Rue des Fleurs"           
[2] "47 Avenue de la Libération" 
[3] "12 Rue du 17 octobre 1961"  
[4] "221 Avenue de la Libération"

Modificateurs de motifs

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” :

str_count(d$nom, ".")
[1] 18 19 15 18

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

str_count(d$nom, fixed("."))
[1] 0 0 1 0

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 :

str_detect(d$nom, "mme")
[1] FALSE FALSE FALSE FALSE
str_detect(d$nom, regex("mme", ignore_case = TRUE))
[1] FALSE  TRUE FALSE  TRUE

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

Insérer une variable dans une chaîne de caractères

La fonction str_glue repose sur l’extension glue. Elle permet, à l’aide d’une syntaxe un peu spécifique, de pouvoir insérer facilement les valeurs d’une ou plusieurs variables dans une chaîne de caractères. Prenons un exemple :

prenom <- "Fred"
age <- 28
anniversaire <- as.Date("1991-10-12")
str_glue(
  "Je m'appelle {prenom}. ",
  "L'année prochaine j'aurai {age + 1} ans, ",
  "car je suis né le {format(anniversaire, '%A %d %B %Y')}."
)
Je m'appelle Fred. L'année prochaine j'aurai 29 ans, car je suis né le samedi 12 octobre 1991.

Sa variante str_glue_data est adaptée lorsque l’on travaille sur un tableau de données avec dplyr.

d %>% mutate(phrase = str_glue_data(d, "{nom} habite à {ville}."))

Ressources

L’ouvrage R for Data Science, accessible en ligne, contient un chapitre entier sur les chaînes de caractères et les expressions régulières (en anglais).

Le site officiel de stringr contient une liste des fonctions et les pages d’aide associées, ainsi qu’un article dédié aux expressions régulières.

Pour des besoins plus pointus, on pourra aussi utiliser l’extension stringi sur laquelle est elle-même basée stringr.

  1. 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…↩︎