Importing and Exporting Data

The post is about “Import Data into R Language” in the form of questions and answers. R Language is a powerful tool for data analysis. Before working with data, one must import it into the R environment. Whether the data is stored in CSV, Excel, JSON, or a database, R provides multiple functions and packages to load datasets efficiently.

Here, we will explore different methods to import data in R.

• Reading CSV and text files using read.csv() and read.table()
• Importing Excel files with readxl and openxlsx
• Loading data from databases and web sources
• Handling large datasets with optimized packages like data.table and vroom

Explain Import Data Into R language

R provides to import data in R language. To begin with, the R commander GUI can be used to import the data by typing the commands in the command Rcmdr into the console. The three ways to import data in R Language are:

• Select the data set in the dialog box or enter the name of the data set as required.
• Data is entered directly using the editor of R Commander via Data->New Data Set. This works well only when the data set is not too large.
• Data can also be imported from a URL, (or from a plain text file (ASCII), or from any statistical package, or from the clipboard).

Write about Functions used to Data Import In R Language from other Software

Some important and popular functions used for data import in R Language are:

• read.table(): The read.table() function in R is a versatile tool for importing structured data from text files (such as *.txt or *.csv) into a data frame. The read.table() can handle various delimiters, missing values, and different data types. The basic syntax of read.table() is:
  data <- read.table(file, header = FALSE, sep = "", stringsAsFactors = FALSE)
• readLines(): The readLines() function in R language reads text files line by line and stores each line as a character string in a vector. readLines() is useful for processing raw text data, log files, or unstructured data where each line needs individual handling. The basic syntax of readLines() is:
  lines <- readLines(file, n = -1, encoding = "UTF-8")
• read.fwf(): The read.fwf() function in R Language reads fixed-width formatted files, where columns are aligned by character positions rather than delimiters (like in CSV or TSV files). This is useful for legacy data formats, government datasets, or reports where spacing defines the structure. The basic syntax of read.fwf() is:
  data <- read.fwf(file, widths, header = FALSE, sep = "\t", skip = 0)
• read.delim(): The read.delim() function in R language is a convenient way to import tab-separated values (TSV) files into a data frame. It is essentially a wrapper for read.table() with defaults optimized for tab-delimited data. The basic syntax of read.delim() is:
  data <- read.delim(file, header = TRUE, sep = "\t", stringsAsFactors = FALSE)
• scan(): The scan() function in R Language provides a flexible way to read data from files or user input (console input) into vectors or lists. Unlike higher-level functions like read.table(), the scan() offers fine-grained control over data reading, making it useful for unstructured or custom-formatted data. The basic syntax of scan() is:
  data <- scan(file = "", what = numeric(), sep = "", n = -1, quiet = FALSE)
• read.csv(): The read.csv() function in R Language is used for importing comma-separated values (CSV) files into a data frame. The read.csv() is a specialized version of read.table() with defaults optimized for CSV files, making it beginner-friendly and efficient for standard data imports. The Basic Syntax of read.csv() is
  data <- read.csv(file, header = TRUE, sep = ",", stringsAsFactors = FALSE)
• read.csv2(): The read.csv2() function is a variant of read.csv() designed for European-style CSV files, where commas are used as decimal points and semicolons as column separators. The basic syntax of read.csv2() is:
  data <- read.csv2(file, header = TRUE, sep = ";", dec = ",", stringsAsFactors = FALSE)

Why Import Data in R Language?

Importing data in R (or Import Data into R Language) refers to the process of loading external datasets (stored in files, databases, or web sources) into R’s working environment for analysis, visualization, or modeling. R provides built-in functions and specialized packages to read data from various formats like CSV, Excel, JSON, SQL databases, and more.

• Perform statistical analysis on real-world datasets.
• Clean and preprocess raw data before modeling.
• Visualize trends using libraries like ggplot2.
• Automate workflows by scripting data-loading steps.

What are the Common Data Import Methods in R Language

Text Files (CSV, TSV, TXT)

• read.csv()/ read.csv2() (for European decimals)
• read.table() (flexible for any delimiter)
• read.delim() (tab-separated files)

Excel Files

• readxl::read_excel() (modern, fast)
• openxlsx::read.xlsx()

JSON/Web Data

• jsonlite::fromJSON()
• httr or curl for APIs

Databases (SQL, NoSQL)

• DBI + RSQLite, RMySQL, RPostgreSQL
• odbc package

Statistical Software Formats

• haven for SAS/SPSS/Stata files
• foreign for legacy formats

Big Data & Fast Import

• data.table::fread() (fast CSV/TSV)
• vroom (reads large files lazily)

What are the Key Considerations When Importing Data in R Language

• File paths: Use absolute/relative paths or file.choose() for interactive selection.
• Encoding: Handle special characters (e.g., encoding = "UTF-8").
• Performance: For large datasets, use optimized tools like data.table or arrow.
• Reproducibility: Script your import steps for automation.

Take Quizzes about Data Science

