Before starting to explore data, you must load the data into the R session. This recipe will introduce methods to load data from a file into the memory, use the predefined data within R, using the data from database.
First, start an R session on your machine. As this recipe involves steps toward the file I/O, if the user does not specify the full path, read and write activity will take place in the current working directory. For working with databases, it is assumed you have working PostgreSQL on your system with some data.
You can simply type getwd() in the R session to obtain the current working directory location. However, if you would like to change the current working directory, you can use setwd("<path>"), where <path> can be replaced with your desired path, to specify the working directory.
Perform the following steps to read and write data with R:
- To view the built-in datasets of R, type the following command:
> data()
- R will return a list of datasets in a
datasetpackage, and the list comprises the name and description of each dataset. - To load the dataset
irisinto an R session, type the following command:
> data(iris)
- The dataset
irisis now loaded into the DataFrame format, which is a common data structure in R to store a data table.
- To view the data type of iris, simply use the
classfunction:
> class(iris)
[1] "data.frame"- The
data.frameconsole print shows that theirisdataset is in the structure of DataFrame. - Use the
savefunction to store an object in a file. For example, to save the loadedirisdata intomyData.RData, use the following command:
> save(iris, file="myData.RData")- Use the
loadfunction to read a saved object into an R session. For example, to loadirisdata frommyData.RData, use the following command:
> load("myData.RData")- In addition to using built-in datasets, R also provides a function to import data from text into a DataFrame. For example, the
read.tablefunction can format a given text into a DataFrame:
> test.data = read.table(header = TRUE, text = "
+ a b
+ 1 2
+ 3 4
+ ") - You can also use
row.namesandcol.namesto specify the names of columns and rows:
> test.data = read.table(text = "
+ 1 2
+ 3 4",
+ col.names=c("a","b"),
+ row.names = c("first","second")) - View the class of the
test.datavariable:
> class(test.data)
[1] "data.frame" - The
classfunction shows that thetest.datavariable contains a DataFrame. - In addition to importing data by using the
read.tablefunction, you can use thewrite.tablefunction to export data to a text file:
> write.table(test.data, file = "test.txt" , sep = " ")
- The
write.tablefunction will write the content oftest.dataintotest.txt(the written path can be found by typinggetwd()), with a separation delimiter as white space. - Similar to
write.table,write.csvcan also export data to a file. However,write.csvuses a comma as the default delimiter:
> write.csv(test.data, file = "test.csv")
- With the
read.csvfunction, thecsvfile can be imported as a DataFrame. However, the last example writes column and row names of the DataFrame to thetest.csvfile. Therefore, specifying header toTRUEand row names as the first column within the function can ensure the read DataFrame will not treat the header and the first column as values:
> csv.data = read.csv("test.csv", header = TRUE, row.names=1)
> head(csv.data)
a b
1 1 2
2 3 4 This section will cover how to work with the database. To connect with PostgreSQL, the RPostgreSQL package is required which can be installed using this command:
> install.packages("RPostgreSQL")Note
It will install package in your system. You need to have active internet connection for this command to complete. Once installed you can use the package for accessing database. You need to have username, password, database name for accessing the PostgreSQL. Replace the value with your values for parameter in dbconnect function.
> require("RPostgreSQL")
> driver = dbDriver("PostgreSQL")
> connection = dbConnect(driver, dbname="restapp", host="localhost",
port=5432, user="postgres", password="postgres")
> dbExistsTable(connection, "country")
[1] TRUE> data = dbGetQuery(connection, "select * from country")
> class(data)
Output:
[1] "data.frame"
> data
Output:
id code name
1 1 US USA
2 43 AS Austria
3 55 BR BrazilReading table data will result in to DataFrame in R.
Generally, data for collection may be in multiple files and different formats. To exchange data between files and RData, R provides many built-in functions, such as save, load, read.csv, read.table, write.csv, and write.table.
This example first demonstrates how to load the built-in dataset iris into an R session.
The iris dataset is the most famous and commonly used dataset in the field of machine learning. Here, we use the iris dataset as an example. The recipe shows how to save RData and load it with the save and load functions. Furthermore, the example explains how to use read.table, write.table, read.csv, and write.csv to exchange data from files to a DataFrame. The use of the R I/O function to read and write data is very important as most of the data sources are external. Therefore, you have to use these functions to load data into an R session.
You need to install the package for reading from the database. For all database, you can find the package, after installing the steps mostly remains the same for reading the data from the database.
For the load, read.table, and read.csv functions, the file to be read can also be a complete URL (for supported URLs, use ?url for more information).
On some occasions, data may be in an Excel file instead of a flat text file. The WriteXLS package allows writing an object into an Excel file with a given variable in the first argument and the file to be written in the second argument:
- Install the
WriteXLSpackage:
> install.packages("WriteXLS")- Load the
WriteXLSpackage:
> library("WriteXLS")- Use the
WriteXLSfunction to write the DataFrameirisinto a file namediris.xls:
> WriteXLS("iris", ExcelFileName="iris.xls")