Tutoriel sur les chaînes de caractères en R

Une chaîne est un type de données textuel composé d’un ou de plusieurs caractères. Elle est délimitée par des apostrophes ('Ceci est une chaîne') ou par des guillemets doubles ("Ceci est aussi une chaîne"). En revanche, en représentation interne, R stocke les chaînes entre guillemets doubles.

Dans ce tutoriel, vous allez découvrir les chaînes de caractères en R. Nous aborderons les points suivants.

1. Tout d’abord, un aperçu des chaînes en R et des règles à respecter.
2. Puis, la concaténation de chaînes en R, ainsi que d’autres propriétés essentielles.
3. Ensuite, l’extraction et le remplacement d’une sous-chaîne, expliqués en détail.
4. Enfin, la mise en forme de chaînes, c’est‑à‑dire la conversion de tout vecteur en un format bien présenté.

Règles pour les chaînes de caractères en R

1. Une chaîne qui commence par une apostrophe doit se terminer par une apostrophe. Vous pouvez toutefois inclure des guillemets doubles, et grâce la séquence d’échappement ('\'), une apostrophe peut aussi faire partie de la chaîne.

Par exemple : 'cars', 'merry"s', 'merry\'s' sont des chaînes valides en R.

1. Une chaîne qui commence par des guillemets doubles doit se terminer par des guillemets doubles. Vous pouvez inclure des apostrophes et, via la séquence d’échappement ('\'), un guillemet double peut aussi faire partie de la chaîne.

Par exemple : "cars", "merry's", "merry\"s" sont également des chaînes valides en R.

Concaténation de chaînes

La concaténation consiste à joindre ou fusionner des chaînes.

La syntaxe pour concaténer des chaînes en R est la suivante :
paste(..., sep = "", collapse = NULL)
paste0(..., collapse = NULL)

Les arguments de paste signifient :

1. '...' – Un ou plusieurs caractères ou objets convertis en vecteurs de caractères.
2. 'sep' – Le séparateur entre les éléments.
3. 'collapse' – Un séparateur optionnel pour fusionner le résultat final en une seule chaîne.

Par exemple, considérons le cas ci‑dessous où les variables contiennent des chaînes de caractères : my.var1 = "I" my.var2 = "eat" my.var3 = "rice" print(paste(my.var1,my.var2,my.var3))

Le code ci‑dessus renvoie une seule chaîne comme ci‑dessous :

"I eat rice"

Autre exemple : des vecteurs sont convertis et fusionnés en une seule chaîne :

my.var1 = c('Book','Copy') my.var2 = c('Pen','Chair') print(paste(my.var1,my.var2,sep=" ",collapse="-"))

Le code ci‑dessus produit la sortie suivante :

"Book Pen-Copy Chair"

Ici, le résultat contient un « - » entre Pen et Copy grâce à l’argument collapse, qui insère un séparateur entre deux vecteurs différents. En revanche, sep contient un espace (' '), qui sépare les éléments individuels.

Voyons un exemple avec paste0()

paste0() utilise implicitement sep = "" (aucun espace) et est privilégiée pour son efficacité.

state.name <- paste0('Mary','l','and')
print(state.name)

La sortie ci‑dessous montre que tous les fragments sont fusionnés sans espace.

"Maryland"

Obtenir la longueur

nchar(char, type, allowNA, keepNA) – Calcule le nombre total de caractères d’un vecteur donné.
nzchar(char) – Retourne TRUE si x n’est pas vide et FALSE si la chaîne est vide.

Les arguments signifient :

1. char – Un vecteur de caractères.
2. type – L’un des trois types : "width", "chars", "bytes".
3. allowNA – Logique, FALSE par défaut ; si le résultat ne peut pas être calculé, renvoie NA au lieu d’une erreur.
4. keepNA – Logique, FALSE par défaut : lorsqu’il est TRUE, les valeurs manquantes sont conservées (et nzchar() renverra TRUE pour les NA si mappées ainsi).

Exemple pour déterminer la longueur d’un vecteur de caractères : my.char = nchar("hello") print(my.char)


Le résultat est « 5 », car le vecteur contient cinq caractères.

Pour l’exemple avec nzchar(), consultez le code ci‑dessous :

new.char = nzchar("monkey") print(new.char)

Le code renvoie la valeur logique TRUE, car 'new.char' n’est pas une chaîne vide.

my.char = nzchar("") print(my.char)

Ici, la valeur logique renvoyée est FALSE, car 'my.char' est une chaîne vide.

Passer en majuscules ou en minuscules

toupper(char) – Convertit tous les caractères en majuscules.
tolower(char) – Convertit tous les caractères en minuscules.

Exemple de conversion en majuscules : my.var = toupper("I'm changed to upper case") print(my.var)

La sortie ci‑dessous montre que chaque caractère de la variable 'my.var' est passé en majuscules.

"I'M CHANGED TO UPPER CASE"

Exemple de conversion en minuscules : my.var = tolower("I'm changed to lower case") print(my.var)

La sortie ci‑dessous montre que chaque caractère de la variable 'my.var' est passé en minuscules.

""i'm changed to lower case""

Extraction et remplacement d’une sous-chaîne

substr(char, start, stop) : extrait ou remplace une sous-chaîne.

Les arguments signifient :

1. char – Une chaîne de caractères.
2. start – Entier indiquant la position de départ à retourner.
3. stop – Entier indiquant la position de fin à retourner.

Voyons un exemple d’extraction.

final.value <- substring('Remaining', 3, 9)
print(final.value)

Dans la chaîne 'Remaining', le premier indice est 1 pour 'R'. Le dernier caractère 'g' a l’indice 9.

Avec un départ à 3, le caractère correspondant est 'm' dans 'Remaining'. Les caractères suivants jusqu’à l’entier 9 inclus ('g') sont imprimés.

"maining"

Exemple de remplacement de caractères :

y = "Remaining"
substring(y, 3, 5) <- "der"
print(y)

Les positions 3 à 5 de y sont remplacées par 'der'.

"Rederning"

substring(char, first, last = 1000000L) : extrait ou remplace une sous-chaîne.
Les arguments signifient :

1. char – Une chaîne de caractères.
2. first – Entier indiquant la première position à retourner.
3. last – Entier indiquant la dernière position à retourner (par défaut 1000000L).

my.value <- substring('Remaining', 3, 8)
print(my.value)

Ici, en partant de 3 ('m'), les caractères jusqu’à l’entier 8 inclus ('n') sont imprimés.

"mainin"

Autre exemple de remplacement :

y = "newcharacter"
substring(y, 6,9) <- "???"
print(y)

Les positions 6 à 9 de y sont remplacées par '???'.

"newch???cter"

Mise en forme des chaînes

format(char, width, scientific, justify, nsmall, digits) : convertit des vecteurs numériques ou de caractères dans un format couramment utilisé.

Les arguments signifient :

1. char – Un vecteur d’entiers ou de caractères.
2. width – Largeur minimale de la chaîne produite.
3. scientific – FALSE par défaut ; TRUE pour la notation scientifique.
4. justify – Par défaut « none », peut être "right", "left" ou "center".
5. nsmall – Nombre de décimales à afficher après la virgule.
6. digits – Nombre total de chiffres significatifs (avant et après la virgule).

Exemple de mise en forme en notation scientifique :

my.var <- format(c(2, 19.267), scientific = TRUE)
print(my.var)

La sortie est exprimée en notation scientifique (exponentielle).

"2.0000e+00" "1.9267e+01"

La sortie "1.9267e+01" = 1,9267 × 10^1 = 19,267.

Exemple avec nsmall :

my.var <- format(92.56656577, nsmall = 6)
print(my.var)

Le résultat ci‑dessous inclut 6 chiffres après la virgule.

"92.566565"

Exemple avec digits :

my.var <- format(102.848793834, digits = 7)
print(my.var)

Le résultat ci‑dessous comprend 7 chiffres significatifs au total.

"102.8488"

Sept chiffres sont conservés au total ; le dernier est arrondi à 8 car le chiffre suivant (9) impose un arrondi.

Exemple avec un alignement à droite :

my.var <- format('Running', justify = 'r',width = 9)
print(my.var)

La chaîne 'Running' est alignée à droite dans une largeur de 9 caractères.

"  Running"

Exemple avec un alignement centré :

my.var <- format('Running', justify = 'c',width = 12)
print(my.var)

La chaîne 'Running' est centrée dans une largeur de 12 caractères, avec des espaces à gauche et à droite.

"  Running   "

Félicitations

Félicitations, vous êtes arrivé au bout de ce tutoriel !

Vous avez vu les chaînes de caractères en R : leurs règles, la concaténation, des propriétés essentielles, l’extraction et le remplacement de sous‑chaînes, ainsi que la mise en forme.

Pour aller plus loin avec R, suivez le cours Introduction to R de DataCamp.

Découvrez aussi notre tutoriel Data Types in R.