There are many ways to read data into R Language.  We will learn here how to import data in R Language, too. We can also generate certain kinds of patterned data. Learn how to import data in R like a pro! This guide covers reading CSV, Excel, SPSS, SAS, and Data from R Library using base R and powerful packages like Hmisc and RODBC. It is essential for data scientists, researchers, analysts, and R beginners who need efficient data-loading techniques!

Reading Data from the Keyboard Directly

For small data (few observations), one can input data in vector form directly on R Console, such as

x <- c(1, 2, 3, 4, 5)
y <- c('a', 'b', 'c')

In vector form, data can be on several lines by omitting the right parentheses until the data are complete, such as

x <- c(1, 2 
       3, 4)

Note that it is more convenient to use the scan function, which permits the index of the next entry.

Using the Scan Function in R

For small data sets it is better to read data from the console by using the scan function. The data can be entered on a separate line, by using a single space and/or tab. After entering the complete required data, pressing the enter key twice will terminate the scanning.

X <- scan()
1:   3 4 5
4:   4 5 6 7
8:   2 3 4 5 6 6
14:
Read 13 items

Reading String Data using the “what” Option

y <- scan(what=" ")
1:    red green blue
4:    white
5:
Read 4 items

The scan function can be used to import data. The scan function returns a list or a vector, while the read.table function returns a data frame. It means that the scan function is less useful for imputing “rectangular” type data.

Reading data from ASCII or plain text files into R as Data Frame

The read.table function reads any type of delimited ASCII file. It can be numeric and character values. Reading data into R read.table is the easiest and most reliable method. The default delimiter is a blank space.

data <- read.table(file=file.choose()) #select from dialog box

data <- read.table("http://itfeature.com/test.txt", header=TRUE)) # read from web site

Note that the read.table command can also be used for reading data from the computer disk by providing an appropriate path in inverted commas, such as

data <-read.table("D:/data.txt", header=TRUE)) # read from your computer

For missing data, read.table will not work, and you will receive an error. For missing values, the easiest way to fix this error, change the type of delimiter by using a sep argument to specify the delimiter.

data <-read.table("http//itfeature.com/missing_comma.txt", header=TRUE, sep=","))

Comma-delimited files can be read in by read.table function and sep argument, but they can also be read in by the read.csv function specifically written for comma-delimited files. To display the contents of the file, use print() function or file name.

data <- read.csv(file=file.choose() )

Reading in fixed formatted files

To read data in fixed format use read.fwf function and argument width are used to indicate the width (number of columns) for each variable. In this format, variable names are not there in the first line, therefore, they must be added after reading the data. Variable names are added by dimnames function and the bracket notation to indicate that we are attaching names to the variables (columns) of the data file. Anyhow there are several different ways to do this task.

data <- read.fwf("http://itfeature.com/test_fixed.txt", width = c(8,1,3,1,1,1) )

dimnames(data)[[2]]
c("v1", "v2", "v3", "v4", "v5","v6")

Import Data In R

Importing data in R is fairly simple. For Stata and Systat, use the foreign package. For SPSS and SAS recommended package is the Hmisc package for ease and functionality. See the Quick-R section on packages for information on obtaining and installing these packages. Examples of importing data in R are provided below.

From Excel

On Windows systems, you can use the RODBC package to access Excel files. The first row of the Excel file should contain variable/column names.

# Excel file name is myexcel and WorkSheet name is mysheet
library(RODBC)
channel <- odbcConnectExcel("c:/myexel.xls")
mydata <- sqlFetch(channel, "mysheet") 
odbcClose(channel)

From SPSS

# First save SPSS dataset in trasport format
get file = 'c:\data.sav'
export outfile = 'c:\data.por'

library(Hmisc)
mydata <- spss.get("c:/data.por", use.value.labels=TRUE)   
# "use.value.labels" option converts value labels to R factors.

From SAS

# save SAS dataset in trasport format
libname out xport 'c:/mydata.xpt';
data out.data;
set sasuser.data;
run;
# in R
library(Hmisc)
mydata <- sasxport.get("c:/data.xpt")
# character variables are converted to R factors
From Stata
# input Stata file
library(foreign)
mydata <- read.dta("c:/data.dta")
From systat
# input Systat file
library(foreign)
mydata <- read.systat("c:/mydata.dta")

Accessing Data in R Library

Many of the R libraries, including the CAR library, contain data sets. For example, to access the Duncan data frame from the CAR library in R, type the following command on R Console

library(car)
data(Duncan)
attach(Duncan)

Some Important Commands for Dataframes

data        #displays the entire data set on command editor
head(data)  #displays the first 6 rows of dataframe
tail(data)  #displays the last 6 rows of dataframe
str(data)   #displays the names of variable and their types
names(data) #shows the variable names only
rename(V1,Variable1, dataFrame=data) # renames V1 to variable 1; note that epicalc packagemust be installed
ls()        #shows a list of objects that are available
attach(data)#attached the dataframe to the R search path, which makes it easy to access variables names.

https://gmstat.com

https://itfeature.com