Manipulation et Exportation de Données Textuelles dans R

dessous, nous obtiendrons 1065 à la sortie, ce qui correspond à la taille du fichier en

d'octets. En exécutant le bloc de code ci-dessous, nous obtiendrons 1065 à la sortie, ce qui correspond à la taille du fichier en

dessous, nous obtiendrons 1065 à la sortie, ce qui correspond à la taille du fichier en

octets.

file.size("The_Artist.txt")

Il existe une autre méthode, scan(), qui peut être utilisée pour lire les fic

readLines() et scan() est que la méthode

la méthode scan() lit les fichiers texte mot par mot.

lit les fichiers texte mot par mot.

, qui peut être utilisée pour lire les fichiers .txt. La différence entre les méthodes

hiers .txt. La différence entre les méthodes

est que la méthode readLines() est utilisée pour lire les fichiers texte ligne par ligne alors que

est utilisée pour lire les fichiers texte ligne par ligne alors que

La méthode scan() prend deux arguments. Le premier est le chemin d'accès au fichier et le second argument est l'expression

nts. Le premier est le chemin d'accès au fichier et le second argument est l'expression

nts. Le premier est le chemin d'accès au fichier et le second argument est l'expression

de la chaîne de caractères selon laquelle nous voulons séparer les mots. Comme dans l'exemple ci-dessous, nous passons une

de la chaîne de caractères selon laquelle nous voulons séparer les mots. Comme dans l'exemple ci

de la chaîne de caractères selon laquelle nous voulons séparer les mots. Comme dans l'exemple ci

chaîne vide comme argument séparateur.

my_data1 <- scan("The_Artist.txt", "")

my_data1

scan("The_Artist.txt", "")

Et si nous vérifions la longueur de la variable my_data1, nous obtiendrons le nombre total d'éléments à la sortie.

length(my_data1)

Opérations sur chaines de caractères

Il existe de nombreuses méthodes d'exploitation des chaînes dans R qui peuvent être utilisées pour manipuler les données.

Nous allons utiliser quelques opérations de base sur les données que nous avons lues auparavant.

nchar()

La première fonction est nchar() qui retournera le nombre total de caractères de la chaîne donnée. Découvrons combien de

caractères se trouvent dans le premier élément de la variable my_data.

nchar(my_data[1])

toupper()

Maintenant, il faut parfois que toute la chaîne soit en majuscules. Pour ce faire, il existe une fonction appelée toupper()

dans R qui prend une chaîne en entrée et fournit la chaîne entière en majuscules en sortie.

toupper(my_data[3])

tolower()

De même, la méthode tolower() peut être utilisée pour convertir une chaîne entière en minuscules. Convertissons en

minuscules la même chaîne que celle que nous convertissons en majuscules.

tolower(my_data[3])

chartr()

que faire si nous voulons remplacer des caractères dans une chaîne donnée ? Cette opération peut également être effectuée dans

R en utilisant la méthode chartr() qui prend trois arguments. Le premier argument est constitué par les caractères que nous

voulons remplacer dans la chaîne, le deuxième argument est constitué par les nouveaux caractères et le dernier argument est la

chaîne sur laquelle l'opération sera effectuée. Remplaçons les espaces blancs dans la chaîne par le trait d'union ("-") dans le

premier élément de la variable my_data.

chartr(" ", "-", my_data[1])

strsplit()

Auparavant, nous avons appris que nous pouvons lire un fichier mot par mot en utilisant la fonction scan(). Mais que faire si

nous voulons diviser la chaîne donnée mot par mot ? Cela peut être fait en utilisant la méthode strsplit(). Divisons la

chaîne de caractères en fonction des espaces blancs.

character_list <- strsplit(my_data[1], " ")

word_list <- unlist(character_list)

word_list

Dans le bloc de code ci-dessus, nous séparons la chaîne de caractères mot par mot, mais la méthode strsplit() fournit une

liste à la sortie qui contient tous les mots séparés comme élément unique, ce qui est plus complexe à lire. Ainsi, pour faciliter la

lecture de chaque mot en tant qu'élément unique, nous avons utilisé la méthode unlist() qui convertit la liste en vecteur de

caractères et nous pouvons maintenant accéder facilement à chaque mot en tant qu'élément unique.

sort()

Le tri est également possible dans R. Utilisons la méthode sort() pour trier les éléments du vecteur de caractères

word_list dans l'ordre croissant.

sorted_list <- sort(word_list)

sorted_list

paste()

Maintenant, nous trions tous les éléments du vecteur de caractères word_list. Utilisons ici la fonction paste(), qui sert à

concaténer les chaînes de caractères. Cette méthode prend deux arguments, les chaînes de caractères que nous voulons

concaténer et l'argument collapse qui définit le séparateur dans les mots. Ici, nous allons concaténer tous les mots du

vecteur de caractères sorted_list en une seule chaîne.

paste(sorted_list, collapse = " ")

substr()

Il existe une autre fonction substr() dans R qui est utilisée pour obtenir une sous-partie de la chaîne de caractères. Prenons

un exemple pour mieux comprendre. Dans l'exemple ci-dessous, nous utilisons la méthode substr() et lui fournissons trois

arguments. Le premier argument est la chaîne de données à partir de laquelle nous voulons obtenir la sous-chaîne. Le deuxième

argument est le point de départ à partir duquel la fonction commencera à lire la chaîne de caractères et le troisième argument

est le point d'arrêt jusqu'à l'endroit où nous voulons que la fonction lise la chaîne de caractères.

sub_string <- substr(my_data[1], start = 4, stop = 50)

sub_string

