Exporter des données depuis R : CSV, Excel et RDS — quel format choisir

Un guide de décision pour enregistrer un data frame dans un fichier — le bon format selon l’usage

Exporter des données depuis R vers un fichier : choisir entre CSV/texte (write.csv(), readr::write_csv()), Excel (writexl::write_xlsx()) et les formats R natifs (saveRDS(), save()). Un guide de décision quel-format-quand avec un exemple exécutable de chacun, renvoyant aux leçons dédiées à chaque format.

AstuceL’essentiel

• CSV / texte — universel, lisible par l’humain, s’ouvre partout : write.csv(df, "out.csv") ou readr::write_csv().
• Excel (.xlsx) — pour les collègues qui vivent dans Excel : writexl::write_xlsx(df, "out.xlsx").
• RDS / RData — des formats R natifs qui préservent exactement les types, les facteurs et les listes : saveRDS() / save().
• Grosses données — arrow (Parquet/Feather) et fst sont des alternatives rapides, compactes et en colonnes.
• Choisissez le format selon qui le lit ensuite — une personne et un tableur, ou R lui-même rechargeant l’objet.

Introduction

Votre analyse est terminée et le résultat doit sortir de R — vers un fichier qu’un collègue ouvre, qu’une chaîne de production de rapports reprend, ou que votre propre prochaine session recharge. La seule vraie décision est quel format, et cela dépend entièrement de qui (ou quoi) lit le fichier ensuite.

Cette page est la vue d’ensemble : la décision, puis un exemple exécutable de chaque voie, avec des liens vers la leçon dédiée où chaque format est approfondi. Trois formats couvrent presque tout.

             Format                                                  Best when
1        CSV / text      A human or any tool must read it; maximum portability
2     Excel (.xlsx)                          A colleague will open it in Excel
3       RDS / RData R will reload it; types/factors/lists must survive exactly
4 Parquet / Feather            Large data shared across R / Python / databases
5               fst          Very large data frames, fastest R-to-R round trip
                        Write with
1 write.csv() / readr::write_csv()
2            writexl::write_xlsx()
3               saveRDS() / save()
4           arrow::write_parquet()
5                 fst::write_fst()

La règle générale : CSV quand quelque chose d’autre que R le lit, Excel quand ce quelque chose est un utilisateur de tableur, RDS quand R le relit et que la structure exacte des données importe.

CSV et texte — le choix universel par défaut

Un CSV est du texte brut que n’importe quel outil peut ouvrir, c’est donc le choix sûr par défaut pour le partage. Le write.csv() de base R ne nécessite aucun package ; le write_csv() de readr est plus rapide et écrit proprement en UTF-8.

# base R — no package needed
csv_path <- tempfile(fileext = ".csv")          # your own path: "results.csv"
write.csv(head(iris, 5), csv_path, row.names = FALSE)

# readr — faster, UTF-8 by default
library(readr)
write_csv(head(iris, 5), csv_path)

# read it back to confirm the round trip
read_csv(csv_path, show_col_types = FALSE)

# A tibble: 5 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl> <chr>  
1          5.1         3.5          1.4         0.2 setosa 
2          4.9         3            1.4         0.2 setosa 
3          4.7         3.2          1.3         0.2 setosa 
4          4.6         3.1          1.5         0.2 setosa 
5          5           3.6          1.4         0.2 setosa 

La seule habitude à conserver : row.names = FALSE en base R (readr n’écrit jamais les noms de lignes) pour ne pas obtenir une colonne d’index parasite. Pour une sortie séparée par des tabulations, utilisez write_tsv() ou write.table(..., sep = "\t"). La leçon dédiée Lire et écrire des CSV/texte couvre les séparateurs, les encodages et les décimales européennes.

Excel — pour les adeptes du tableur

Quand le fichier part vers quelqu’un qui travaille dans Excel, écrivez un vrai .xlsx. writexl est le choix moderne et léger — une seule fonction, pas de Java :

library(writexl)
xlsx_path <- tempfile(fileext = ".xlsx")        # your own path: "results.xlsx"
write_xlsx(head(iris, 5), xlsx_path)
file.exists(xlsx_path)

[1] TRUE

