R Data Types Detailed Walkthrough
R implements a number of useful data types to support complex analytics and calculations. This articles focus on String, Vector, List, Matrix, Array, Factory and Data Frame. It also shows examples about expanding data frame, for example, add or drop columns for data frames, add rows for data frames, etc.
String
String data type is one of the most frequently used data type in most programming languages. In R, string value can be single quoted ('') or double quoted(""). To escape the quote characters, '\' can be used.
String to raw (binary) conversion is very common in programming. In R, we can use charToRaw and rawToChar functions.
Some of the other commonly used String functions include:
- format: format other data types to certain string format.
- paste: concatenating strings.
- nchar: returns number of chars in the string.
- toupper and tolower: convert the cases of string.
- substring: extract a sub string.
- strsplit: split the string.
Examples
The following script R08.String.R includes examples about string data type related transformations or conversion:
> v <- '"i am a character"'
> print(v)
[1] "\"i am a character\""
> print(class(v))
[1] "character"
> v <- '"i am a \'character"'
> print(v)
[1] "\"i am a 'character\""
> print(class(v))
[1] "character"
>
> # raw (binary)
> v <- charToRaw('"i am a character"')
> print(v)
[1] 22 69 20 61 6d 20 61 20 63 68 61 72 61 63 74 65 72 22
> print(class(v))
[1] "raw"
> # encoding
> v <- rawToChar(v)
> print(v)
[1] "\"i am a character\""
> print(class(v))
[1] "character"
>
> toupper(v)
[1] "\"I AM A CHARACTER\""
>
> tolower("R PROGRAMMING")
[1] "r programming"
>
> nchar(v)
[1] 18
>
> s<-"R PROGRAMMING"
> substr(s,3,nchar(s))
[1] "PROGRAMMING"
>
> strsplit("R:PROGRAMMING", split=":")
[[1]]
[1] "R" "PROGRAMMING"
>
> format(13.7, nsmall = 3)
[1] "13.700"
> format(c(6.0, 13.1), digits = 2)
[1] " 6" "13"
> format(2^31 - 1, scientific = TRUE)
[1] "2.147484e+09"
>
> format("R PROGRAMMING",width=20, justify = "right")
[1] " R PROGRAMMING"
> format("R PROGRAMMING",width=20, justify = "centre")
[1] " R PROGRAMMING "Vector
In R Programming Basics, I mentioned vector is a list of data elements with same basic data types. Function length() can be used to find the element count in the vector. Function c() can be used to combine values to a vector or list. Arithmetic operations can be applied to vectors. If the object length of operands are different from each other, the longer object's length must be a multiple of the shorter object length. To sort elements, function sort() can be used.
The following are some examples (from script file R09.Vectors.R).
Create sequences
One thing to pay attention to is the final element specified will be discarded if it doesn't belong to the sequence.
> # Creating a sequence from 1 to 10. > v <- 1L:10L > print(v) [1] 1 2 3 4 5 6 7 8 9 10 > print(class(v)) [1] "integer" > > # Creating a sequence from 1.1 to 11.1. > v <- 1.1:11.1 > print(v) [1] 1.1 2.1 3.1 4.1 5.1 6.1 7.1 8.1 9.1 10.1 11.1 > print(class(v)) [1] "numeric" > print(length(v)) [1] 11 > > # If the final element specified does not belong to the sequence then it is discarded. > v <- 2.3:10.5 > print(v) [1] 2.3 3.3 4.3 5.3 6.3 7.3 8.3 9.3 10.3 > print(class(v)) [1] "numeric" > print(length(v)) [1] 9
Use function c()
If the input elements are not the same atomic data type, the subsequent ones will be converted to the same type as the first element.
> # use c to combine values into a Vector or List
> v <- c(1:5)
> print(v)
[1] 1 2 3 4 5
> print(class(v))
[1] "integer"
> print(length(v))
[1] 5
>
> v <- c("Apple", "Pear")
> print(v)
[1] "Apple" "Pear"
> print(class(v))
[1] "character"
> print(length(v))
[1] 2
>
> v <- c('Apple',1,TRUE)
> print(v)
[1] "Apple" "1" "TRUE"
> print(class(v))
[1] "character"
> print(length(v))
[1] 3
Use sort() function
The following example sort the elements alphabetically in the decreasing order.
> # sorting
> c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec") -> v
> sort(v, decreasing = TRUE)
[1] "Sep" "Oct" "Nov" "May" "Mar" "Jun" "Jul" "Jan" "Feb" "Dec" "Aug" "Apr"
> # sorting
> c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec") -> v
> sort(v, decreasing = TRUE)
[1] "Sep" "Oct" "Nov" "May" "Mar" "Jun" "Jul" "Jan" "Feb" "Dec" "Aug" "Apr"
> Element recycling
The following are two examples of element recycling in arithmetic operation. The second one errors out the x length is 10 while y length is 4.
> # Recycling > x<- 1：10 > y<- 2:6 > y+x [1] 3 5 7 9 11 8 10 12 14 16 > x+y [1] 3 5 7 9 11 8 10 12 14 16 > > # Recycling error > x<- 1：10 > y<- 2:5 > x+y [1] 3 5 7 9 7 9 11 13 11 13 Warning message: In x + y : longer object length is not a multiple of shorter object length
Access vector elements
Once vectors are created, elements of them can be accessed using indexing. The [ ] are used for indexing. Different from C based languages, R index starts from 1. Elements can also be accessed via TRUE or FALSE.
The following are some examples of accessing elements (script R10.AccessingVectorElement.R).
> # Accessing vectors
> v <- c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")
> print(v)
[1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
> print(class(v))
[1] "character"
> print(length(v))
[1] 12
>
> # Accessing index
> v[1]
[1] "Jan"
>
> v[1:5]
[1] "Jan" "Feb" "Mar" "Apr" "May"
>
> v[10:12]
[1] "Oct" "Nov" "Dec"
>
> v[c(1,3,5)]
[1] "Jan" "Mar" "May"
>
> # Exclude Janary and March
> v[c(-3,-1)]
[1] "Feb" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
>
> # Exclude using FALSE
> v[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE,FALSE)]
[1] "Jan" "Jun" "Sep"
>
> # Vector will be reused.
> v[c(TRUE,FALSE,FALSE)]
[1] "Jan" "Apr" "Jul" "Oct"
List
For vectors, the data elements must be the same. If your data elements are different, list is the option. A list is the R object which contains elements of all different R objects. List is created using list() function. List can be converted to vector using unlist() function. List can be merged using function c().
The following are some examples about R list (script R11.Lists.R).
> # create list > myList<- list(1:10,"Test", "b", TRUE, list(1,3:100,"string")) > print(myList) [[1]] [1] 1 2 3 4 5 6 7 8 9 10 [[2]] [1] "Test" [[3]] [1] "b" [[4]] [1] TRUE [[5]] [[5]][[1]] [1] 1 [[5]][[2]] [1] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 [22] 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 [43] 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 [64] 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 [85] 87 88 89 90 91 92 93 94 95 96 97 98 99 100 [[5]][[3]] [1] "string" > > listA <- list(1:5,10) > listB <- list(10:26, 100) > c(listA, listB) [[1]] [1] 1 2 3 4 5 [[2]] [1] 10 [[3]] [1] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 [[4]] [1] 100 > > unlist(listA) + unlist(listB) [1] 11 13 15 17 19 25 17 19 21 23 25 31 23 25 27 29 31 110 > > listA[1] [[1]] [1] 1 2 3 4 5
Matrix
Matrix is a rectangular array of numbers, symbols, or expressions, arranged in rows and columns. Matrices containing numeric elements can be used in mathematical calculations.
The following diagram is cited from Wikipedia about Matrix:
Create and access matrix
Matrix can be created using function:
matrix(data, nrow, ncol, byrow, dimnames)
For example, the following script (R12.Matrices.R) creates three matrices using different approaches:
# Matrices
> MA <- matrix(1:10,nrow=2,ncol=5, byrow = TRUE)
> class(MA)
[1] "matrix"
> MB <- matrix(11:20,nrow=2,ncol=5)
>
> MC <- matrix(31:40, nrow=5, ncol=2, dimnames = list(c('row1','row2','row3','row4','row5'),c('col1','col2')))
> View(MC)
Accessing matrix
Matrix can be accessed via row and column index.
> # Accessing > MC[1,2] [1] 36 > MC[1,] col1 col2 31 36 > # class is integer vector > class(MC[1,]) [1] "integer" > MC[,2] row1 row2 row3 row4 row5 36 37 38 39 40
Matrix arithmetic operations
Matrix supports mathematical operation like +, -, * ,/, which results also a matrix with same rows and columns.
> # matrix operations
> MA+MB
[,1] [,2] [,3] [,4] [,5]
[1,] 12 15 18 21 24
[2,] 18 21 24 27 30
> MA-MB
[,1] [,2] [,3] [,4] [,5]
[1,] -10 -11 -12 -13 -14
[2,] -6 -7 -8 -9 -10
> MA*MB
[,1] [,2] [,3] [,4] [,5]
[1,] 11 26 45 68 95
[2,] 72 98 128 162 200
> MA/MB
[,1] [,2] [,3] [,4] [,5]
[1,] 0.09090909 0.1538462 0.2 0.2352941 0.2631579
[2,] 0.50000000 0.5000000 0.5 0.5000000 0.5000000
Array
There are only two dimensions for a Matrix. To store data in more than two dimensions, array data type can be used.
The following is a diagram from Wikipedia about array of matrix:
Create array
Array can be created using function array(). If an array is created using dimension (m,n,k), the total element count is: m*n*k.
The signature of the function is:
array(data = NA, dim = length(data), dimnames = NULL)
> # Array
>
> vector<- c(1:30)
>
> column.names=c("col1","col2","col3")
> row.names=c("row1","row2")
> matrix.names=c("Matrix1","Matrix2","Matrix3","Matrix4","Matrix5")
>
> myArray <- array(vector,dim=c(2,3,5), dimnames = list(row.names,column.names, matrix.names))
>
> print(myArray)
, , Matrix1
col1 col2 col3
row1 1 3 5
row2 2 4 6
, , Matrix2
col1 col2 col3
row1 7 9 11
row2 8 10 12
, , Matrix3
col1 col2 col3
row1 13 15 17
row2 14 16 18
, , Matrix4
col1 col2 col3
row1 19 21 23
row2 20 22 24
, , Matrix5
col1 col2 col3
row1 25 27 29
row2 26 28 30
Accessing array
We can used index to access array data and matrix can be created from array.
> # Access array
>
> myArray[1,2,3]
[1] 15
>
> myArray[,,3]
col1 col2 col3
row1 13 15 17
row2 14 16 18
> class(myArray[,,3])
[1] "matrix"
>
> myArray[1,,3]
col1 col2 col3
13 15 17
>
> # Create matrices from array
> m1 <- myArray[,,3]
> m2 <- myArray[,,4]
> m1+m2
col1 col2 col3
row1 32 36 40
row2 34 38 42
Apply arithmetic calculations
Function apply() can be used to apply calculation across all array elements.
Here are some examples:
> # Apply
>
> # Use apply to calculate the sum of the rows across all the matrices.
> apply(myArray, c(1), sum)
row1 row2
225 240
> # Use apply to calculate the sum of the columns across all the matrices.
> apply(myArray, c(2), sum)
col1 col2 col3
135 155 175
> # Use apply to calculate the sum of the rows and columns across all the matrices.
> apply(myArray, c(1,2), sum)
col1 col2 col3
row1 65 75 85
row2 70 80 90
The second parameters controls whether calculate the sum of the rows, columns or both across all the matrices.
Factor
Factor is used to categorize the data and store it as levels. Factor can be created via function factor(). The following are some examples of factors:
- Male, Female
- West, East, North, South
- …
Factors are commonly used in data frames (will be covered in the following section). Some of the commonly used functions about factor are: factor(), levels() and is_factor().
The following are some examples about factor (script R14.Factors.R):
> # Factors
>
> d1<-c("Male","Female","Male","Male")
> d1f<-factor(d1)
> levels(d1f)
[1] "Female" "Male"
> length(d1f)
[1] 4
>
> # Change order
> d2f<-factor(d1, levels=c("Male","Female"))
> levels(d2f)
[1] "Male" "Female"
>
> # Change label
> d3f<-factor(d1, levels=c("F","M"))
> levels(d3f)
[1] "F" "M"
>
Data Frame
Data Frame is the most important data type for most of data workers using R. A data frame is a table or a two-dimensional array-like structure. Each column contains values of one variable, of which the values can be numeric, factor or character. Each row contains a set of values from each column.
The following table is a semantic data frame:
| CustomerID | CustomerName | DateOfBirth | Balance | |
| 1 | 10001 | John | 1990-01-01 | 600.11 |
| 2 | 10002 | Tom | 1991-01-01 | 1278.10 |
| 3 | 10003 | Lily | 2000-07-06 | 3000 |
Create data frame
Data frame can be created using function data.frame(). By default, character variables will be created as factors. Structure of the frame can be viewed via function str(). Statistical summary can be obtained via function summary().
> # Create data frames
>
> customer.data <- data.frame(
+ CustomerID = 10001:10003,
+ CustomerName = c('John','Tom','Lily'),
+ DateOfBirth = as.Date(c("1990-01-01","1991-01-01","2000-07-26")),
+ Balance = c(600.11,1278.10,3000),
+ stringsAsFactors = FALSE
+ )
>
> # Vector of date
> class(customer.data$DateOfBirth)
[1] "Date"
>
> # display the structure of data frame
> str(customer.data)
'data.frame': 3 obs. of 4 variables:
$ CustomerID : int 10001 10002 10003
$ CustomerName: chr "John" "Tom" "Lily"
$ DateOfBirth : Date, format: "1990-01-01" "1991-01-01" ...
$ Balance : num 600 1278 3000
>
> # statistic summary
> summary(customer.data)
CustomerID CustomerName DateOfBirth Balance
Min. :10001 Length:3 Min. :1990-01-01 Min. : 600.1
1st Qu.:10002 Class :character 1st Qu.:1990-07-02 1st Qu.: 939.1
Median :10002 Mode :character Median :1991-01-01 Median :1278.1
Mean :10002 Mean :1993-11-09 Mean :1626.1
3rd Qu.:10002 3rd Qu.:1995-10-14 3rd Qu.:2139.1
Max. :10003 Max. :2000-07-26 Max. :3000.0
Accessing and expanding data frame
Data can be extracted from data frame through column name and indices via function data.frame(). Columns can be dynamically added into existing data frame: dataFrame$variableName. Columns can be dropped: dataFrame$variableName <- c(). Rows can be added using function rbind(). Vectors can be combined into data frame using cbind().
The following are some examples (script R16.AccessingAndExpandDataFrame.R):
1) Extract only a few columns:
> # Extract only a few columns
> data.frame(customer.data$CustomerID, customer.data$Balance)
customer.data.CustomerID customer.data.Balance
1 10001 600.11
2 10002 1278.10
3 10003 3000.00
2) Extract only a few rows:
> # EXtract only a few rows > # extract the first row > customer.data[1,] CustomerID CustomerName DateOfBirth Balance 1 10001 John 1990-01-01 600.11 > # extract the second the the third rows > customer.data[2:3,] CustomerID CustomerName DateOfBirth Balance 2 10002 Tom 1991-01-01 1278.1 3 10003 Lily 2000-07-26 3000.0
3) Extract via column name:
> # extract via column name
> customer.data[2:3,c("CustomerID","Balance")]
CustomerID Balance
2 10002 1278.1
3 10003 3000.0
> customer.data[c("CustomerID","Balance")]
CustomerID Balance
1 10001 600.11
2 10002 1278.10
3 10003 3000.004) Extract via column index:
> # extract via column index > customer.data[2:3, c(1,2,4)] CustomerID CustomerName Balance 2 10002 Tom 1278.1 3 10003 Lily 3000.0
5) Add new column:
> # Add new column > customer.data$IsClosed <- c(FALSE,TRUE,FALSE) > View(customer.data)
The data frame looks like the following screenshot:
6) Drop column:
# Drop column customer.data$IsClosed <- c()
7) Add rows:
> # Add rows
> customer.data2 <- data.frame(
+ CustomerID = 10004:10006,
+ CustomerName = c('Lucy','Jack','Rose'),
+ DateOfBirth = as.Date(c("1997-01-01","1998-02-07","2001-07-12")),
+ Balance = c(700.11,27,1937.22),
+ stringsAsFactors = FALSE
+ )
> View(customer.data2)
>
> # Row bind
> customer.data.all <- rbind(customer.data, customer.data2)
> summary(customer.data.all)
CustomerID CustomerName DateOfBirth Balance
Min. :10001 Length:6 Min. :1990-01-01 Min. : 27.0
1st Qu.:10002 Class :character 1st Qu.:1992-07-02 1st Qu.: 625.1
Median :10004 Mode :character Median :1997-07-21 Median : 989.1
Mean :10004 Mean :1996-05-14 Mean :1257.1
3rd Qu.:10005 3rd Qu.:1999-12-14 3rd Qu.:1772.4
Max. :10006 Max. :2001-07-12 Max. :3000.0 Data frame customer.data2 looks like the following:
Function rbind was used to combine these two data frames to be one.
8) Column bind:
The following shows an example of creating data frame using cbind function:
> # Column bind
> CustomerID = 10001:10003
> CustomerName = c('John','Tom','Lily')
> DateOfBirth = as.Date(c("1990-01-01","1991-01-01","2000-07-26"))
> Balance = c(600.11,1278.10,3000)
>
> dataFrame <- cbind(CustomerID, CustomerName, DateOfBirth, Balance)
> print(dataFrame)
CustomerID CustomerName DateOfBirth Balance
[1,] "10001" "John" "7305" "600.11"
[2,] "10002" "Tom" "7670" "1278.1"
[3,] "10003" "Lily" "11164" "3000" Summary
Now you should be familiar with these frequently used data types in R. We will continue in this series to provide more usages about these advanced data types.