Ainsi, à partir du vecteur de caractères, nous commençons à lire le premier élément à partir de la 4ème position et nous lisons

la chaîne jusqu'à la 50ème position et à la sortie, nous obtenons la chaîne résultante que nous avons stockée dans la variable

sub_string.

trimws()

Comme la sous-chaîne que nous obtenons dans le bloc de code ci-dessus, il y a des espaces blancs aux points initial et final.

Donc, pour les supprimer rapidement, nous pouvons utiliser la méthode trimws() de R comme indiqué ci-dessous.

trimws(sub_string)

Ainsi, à la sortie, nous obtenons la chaîne qui ne contient pas d'espaces blancs aux deux extrémités.

str_sub()

Pour lire la les chaîne à partir de la fin, nous utilisons la bibliothèque stringr. Cette bibliothèque contient la méthode

str_sub(), qui prend les mêmes arguments que la méthode sub_stirng mais lit la chaîne de caractères à partir de la fin.

Comme dans l'exemple ci-dessous, nous fournissons une chaîne de données et les points de départ et d'arrivée avec des valeurs

négatives qui indiquent que nous lisons la chaîne de caractères à partir de la fin.

library(stringr)

str_sub(my_data[1], -8, -1)

Donc, nous lisons des chaînes de -1 à -8 et cela donne talkies. (avec un point) en sortie.

Ecriture et enregistrement dans les fichiers

Après avoir lu des fichiers, nous pouvons également écrire des données dans des fichiers et les enregistrer dans différents

formats de fichier comme .txt, .csv, .xls (pour les fichiers Excel), etc. Voyons quelques exemples.

Exportation sous forme de fichier texte

Supposons que nous voulions exporter une matrice ou une chaîne de caractères dans un fichier .txt. Pour ce faire, nous

pouvons utiliser la méthode write() qui écrit dans le fichier et le sauvegarde sur le disque. Créons une matrice et essayons

de la sauvegarder dans un fichier.

m <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)

m

write(m, file = "my_text_file.txt", ncolumns = 3, sep = " ")

Dans le bloc de code ci-dessus, nous fournissons les données d'entrée, le nom du fichier dans lequel nous voulons stocker les

données ainsi que son chemin d'accès et comme nous utilisons des matrices pour la sortie dans le fichier, nous fournissons la

valeur de l'argument ncolumns et l'argument sep. Essayons d'écrire une chaîne de caractères de notre variable my_data

dans un fichier nommé my_text_file2.txt

write(my_data[1], file = "my_text_file2.txt", ncolumns = 1, sep = " ")

Donc, nous obtenons le premier élément de la variable my_data et nous le fournissons comme entrée pour la fonction

d'écriture et cette fois, nous attribuons à l'argument ncolumn la valeur 1 parce que nous voulons une seule colonne pour la

chaîne.

Exportation sous forme de fichier CSV

Comme nous exportons des données dans des fichiers texte, nous pouvons également exporter des données dans des fichiers

CSV. Pour ce faire, nous avons besoin d'un cadre de données qui contient des données. Pour ce faire, nous pouvons utiliser des

ensembles de données intégrés.

Utilisons le jeu de données sur le CO2 de R qui contient des données sur l'absorption de dioxyde de carbone par les plantes

herbacées. Voyons à quoi ressemblent les données dans l'ensemble de données sur le CO2.

head(CO2)

Maintenant, exportons ces données dans un fichier CSV. Nous utiliserons la méthode write.csv() qui prend la trame de

données comme entrée et un argument de fichier pour spécifier le nom du fichier de sortie.

write.csv(CO2, file = "my_csv.csv")

Maintenant, lorsque nous exécuterons le bloc de code ci-dessus, toutes les données seront exportées dans un fichier CSV. La

première colonne du fichier CSV contient les numéros de ligne que nous ne voulons pas voir figurer dans notre fichier CSV.

Nous devons donc définir les noms de lignes à FALSE dans la méthode write.csv().

write.csv(CO2, file = "my_csv.csv", row.names = FALSE)

De même, pour supprimer les noms de colonnes, il suffit de faire passer col.names à FALSE.

Exportation sous forme de fichier Excel

Pour sauvegarder les données dans des fichiers Excel, nous devons installer une bibliothèque externe appelée xlsx, qui nous

fournira des méthodes faciles pour exporter des données dans des fichiers .xlsx. Installons cette bibliothèque. (Cela peut

prendre une minute ou deux)

install.packages("xlsx")

library(xlsx)

write.xlsx(CO2, file = "my_excel.xlsx", row.names = FALSE)

Ainsi, l'exportation de données dans des fichiers .xlsx est similaire à celle de fichiers .csv, mais le nom de la fonction est

différent et nous avons dû installer une bibliothèque externe pour effectuer cette opération.

Exportation sous forme de fichier .RData

Dans R, nous pouvons également enregistrer des fichiers au format .RData. Le format .RData permet de sauvegarder et de

charger nos objets R. Créons des objets variables simples et enregistrons les dans un fichier avec l'extension .RData.

var1 <- "var1"

var2 <- "var2"

var3 <- "var3"

Maintenant, pour écrire dans un fichier .RData, nous allons utiliser la méthode save() de R. Elle a un argument list qui

est la liste contenant les noms des variables de tous les objets que nous voulons sauvegarder (qui dans ce cas sont trois

variables), un argument file qui contient le nom du fichier dans lequel nous allons écrire/sauvegarder les données et un

argument safe qui est de spécifier si vous voulez que la sauvegarde soit effectuée de manière atomique.

save(list = c("var1", "var2", "var3"), file = "variables.RData", safe = T)

Le fichier nommé variables.RData est généré à l'endroit prévu.