Plusieurs feuilles proviennent d’une liste nommée : write_xlsx(list(Sheet1 = df1, Sheet2 = df2), "out.xlsx"). Pour la mise en forme, les en-têtes en gras et l’ajustement automatique de la largeur, utilisez openxlsx. Le traitement complet — classeurs multi-feuilles, mise en forme, vérification de l’aller-retour — se trouve dans Écrire des fichiers Excel dans R ; pour aller dans l’autre sens, voir Lire des fichiers Excel dans R.

Note

Évitez l’ancien package xlsx basé sur Java — il nécessite rJava/un JDK et échoue souvent à l’installation. Utilisez writexl (export simple) ou openxlsx (mise en forme) à la place.

RDS et RData — les formats R natifs

Quand R lui-même recharge le fichier, enregistrez-le dans un format natif. Contrairement au CSV, ceux-ci préservent l’objet exactement — types de colonnes, niveaux de facteurs, listes, objets de modèle, attributs — rien n’est ré-analysé ni deviné.

saveRDS() enregistre un seul objet ; vous lui attribuez le nom de votre choix au rechargement :

rds_path <- tempfile(fileext = ".rds")
saveRDS(iris, rds_path)

# restore under any name you like
flowers <- readRDS(rds_path)
identical(flowers, iris)        # TRUE — types and all

[1] TRUE

save() stocke ensemble un ou plusieurs objets nommés ; load() les restaure sous leurs noms d’origine :

rdata_path <- tempfile(fileext = ".RData")
a <- 1:10
b <- head(mtcars, 3)
save(a, b, file = rdata_path)

# load() brings back `a` and `b` by their saved names
load(rdata_path)

Utilisez saveRDS() pour un objet unique que vous nommerez vous-même (le choix le plus propre et le plus courant) ; save()/load() quand vous voulez regrouper plusieurs objets. La leçon dédiée Enregistrer en RDS et RData couvre la compression, save.image() et les cas où qs est plus rapide.

Données plus volumineuses et rapports

• Grosses données multi-langages — arrow::write_parquet(df, "out.parquet") écrit du Parquet en colonnes que R, Python (pandas/polars) et les bases de données lisent tous rapidement et de manière compacte ; Feather (arrow::write_feather()) est la variante rapide en mémoire.
• Très grosses données R-vers-R — fst::write_fst(df, "out.fst") offre l’aller-retour R-uniquement le plus rapide avec compression.
• Rapports Word / PowerPoint mis en forme — ne générez pas les documents Office objet par objet (l’ancien workflow ReporteRs est mort). Écrivez un document Quarto qui s’exporte en Word/PowerPoint/PDF depuis la même source, ou utilisez officer pour une sortie Office fine.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la construction. Modifiez celui-ci et appuyez sur Run — il écrit les mêmes données en CSV, Excel et RDS, puis relit chacune pour prouver que l’export a fonctionné, entièrement dans votre navigateur via webR (sans installation).

🟢 Avec un agent IA

Demandez à Prova « J’ai besoin d’envoyer ce data frame à un collègue dans Excel et aussi de le mettre en cache pour ma prochaine session R — écris les deux exports » et elle choisit write_xlsx() pour le collègue et saveRDS() pour le cache. Parce que le runtime est juste là, vous exécutez les deux et les relisez, confirmant que le bon format a atterri pour chaque usage. Demander à Prova →

Vous travaillez en Python ? Un guide pandas to_csv / to_excel / to_parquet arrive bientôt dans la série Python.

Problèmes courants

Votre CSV a une première colonne supplémentaire sans nom. Le write.csv() de base R écrit les noms de lignes par défaut. Passez row.names = FALSE (le write_csv() de readr ne les écrit jamais) pour ne pas obtenir une colonne d’index parasite au rechargement.

Votre CSV s’ouvre mal dans l’Excel européen. Certaines locales attendent ; comme séparateur et , comme marque décimale. Utilisez write.csv2() (base R) ou readr::write_csv2() pour cette convention, ou remettez plutôt au collègue un .xlsx et contournez le problème.

Les dates, les facteurs ou les colonnes-listes sont revenus en texte brut depuis le CSV. Le CSV ne stocke que du texte — tout est ré-analysé à la lecture, donc les types et les niveaux de facteurs peuvent changer. Quand la structure exacte doit survivre, utilisez saveRDS() (R natif) plutôt que le CSV.

Questions fréquentes

NoteComment exporter un data frame depuis R vers un fichier ?

Choisissez le format selon qui le lit ensuite. Pour un fichier texte portable : write.csv(df, "out.csv", row.names = FALSE) ou readr::write_csv(df, "out.csv"). Pour Excel : writexl::write_xlsx(df, "out.xlsx"). Pour que R le recharge exactement : saveRDS(df, "out.rds").

