Tutoriel R: Comment importer des données dans R

Obtenez le livre complet
R pratique pour la communication de masse et le journalisme PDSF 59,95 $ Voir

Cet article est extrait de «Practical R for Mass Communication and Journalism» avec la permission de l'éditeur. © 2019 par Taylor & Francis Group, LLC.

Avant de pouvoir analyser et visualiser des données, vous devez obtenir ces données dans R. Il existe différentes façons de le faire, selon la façon dont vos données sont formatées et où elles se trouvent.

Habituellement, la fonction que vous utilisez pour importer des données dépend du format de fichier des données. Dans la base R, par exemple, vous pouvez importer un fichier CSV avec read.csv(). Hadley Wickham a créé un package appelé readxl qui, comme vous pouvez vous y attendre, a une fonction à lire dans les fichiers Excel. Il existe un autre package, googlesheets, pour extraire les données des feuilles de calcul Google.

Mais si vous ne voulez pas vous souvenir de tout cela, il y a Rio.

La magie de Rio

«Le but de rio est de simplifier au maximum les E / S de fichiers de données [importation / sortie] dans R en implémentant trois fonctions simples dans le style du couteau suisse», selon la page GitHub du projet. Ces fonctions sont import(), export()et convert().

Ainsi, le paquet de Rio a une seule fonction à lire dans de nombreux types de fichiers différents: import(). Si vous import("myfile.csv"), il sait utiliser une fonction pour lire un fichier CSV. import("myspreadsheet.xlsx")fonctionne de la même manière. En fait, rio gère plus de deux douzaines de formats, y compris des données séparées par des tabulations (avec l'extension .tsv), JSON, Stata et des données au format à largeur fixe (.fwf).

Packages nécessaires pour ce didacticiel

  • Rio
  • htmltab
  • readxl
  • googlesheets
  • Pac-Man
  • concierge
  • rmiscutils (pm GitHub) ou readr
  • tibble

Une fois que vous avez analysé vos données, si vous souhaitez enregistrer les résultats sous forme de CSV, de feuille de calcul Excel ou d'autres formats, la export()fonction de rio peut gérer cela.

Si vous ne disposez pas déjà du package rio sur votre système, installez-le maintenant avec install.packages("rio").

J'ai mis en place des exemples de données avec les données de chutes de neige d'hiver de Boston. Vous pouvez vous diriger vers //bit.ly/BostonSnowfallCSV et cliquer avec le bouton droit pour enregistrer le fichier sous BostonWinterSnowfalls.csv dans le répertoire de travail actuel de votre projet R. Mais l'un des points du script est de remplacer le travail manuel - fastidieux ou non - par une automatisation facile à reproduire. Au lieu de cliquer pour télécharger, vous pouvez utiliser la download.filefonction de R avec la syntaxe download.file("url", "destinationFileName.csv"):

download.file ("// bit.ly/BostonSnowfallCSV", "BostonWinterSnowfalls.csv")

Cela suppose que votre système redirigera à partir de ce raccourci d'URL Bit.ly et trouvera avec succès l'URL du fichier réel, //raw.githubusercontent.com/smach/NICAR15data/master/BostonWinterSnowfalls.csv. J'ai parfois eu des problèmes pour accéder au contenu Web sur d'anciens PC Windows. Si vous en avez un et que ce lien Bit.ly ne fonctionne pas, vous pouvez échanger l'URL réelle contre le lien Bit.ly. Une autre option consiste à mettre à niveau votre PC Windows vers Windows 10 si possible pour voir si cela fonctionne.

Si vous souhaitez que rio puisse simplement importer des données directement à partir d'une URL, en fait, il le peut, et j'y reviendrai dans la section suivante. Le but de cette section est de s'entraîner à travailler avec un fichier local.

Une fois que vous avez le fichier de test sur votre système local, vous pouvez charger ces données dans un objet R appelé snowdata avec le code:

snowdata <- rio :: import ("BostonWinterSnowfalls.csv")

Notez qu'il est possible que rio vous demande de retélécharger le fichier au format binaire, auquel cas vous devrez exécuter

download.file ("// bit.ly/BostonSnowfallCSV", "BostonWinterSnowfalls.csv", mode = "wb")

Assurez-vous d'utiliser les options de complétion des onglets de RStudio. Si vous tapez rio::et attendez, vous obtiendrez une liste de toutes les fonctions disponibles. Tapez snowet attendez, et vous devriez voir le nom complet de votre objet en option. Utilisez les touches fléchées haut et bas pour vous déplacer entre les suggestions de saisie semi-automatique. Une fois l'option souhaitée en surbrillance, appuyez sur la touche Tab (ou Entrée) pour ajouter le nom complet de l'objet ou de la fonction à votre script.

Vous devriez voir l'objet snowdataapparaître dans l'onglet de votre environnement dans le volet supérieur droit de RStudio. (Si ce volet supérieur droit affiche l'historique de vos commandes au lieu de votre environnement, sélectionnez l'onglet Environnement.)

Groupe Taylor & Francis

snowdatadevrait montrer qu'il a 76 «obs.» - observations, ou lignes - et deux variables, ou colonnes. Si vous cliquez sur la flèche à gauche de snowdatapour développer la liste, vous verrez les deux noms de colonne et le type de données que chaque colonne contient. Les Winterchaînes de caractères sont et la Totalcolonne est numérique. Vous devriez également pouvoir voir les premières valeurs de chaque colonne dans le volet Environnement.

Groupe Taylor & Francis

Cliquez sur le mot snowdatalui-même dans l'onglet Environnement pour une vue plus semblable à une feuille de calcul de vos données. Vous pouvez obtenir la même vue depuis la console R avec la commande View(snowdata)(cela doit être un V majuscule sur View - viewne fonctionnera pas). Remarque: snowdatan'est pas entre guillemets car vous faites référence au nom d'un objet R dans votre environnement. Dans la rio::importcommande précédente, BostonWinterSnowfalls.csv est entre guillemets car ce n'est pas un objet R; c'est un nom de chaîne de caractères d'un fichier en dehors de R.

Groupe Taylor & Francis

Cette vue présente quelques comportements de type feuille de calcul. Cliquez sur un en-tête de colonne pour le trier en fonction des valeurs de cette colonne dans l'ordre croissant; cliquez une deuxième fois sur le même en-tête de colonne pour trier par ordre décroissant. Il existe un champ de recherche pour trouver les lignes correspondant à certains caractères.

Si vous cliquez sur l'icône Filtre, vous obtenez un filtre pour chaque colonne. La Wintercolonne de caractères fonctionne comme vous vous en doutez, filtrant toutes les lignes contenant les caractères que vous saisissez. Si vous cliquez dans le Totalfiltre de la colonne numérique, les anciennes versions de RStudio affichent un curseur tandis que les plus récentes affichent un histogramme et une zone de filtrage .

Importer un fichier depuis le Web

Si vous souhaitez télécharger et importer un fichier depuis le Web, vous pouvez le faire s'il est accessible au public et dans un format tel qu'Excel ou CSV. Essayer

snowdata <- rio :: import ("// bit.ly/BostonSnowfallCSV", format)

De nombreux systèmes peuvent suivre l'URL de redirection vers le fichier même après vous avoir envoyé un message d'erreur, tant que vous spécifiez le format "csv"car le nom du fichier ici ne comprend pas .csv. Si le vôtre ne fonctionne pas, utilisez plutôt l'URL //raw.githubusercontent.com/smach/R4JournalismBook/master/data/BostonSnowfall.csv.

rio peut également importer des tableaux HTML bien formatés à partir de pages Web, mais les tableaux doivent être extrêmement bien formatés. Supposons que vous souhaitiez télécharger le tableau qui décrit les cotes de gravité du National Weather Service pour les tempêtes de neige. La page d'index régional des chutes de neige des National Centers for Environmental Information ne contient qu'un seul tableau, très bien conçu, donc un code comme celui-ci devrait fonctionner:

rsi_description <- rio :: import ("//www.ncdc.noaa.gov/snow-and-ice/rsi/", format = "html")

Notez à nouveau que vous devez inclure le format, dans ce cas format="html". car l'URL elle-même ne donne aucune indication sur le type de fichier dont il s'agit. Si l'URL incluait un nom de fichier avec une .htmlextension, rio le saurait.

Dans la vraie vie, cependant, les données Web apparaissent rarement sous une forme aussi soignée et isolée. Une bonne option pour les cas qui ne sont pas aussi bien conçus est souvent le paquet htmltab. Installez-le avec install.packages("htmltab"). La fonction de lecture d'un tableau HTML du package est également appelée htmltab. Mais si vous exécutez ceci:

bibliothèque (htmltab) citytable <- htmltab ("// en.wikipedia.org/wiki/List_of_United_States_cities_by_population") str (citytable)

vous voyez que vous n'avez pas la table correcte, car le bloc de données contient un objet. Parce que je n'ai pas spécifié quelle table, il a extrait le premier tableau HTML de la page. Ce n'est pas celui que je veux. Je n'ai pas envie d'importer toutes les tables de la page jusqu'à ce que je trouve la bonne, mais heureusement, j'ai une extension Chrome appelée Table Capture qui me permet d'afficher une liste des tables sur une page.

La dernière fois que j'ai vérifié, le tableau 5 avec plus de 300 lignes était celui que je voulais. Si cela ne fonctionne pas pour vous maintenant, essayez d'installer Table Capture sur un navigateur Chrome pour vérifier quelle table vous souhaitez télécharger.

Je vais essayer à nouveau, en spécifiant le tableau 5 et en voyant les noms de colonne dans la nouvelle table de ville. Notez que dans le code suivant, je mets la citytable <- htmltab()commande sur plusieurs lignes. C'est ainsi qu'il n'a pas dépassé les marges - vous pouvez tout conserver sur une seule ligne. Si le numéro de table a changé depuis la publication de cet article, remplacez-le which = 5par le numéro correct.

Au lieu d'utiliser la page de Wikipédia, vous pouvez remplacer l'URL Wikipédia par l'URL d'une copie du fichier que j'ai créé. Ce fichier se trouve sur //bit.ly/WikiCityList. Pour utiliser cette version, tapez bit.ly/WikiCityListdans un navigateur, puis copiez la longue URL vers laquelle il redirige et utilisez -la à la place de l'URL Wikipedia dans le code ci-dessous:

bibliothèque (htmltab) citytable <- htmltab ("// en.wikipedia.org/wiki/List_of_United_States_cities_by_population", qui = 5) colnames (citytable)

Comment savoir si whichl'argument dont j'avais besoin pour spécifier le numéro de table? J'ai lu le htmltabfichier d'aide à l'aide de la commande ?htmltab. Cela comprenait tous les arguments disponibles. J'ai scanné les possibilités, et « whichun vecteur de longueur un pour l'identification de la table dans le document» semblait juste.

Notez également que j'ai utilisé colnames(citytable)au lieu de names(citytable)pour voir les noms de colonnes. L'un ou l'autre fonctionnera. Base R a également la  rownames()fonction.

Quoi qu'il en soit, ces résultats de table sont bien meilleurs, bien que vous puissiez voir en exécutant str(citytable)que quelques colonnes qui devraient être des nombres sont entrées sous forme de chaînes de caractères. Vous pouvez le voir à la fois en regard chrdu nom de la colonne et des guillemets autour de valeurs telles que 8,550,405.

C'est l'un des petits désagréments de R: R ne comprend généralement pas que 8,550c'est un nombre. J'ai résolu ce problème moi-même en écrivant ma propre fonction dans mon propre paquetage rmiscutils pour transformer toutes ces «chaînes de caractères» qui sont en réalité des nombres avec des virgules en nombres. Tout le monde peut télécharger le package depuis GitHub et l'utiliser.

Le moyen le plus courant d'installer des packages à partir de GitHub est d'utiliser un package appelé devtools. devtools est un package extrêmement puissant conçu principalement pour les personnes qui souhaitent écrire leurs propres packages, et il comprend quelques façons d'installer des packages à partir d'autres endroits que CRAN. Cependant, les outils de développement nécessitent généralement quelques étapes supplémentaires à installer par rapport à un package typique, et je veux laisser les tâches d'administration système ennuyeuses jusqu'à ce qu'elles soient absolument nécessaires.

Cependant, le package pacman installe également des packages à partir de sources non CRAN telles que GitHub. Si vous ne l'avez pas encore fait, installez pacman avecinstall.packages("pacman").

La p_install_gh("username/packagerepo")fonction de pacman s'installe à partir d'un dépôt GitHub.

p_load_gh("username/packagerepo")charge un package en mémoire s'il existe déjà sur votre système, et il s'installe d'abord puis charge un package à partir de GitHub si le package n'existe pas localement.

Mon package d'utilitaires rmisc se trouve à l'adresse smach/rmiscutils. Exécutez pacman::p_load_gh("smach/rmiscutils")pour installer mon package rmiscutils.

Remarque: Un autre package pour installer des packages à partir de GitHub est appelé télécommandes, que vous pouvez installer via  install.packages("remotes"). Son objectif principal est d'installer des packages à partir de référentiels distants tels que GitHub. Vous pouvez consulter le fichier d'aide avec help(package="remotes").

Et, peut-être le plus lisse de tous est un package appelé githubinstall. Il vise à deviner le dépôt où réside un package. Installez-le via  install.packages("githubinstall"); alors vous pouvez installer mon package rmiscutils en utilisant  githubinstall::gh_install_packages("rmiscutils"). On vous demande si vous souhaitez installer le package à smach/rmisutils(vous le faites).

Maintenant que vous avez installé ma collection de fonctions, vous pouvez utiliser ma number_with_commas()fonction pour changer ces chaînes de caractères qui devraient être des nombres en nombres. Je suggère fortement d'ajouter une nouvelle colonne au bloc de données au lieu de modifier une colonne existante - c'est une bonne pratique d'analyse de données quelle que soit la plate-forme que vous utilisez.

Dans cet exemple, j'appellerai la nouvelle colonne PopEst2017. (Si la table a été mise à jour depuis, utilisez les noms de colonne appropriés.)

bibliothèque (rmiscutils) citytable $ PopEst2017 <- number_with_commas (citytable $ `estimation 2017`)

Mon paquet rmiscutils n'est pas le seul moyen de traiter les numéros importés qui ont des virgules, d'ailleurs. Après avoir créé mon package rmiscutils et sa number_with_commas()fonction, le package readr tidyverse est né. readr comprend également une fonction qui tourne des chaînes de caractères en nombres, parse_number().

Après avoir installé readr, vous pouvez générer des nombres à partir de la colonne d'estimation 2017 avec readr:

citytable $ PopEst2017 <- readr :: parse_number (citytable $ `estimation 2017`)

L'un des avantages de readr::parse_number()est que vous pouvez définir le vôtre locale()pour contrôler des éléments tels que le codage et les décimales, ce qui peut intéresser les lecteurs non américains. Exécutez ?parse_number pour plus d'informations.

Remarque: Si vous n'avez pas utilisé la saisie semi-automatique pour la colonne d'estimation 2017, vous avez peut-être rencontré un problème avec ce nom de colonne s'il contient un espace au moment où vous exécutez ce code. Dans mon code ci-dessus, notez qu'il y a des guillemets simples inversés ( `) autour du nom de la colonne. C'est parce que le nom existant contenait un espace, ce que vous n'êtes pas censé avoir dans R. Ce nom de colonne a un autre problème: il commence par un nombre, également généralement un R no-no. RStudio le sait et ajoute automatiquement les guillemets nécessaires autour du nom avec la saisie semi-automatique de l'onglet.

Astuce bonus: il existe un package R (bien sûr qu'il y en a!) Appelé janitor qui peut corriger automatiquement les noms de colonnes gênants importés à partir d'une source de données non compatible R. Installez-le avec install.packages("janitor"). Ensuite, vous pouvez créer de nouveaux noms de colonnes propres à l'aide de la clean_names()fonction de concierge .

Maintenant, je vais créer un tout nouveau bloc de données au lieu de modifier les noms de colonne sur mon bloc de données d'origine, et exécuter clean_names () de concierge sur les données d'origine. Ensuite, vérifiez les noms des colonnes du bloc de données avec names():

citytable_cleaned <- concierge :: clean_names (citytable)

noms (citytable_cleaned)

Vous voyez que les espaces ont été remplacés par des traits de soulignement, qui sont légaux dans les noms de variables R (tout comme les points). Et, tous les noms de colonne qui commençaient par un nombre ont maintenant un xau début.

Si vous ne voulez pas perdre la mémoire en ayant deux copies essentiellement les mêmes données, vous pouvez supprimer un objet R de votre séance de travail avec  la rm()fonction: rm(citytable).

Importer des données à partir de packages

Il existe plusieurs packages qui vous permettent d'accéder aux données directement à partir de R. L'un est quantmod, qui vous permet d'extraire certaines données gouvernementales et financières américaines directement dans R.

Un autre est le package weatherdata bien nommé sur CRAN. Il peut extraire des données de l'API Weather Underground, qui contient des informations pour de nombreux pays à travers le monde. 

Le paquet rnoaa, un projet du groupe rOpenSci, exploite plusieurs ensembles de données de la National Oceanic and Atmospheric Administration des États-Unis, notamment des informations quotidiennes sur le climat, les bouées et les tempêtes.

If you are interested in state or local government data in the US or Canada, you may want to check out RSocrata to see if an agency you’re interested in posts data there. I’ve yet to find a complete list of all available Socrata data sets, but there’s a search page at //www.opendatanetwork.com. Be careful, though: There are community-uploaded sets along with official government data, so check a data set’s owner and upload source before relying on it for more than R practice. “ODN Dataset” in a result means it’s a file uploaded by someone in the general public. Official government data sets tend to live at URLs like //data.CityOrStateName.gov and //data.CityOrStateName.us.

For more data-import packages, see my searchable chart at //bit.ly/RDataPkgs. If you work with US government data, you might be particularly interested in censusapi and tidycensus, both of which tap into US Census Bureau data. Other useful government data packages include eu.us.opendata from the US and European Union governments to make it easier to compare data in both regions, and cancensus for Canadian census data.

When the data’s not ideally formatted

In all these sample data cases, the data has been not only well-formatted, but ideal: Once I found it, it was perfectly structured for R. What do I mean by that? It was rectangular, with each cell having a single value instead of merged cells. And the first row had column headers, as opposed to, say, a title row in large font across multiple cells in order to look pretty—or no column headers at all.

Dealing with untidy data can, unfortunately, get pretty complicated. But there are a couple of common issues that are easy to fix.

Beginning rows that aren’t part of the data. If you know that the first few rows of an Excel spreadsheeet don’t have data you want, you can tell rio to skip one or more lines. The syntax is rio::import("mySpreadsheet.xlsx", skip=3) to exclude the first three rows. skip takes an integer.

There are no column names in the spreadsheet. The default import assumes the first row of your sheet is the column names. If your data doesn’t have headers, the first row of your data may end up as your column headers. To avoid that, use rio::import("mySpreadsheet.xlsx", col_names = FALSE) so R will generate default headers of X0, X1, X2, and so on. Or, use a syntax such as rio::import("mySpreadsheet.xlsx", col_names = c("City", "State", "Population")) to set your own column names.

If there are multiple tabs in your spreadsheet, the which argument overrides the default of reading in the first worksheet. rio::import("mySpreadsheet.xlsx", which = 2) reads in the second worksheet.

What’s a data frame? And what can you do with one?

rio imports a spreadsheet or CSV file as an R data frame. How do you know whether you’ve got a data frame? In the case of snowdata, class(snowdata) returns the class, or type, of object it is. str(snowdata) also tells you the class and adds a bit more information. Much of the info you see with str() is similar to what you saw for this example in the RStudio environment pane: snowdata has 76 observations (rows) and two variables (columns).

Data frames are somewhat like spreadsheets in that they have columns and rows. However, data frames are more structured. Each column in a data frame is an R vector, which means that every item in a column has to be the same data type. One column can be all numbers and another column can be all strings, but within a column, the data has to be consistent.

If you’ve got a data frame column with the values 5, 7, 4, and “value to come,” R will not simply be unhappy and give you an error. Instead, it will coerce all your values to be the same data type. Because “value to come” can’t be turned into a number, 5, 7, and 4 will end up being turned into character strings of "5", "7", and "4". This isn’t usually what you want, so it’s important to be aware of what type of data is in each column. One stray character string value in a column of 1,000 numbers can turn the whole thing into characters. If you want numbers, make sure you have them!

R does have a ways of referring to missing data that won’t screw up the rest of your columns: NA means “not available.”

Les blocs de données sont rectangulaires: chaque ligne doit avoir le même nombre d'entrées (bien que certaines puissent être vides), et chaque colonne doit avoir le même nombre d'éléments.

Les colonnes de la feuille de calcul Excel sont généralement désignées par des lettres: Colonne A, Colonne B, etc. Vous pouvez faire référence à une colonne de bloc de données avec son nom, en utilisant la syntaxe dataFrameName$columnName. Ainsi, si vous tapez snowdata$Totalet appuyez sur Entrée, vous voyez toutes les valeurs dans la Totalcolonne, comme indiqué dans la figure ci-dessous. (C'est pourquoi lorsque vous exécutez la str(snowdata)commande, il y a un signe dollar avant le nom de chaque colonne.)

Groupe Taylor & Francis

A reminder that those bracketed numbers at the left of the listing aren’t part of the data; they’re just telling you what position each line of data starts with. [1] means that line starts with the first item in the vector, [10] the tenth, etc.

RStudio tab completion works with data frame column names as well as object and function names. This is pretty useful to make sure you don’t misspell a column name and break your script—and it also saves typing if you’ve got long column names.

Type snowdata$ and wait, then you see a list of all the column names in snowdata.

It’s easy to add a column to a data frame. Currently, the Total column shows winter snowfall in inches. To add a column showing totals in meters, you can use this format:

snowdata$Meters <- snowdata$Total * 0.0254

The name of the new column is on the left, and there’s a formula on the right. In Excel, you might have used =A2 * 0.0254 and then copied the formula down the column. With a script, you don’t have to worry about whether you’ve applied the formula properly to all the values in the column.

Now look at your snowdata object in the Environment tab. It should have a third variable, Meters.

Because snowdata is a data frame, it has certain data-frame properties that you can access from the command line. nrow(snowdata) gives you the numbers of rows and ncol(snowdata) the number of columns. Yes, you can view this in the RStudio environment to see how many observations and variables there are, but there will probably be times when you’ll want to know this as part of a script. colnames(snowdata) or names(snowdata) gives you the name of snowdata columns. rownames(snowdata) give you any row names (if none were set, it will default to character strings of the row number such as "1", "2", "3", etc.).

Some of these special dataframe functions, also known as methods, not only give you information but let you change characteristics of the data frame. So, names(snowdata) tells you the column names in the data frame, but

names(snowdata) <- c("Winter", "SnowInches", "SnowMeters")

changes the column names in the data frame.

You probably won’t need to know all available methods for a data frame object, but if you’re curious, methods(class=class(snowdata)) displays them. To find out more about any method, run the usual help query with a question mark, such as ?merge or ?subset.

When a number’s not really a number

ZIP codes are a good example of “numbers” that shouldn’t really be treated as such. Although technically numeric, it doesn’t make sense to do things like add two ZIP codes together or take an average of ZIP codes in a community. If you import a ZIP-code column, R will likely turn it into a column of numbers. And if you’re dealing with areas in New England where ZIP codes start with 0, the 0 will disappear.

I have a tab-delineated file of Boston ZIP codes by neighborhood, downloaded from a Massachusetts government agency, at //raw.githubusercontent.com/smach/R4JournalismBook/master/data/bostonzips.txt. If I tried to import it with zips <- rio::import("bostonzips.txt"), the ZIP codes would come in as 2118, 2119, etc. and not 02118, 02119, and so on.

This is where it helps to know a little bit about the underlying function that rio’s import() function uses. You can find those underlying functions by reading the import help file at ?import. For pulling in tab-separated files, import uses either fread() from the data.table package or base R’s read.table() function. The ?read.table help says that you can specify column classes with the colClasses argument.

Create a data subdirectory in your current project directory, then download the bostonzips.txt file with

download.file("//raw.githubusercontent.com/smach/R4JournalismBook/master/data/bostonzips.txt", "data/bostonzips.txt")

If you import this file specifying both columns as character strings, the ZIP codes will come in properly formated:

zips <- rio::import("data/bostonzips.txt", colClasses = c("character”", "character")) str(zips)

Note that the column classes have to be set using the c() function, c("character", "character"). If you tried colClasses, "character", you’d get an error message. This is a typical error for R beginners, but it shouldn’t take long to get into the c() habit.

A save-yourself-some-typing tip: Writing out c("character", "character") isn’t all that arduous; but if you’ve got a spreadsheet with 16 columns where the first 14 need to be character strings, this can get annoying. R’s rep() function can help. rep(), as you might have guessed, repeats whatever item you give it however many times you tell it to, using the format rep(myitem, numtimes). rep("character", 2) is the same as c("character", "character"), so colClasses = rep("character", 2) is equivalent to colClasses = c("character", "character") . And, colClasses = c(rep("character", 14), rep("numeric", 2)) sets the first 14 columns as character strings and the last two as numbers. All the names of column classes here need to be in quotation marks because names are character strings.

I suggest you play around a little with rep() so you get used to the format, since it’s a syntax that other R functions use, too.

Easy sample data

R comes with some built-in data sets that are easy to use if you want to play around with new functions or other programming techniques. They’re also used a lot by people teaching R, since instructors can be sure that all students are starting off with the same data in exactly the same format.

Type data() to see available built-in data sets in base R and whatever installed packages are currently loaded. data(package = .packages(all.available = TRUE)) from base R displays all possible data sets from packages that are installed in your system, whether or not they’re loaded into memory in your current working session.

You can get more information about a data set the same way you get help with functions: ?datasetname or help("datasetname"). mtcars and iris are among those I’ve seen used very often.

If you type mtcars, the entire mtcars data set prints out in your console. You can use the head() function to look at the first few rows with head(mtcars).

You can store that data set in another variable if you want, with a format like cardata <- mtcars.

Or, running the data function with the data set name, such as data(mtcars), loads the data set into your working environment.

One of the most interesting packages with sample data sets for journalists is the fivethirtyeight package, which has data from stories published on the FiveThirtyEight.com website. The package was created by several academics in consultation with FiveThirtyEight editors; it is designed to be a resource for teaching undergraduate statistics.

Prepackaged data can be useful—and in some cases fun. In the real world, though, you may not be using data that’s quite so conveniently packaged.

Create a data frame manually in R

Chances are, you’ll often be dealing with data that starts off outside of R and you import from a spreadsheet, CSV file, API, or other source. But sometimes you might just want to type a small amount of data directly into R, or otherwise create a data frame manually. So let’s take a quick look at how that works.

R data frames are assembled column by column by default, not one row at a time. If you wanted to assemble a quick data frame of town election results, you could create a vector of candidate names, a second vector with their party affiliation, and then a vector of their vote totals:

candidates <- c("Smith", "Jones", "Write-ins", "Blanks")

party <- c("Democrat", "Republican", "", "")

votes <- c(15248, 16723, 230, 5234)

Remember not to use commas in your numbers, like you might do in Excel.

To create a data frame from those columns, use the data.frame() function and the synatx data.frame(column1, column2, column3).

myresults <- data.frame(candidates, party, votes)

Check its structure with str():

str(myresults)

While the candidates and party vectors are characters, the candidates and party data frame columns have been turned into a class of R objects called factors. It’s a bit too in-the-weeds at this point to delve into how factors are different from characters, except to say that

  1. Factors can be useful if you want to order items in a certain, nonalphabetical way for graphing and other purposes, such as Poor is less than Fair is less than Good is less than Excellent.
  2. Factors can behave differently than you might expect at times. I recommend sticking with character strings unless you have a good reason to specifically want factors.

You can keep your character strings intact when creating data frames by adding the argument stringsAsFactors = FALSE:

myresults <- data.frame(candidates, party, votes, stringsAsFactors = FALSE) str(myresults)

Now, the values are what you expected.

There’s one more thing I need to warn you about when creating data frames this way: If one column is shorter than the other(s), R will sometimes repeat data from the shorter column—whether or not you want that to happen.

Say, for example, you created the election results columns for candidates and party but only entered votes results for Smith and Jones, not for Write-ins and Blanks. You might expect the data frame would show the other two entries as blank, but you’d be wrong. Try it and see, by creating a new votes vector with just two numbers, and using that new votes vector to create another data frame:

votes <- c(15248, 16723)

myresults2 <- data.frame(candidates, party, votes)

str(myresults2)

That’s right, R reused the first two numbers, which is definitely not what you’d want. If you try this with three numbers in the votes vector instead of two or four, R would throw an error. That’s because each entry couldn’t be recycled the same number of times.

If by now you’re thinking, “Why can’t I create data frames that don’t change strings into factors automatically? And why do I have to worry about data frames reusing one column’s data if I forget to complete all the data?” Hadley Wickham had the same thought. His tibble package creates an R class, also called tibble, that he says is a “modern take on data frames. They keep the features that have stood the test of time, and drop the features that used to be convenient but are now frustrating.”

If this appeals to you, install the tibble package if it’s not on your system and then try to create a tibble with

myresults3 <- tibble::tibble(candidates, party, votes)

and you’ll get an error message that the votes column needs to be either 4four items long or one item long (tibble() will repeat a single item as many times as needed, but only for one item).

Put the votes column back to four entries if you’d like to create a tibble with this data:

library(tibble)

votes <- c(15248, 16723, 230, 5234)

myresults3 <- tibble(candidates, party, votes)

str(myresults3)

It looks similar to a data frame—in fact, it is a data frame, but with some special behaviors, such as how it prints. Also notice that the candidates column is character strings, not factors.

If you like this behavior, go ahead and use tibbles. However, given how prevelant conventional data frames remain in R, it’s still important to know about their default behaviors.

Exporting data

Often after you’ve wrangled your data in R, you want to save your results. Here are some of the ways to export your data that I tend to use most:

Save to a CSV file with rio::export(myObjectName, file="myFileName.csv") and to an Excel file with rio::export(myObjectName, file="myFileName.xlsx"). rio understands what file format you want based on the extension of the file name. There are several other available formats, including .tsv for tab-separated data, .json for JSON, and .xml for XML.

Save to an R binary object that makes it easy to load back into R in future sessions. There are two options.

Generic save() saves one or more objects into a file, such as save(objectName1, objectName2, file="myfilename.RData"). To read this data back into R, you just use the command load("myfilename.RData") and all the objects return with the same names in the same state they had before.

You can also save a single object into a file with saveRDS(myobject, file="filename.rds"). The logical assumption is that loadRDS would read the file back in, but instead the command is readRDS—and in this case, just the data has been stored, not the object name. So, you need to read the data into a new object name, such as mydata <- readRDS("filename.rds").

There’s a third way of saving an R object specifically for R: generating the R commands that would recreate the object instead of the object with final results. The base R functions for generating an R file to recreate an object are dput() or dump(). However, I find rio::export(myobject, "mysavedfile.R") even easier to remember.

Finally, there are additional ways to save files that optimize for readability, speed, or compression, which I mention in the additional resources section at the end of this article.

You can also export an R object into your Windows or Mac clipboard with rio: rio::export(myObjectName, format). And, you can import data into R from your clipboard the same way: rio::import(file).

Bonus: rio’s convert() function lets you—you guessed it—convert one file type to another without having to manually pull the data into and then out of R. See ?convert for more info.

Final point: RStudio lets you click to import a file, without having to write code at all. This isn’t something I recommend until you’re comfortable importing from the command line, beause I think it’s important to understand the code behind importing. But, I admit this can be a handy shortcut.

In the Files tab of RStudio’s lower right pane, navigate to the file you want to import and click it. You’ll see an option to either View File or Import Dataset. Choose Import Dataset to see a dialog that previews the data, lets you modify how the data is imported, and previews the code that will be generated.

Make whatever changes you want and click Import, and your data will be pulled into R.

Additional resources

rio alternatives. While rio is a great Swiss Army knife of file handling, there may be times when you want a bit more control over how your data is pulled into or saved out of R. In addition, there have been times when I’ve had a challenging data file that rio choked on but another package could handle it. Some other functions and packages you may want to explore:

  • Base R’s read.csv() and read.table() to import text files (use ?read.csv and ?read.table to get more information). stringsAsFactors = FALSE is needed with these if you want to keep your character strings as character strings. write.csv() saves to CSV.
  • rio uses Hadley Wickham’s readxl package for reading Excel files. Another alternative for Excel is openxlsx, which can write to an Excel file as well as read one. Look at the openxlsx package vignettes for information about formatting your spreadsheets as you export.
  • Wickham’s readr package is also worth a look as part of the “tidyverse.” readr includes functions to read CSV, tab-separated, fixed-width, web logs, and several other types of files. readr prints out the type of data it has determined for each column—integer, character, double (non-whole numbers), etc. It creates tibbles.

Import directly from a Google spreadsheet. The googlesheets package lets you import data from a Google Sheets spreadsheet, even if it’s private, by authenticating your Google account. The package is available on CRAN; install it via install.packages("googlesheets"). After loading it with library("googlesheets"), read the excellent introductory vignette. At the time of this writing, the intro vignette was available in R at vignette("basic-usage", package="googlesheets"). If you don’t see it, try help(package="googlesheets") and click the User Guides, Package Vignettes and Other Documentation link for available vignettes, or look at the package information on GitHub at //github.com/jennybc/googlesheets.

Scrape data from Web pages with the rvest package and SelectorGadget browser extension or JavaScript bookmarklet. SelectorGadget helps you discover the CSS elements of data you want to copy that are on an HTML page; then rvest uses R to find and save that data. This is not a technique for raw beginners, but once you’ve got some R experience under your belt, you may want to come back and revisit this. I have some instructions and a video on how to do this at //bit.ly/Rscraping. RStudio has a webinar available on demand as well.

Alternatives to base R’s save and read functions. If you are working with large data sets, speed may become important to you when saving and loading files. The data.table package has a speedy fread() function, but beware that resulting objects are data.tables and not plain data frames; some behaviors are different. If you want a conventional data frame, you can get one with the as.data.frame(mydatatable) syntax. The data.table package’s fwrite() function is aimed at writing to a CSV file considerably faster than base R’s write.csv().

Deux autres packages peuvent être intéressants pour le stockage et la récupération de données. Le package feather enregistre dans un format binaire qui peut être lu en R ou Python. Et, le paquet de fst read.fst()et write.fst()offre l' enregistrement rapide et le chargement des objets ainsi que la trame de données R l'option de compression de fichiers.