Lecture et Ecriture de fichiers

Lecture d'un frame à partir d'un fichier contenant un tableau :

• Avec un tableau contenant des étiquettes de lignes et de colonnes et une case vide en haut à gauche, et les colonnes séparées par des espaces ou tabulations : fr <- read.table("file.csv") (le frame a alors des lignes et des colonnes nommées).
• attention : pour inactiver les quotes dans un tableau, faire : read.table(..., quote = "")
• Avec un tableau contenant des étiquettes de colonnes seulement : fr <- read.table("toto.csv", header = TRUE) (le frame a alors des colonnes nommées, et des lignes numérotées).
• Avec un tableau ne contenant ni étiquettes de lignes, ni étiquettes de colonnes : fr <- read.table("file.csv") (le frame a alors des lignes numérotées et des colonnes appelées V1, V2, ...).
• Par défaut, les colonnes où toutes les valeurs sont numériques sont de type numériques, et les colonnes comportant au moins une chaîne sont de classe factor.
• Attention : si une colonne ne contient que des T et/ou des F, R interprête cela comme des booléens (TRUE et FALSE), même is as.is = TRUE ! Utiliser colClasses pour éviter ce comportement !
• fr <- read.table("toto.csv", sep = "\t", na.strings = c("-"), colClasses = c("character", "numeric", "character"), nrows = 10, header = TRUE, check.names = FALSE) :
  • sep = "\t" : précise le séparateur (permet d'inclure des espaces à l'intérieur des champs). On peut aussi utiliser read.delim() qui est la même chose que read.table, mais avec \t comme séparateur par défaut).
  • na.strings : indique les chaînes de caractères qui ont valeur de NA. Attention : si un champ vaut la chaîne NA, il sera interprêté comme NA et non comme la chaîne "NA" ! (mettre na.strings à autre chose pour l'éviter)
  • colClasses : force un type pour chaque colonne (numeric, factor, character, logical, Date, POSIXct).
  • nrows : ne lit que les n premières lignes.
  • as.is = TRUE : indique que les chaînes doivent être lues comme des chaînes de caractères et pas des facteurs.
  • check.names = FALSE : ne change pas les noms des colonnes si celles-ci ne sont pas correctes (uniques et commençant par une lettre). Par défaut, change les noms des colonnes pour avoir des noms valides (transforme 3 en X3 par exemple).

Lecture d'un frame à partir d'un flux : fr <- read.table(pipe("cut -f1,3 file.csv |header -10")) : lit seulement les colonnes 1 et 3 des 10 premières lignes du fichier.

Ecriture d'un dataframe :

• Avec des étiquettes de ligne : write.table(fr, file = "file.csv", append = FALSE, quote = FALSE, sep = "\t", na = "-", row.names = TRUE, col.names = NA) :
  • append : permet de rajouter les données à la fin du fichier (défaut = FALSE).
  • quote = FALSE : évite de mettre des quotes autour des chaînes (défaut = TRUE).
  • sep = "\t": tabulation comme séparateur (défaut = espace).
  • na = "-" : indique ce qui doit être imprimé pour NA (défaut = NA).
  • row.names = TRUE : indique si nom des colonnes doit être sorti (défaut = TRUE, même si pas de noms de colonnes, mais seulement les numéros, sinon mettre à FALSE pour ne pas avoir de noms de lignes).
  • col.names = NA est l'option à utiliser dans on a des lignes et des colonnes. Défaut à TRUE pour avoir noms de colonnes en l'absence de noms de lignes. Mettre à FALSE pour éviter les noms de colonnes.
• Sans étiquettes de ligne (cf ci-dessus) : write.table(fr, file = "file.csv", append = FALSE, quote = FALSE, sep = "\t", na = "-", row.names = FALSE)
• On peut écrire le dataframe sur stdout simplement avec write.table(fr, file = stdout(), quote = FALSE, sep = "\t")

Ecriture simple d'une matrice avec les noms de lignes et de colonnes :

mat <- matrix(c(2, 3, 4, 5), nrow = 2)
rownames(mat) <- c("a", "b")
colnames(mat) <- c("A", "B")
write.table(mat, "out.csv", sep = "\t", quote = FALSE, col.names = NA)
  

Lecture simple d'un fichier :

con <- file("myFile", open = "r")
while (length(line <- readLines(con, n = 1))) {
    print(line)
}
close(con)

ou même en lisant toutes les lignes d'un seul coup :

con <- file("myFile", open = "r")
lines <- readLines(con)
print(lines)
close(con)

C'est un vecteur de type character qui est renvoyé.

Lecture d'une fichier structuré :

con <- file("myFile", open = "r")
while (length(line <- scan(con, what = character(0), sep = "\t", nlines = 1, quiet = TRUE)) > 0) {
    print(line)
}
close(con)

• what : le type lu.
• sep : le séparateur (par défaut, un espace).
• nlines : le nombre de lignes lues (par défaut, toutes les lignes).
• quiet : indique s'il l'on veut imprimer le nombre d'items lus (défaut est FALSE, c'est à dire que le nombre d'items est imprimé).

Ecriture simple d'un fichier (l'argument sep doit être précisé si plusieurs lignes, car son défaut est " ") :

con <- file("myFile", open = "w")
cat("first line\n", file = con)
cat("second line\n", "third line\n", file = con, sep = "")
close(con)

Autre façon d'écrire un fichier :

con <- file("myFile", open = "w")
vect <- c("first line", "second line", "third line")
writeLines(vect, con = con)
close(con)

writeLines :

• writeLines(vect) : par défaut, écrit sur stdout et sépare chaque chaîne de vect par un retour chariot \n.
• writeLines(vect, con = stderr()) : écrit sur stderr (sinon, on peut préciser stdout()).
• writeLines(vect, con = myConnection, sep = " ") : écrit sur la connexion myConnection et sépare chaque chaîne par un espace plutôt qu'un \n.
• writeLines(vect, con = "myFile") : ouvre le fichier, écrit dedans et le referme automatiquement.
• Attention : utiliser writeLines pour écrire un tableau en bouclant sur chaque line est extrèmement inefface par rapport à write.table !