NoteDois-je enregistrer mes données en CSV ou en RDS dans R ?

Utilisez le CSV quand quelque chose d’autre que R doit le lire — il est universel et lisible par l’humain, mais ne stocke que du texte, donc les types et les facteurs sont ré-analysés au rechargement. Utilisez le RDS (saveRDS()) quand R le relit et que la structure exacte (types, facteurs, listes, attributs) doit être préservée inchangée.

NoteQuelle est la différence entre saveRDS() et save() dans R ?

saveRDS() stocke un seul objet sans nom ; vous lui attribuez le nom de votre choix avec readRDS(). save() stocke un ou plusieurs objets nommés dans un seul fichier, et load() les restaure sous leurs noms d’origine. Préférez saveRDS() pour un objet unique que vous voulez nommer vous-même.

NoteComment exporter un data frame R vers Excel ?

Utilisez writexl : write_xlsx(df, "out.xlsx") — pas de Java, pas de dépendances. Pour plusieurs feuilles, passez une liste nommée. Pour la mise en forme et l’ajustement de la largeur, utilisez openxlsx. Évitez l’ancien package xlsx, qui nécessite un JDK. Voir la leçon dédiée Écrire des fichiers Excel.

NoteComment exporter efficacement de grosses données depuis R ?

Pour de grosses données ou des données multi-langages, écrivez du Parquet avec arrow::write_parquet() — compact, en colonnes, et lu rapidement par R, Python et les bases de données. Pour l’aller-retour R-uniquement le plus rapide, utilisez fst::write_fst(). Tous deux battent le CSV en taille et en vitesse pour les grandes tables.

Testez vos connaissances

ImportantExercice : exporter les mêmes données de trois façons

Écrivez head(mtcars, 4) dans un CSV (sans colonne de noms de lignes), un fichier Excel et un fichier RDS. Puis relisez le RDS et confirmez qu’il est égal à ce que vous avez enregistré.

# saveRDS(object, file) writes; readRDS(file) reads back.
# write_csv already drops row names — nothing extra needed.

library(readr) library(writexl) df <- head(mtcars, 4) write_csv(df, tempfile(fileext = ".csv")) write_xlsx(df, tempfile(fileext = ".xlsx")) rds <- tempfile(fileext = ".rds") saveRDS(df, rds) restored <- readRDS(rds) identical(restored, df) # TRUE

library(readr)
library(writexl)

df <- head(mtcars, 4)

write_csv(df, tempfile(fileext = ".csv"))
write_xlsx(df, tempfile(fileext = ".xlsx"))

rds <- tempfile(fileext = ".rds")
saveRDS(df, rds)

restored <- readRDS(rds)
identical(restored, df)      # TRUE

NoteVérification rapide : quel format préserve exactement les types R ?

Vous rechargerez le fichier dans R et les niveaux de facteurs et les types de colonnes doivent survivre inchangés. Quel format ?

A. CSV via write.csv() B. Excel via write_xlsx() C. RDS via saveRDS()

Afficher la réponse

C. saveRDS() stocke l’objet R natif, donc les types, les niveaux de facteurs, les listes et les attributs reviennent exactement. Le CSV (A) et Excel (B) stockent des valeurs plates qui sont ré-analysées à la lecture, donc les types et les facteurs peuvent changer. Utilisez CSV/Excel pour le partage, RDS quand R recharge l’objet.

Conclusion

Exporter depuis R est une seule décision : qui lit le fichier ensuite. CSV (write.csv() / write_csv()) pour la portabilité, Excel (write_xlsx()) pour les utilisateurs de tableur, RDS (saveRDS()) quand R recharge l’objet et que sa structure doit survivre. Tournez-vous vers Parquet/fst pour les grosses données, et Quarto/officer pour les rapports mis en forme. Quoi que vous écriviez, relisez-le une fois pour confirmer l’aller-retour.

Leçons connexes

• Écrire des fichiers Excel dans R — classeurs multi-feuilles, mise en forme et vérification de l’aller-retour. · Lire des fichiers Excel dans R — importer un .xls/.xlsx dans un data frame. · Résumer par groupe dans R — construire la table de synthèse que vous exportez ensuite.
• Pour aller plus loin : Importer et exporter des données — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Importer et exporter des données en R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.