R Data Frame
• A data frame is a two-dimensional data structure which can
store data in tabular format.
• Data frames have rows and columns and each column can be
a different vector.
• Different vectors can be of different data types.
Characteristics of a data frame.
•The columns name should be non-empty.
•The rows name should be unique.
•The data which is stored in a data frame can be a factor,
numeric, or character type.
•Each column contains the same number of data items.
Create a Data Frame in R
Use the data.frame() function to create a Data Frame.
The syntax of the data.frame() function is
dataframe1 <- data.frame(
first_col = c(val1, val2, ...),
second_col = c(val1, val2, ...), ... )
Create a data frame
dataframe1 <- data.frame (
Name = c("Juan", "Alcaraz", "Simantha"),
Age = c(22, 15, 19),
Vote = c(TRUE, FALSE, TRUE)
)
print(dataframe1)
Access Data Frame Column
There are different ways to extract columns from a data frame. We can use [ ],
[[ ]], or $ to access specific column of a data frame in R
Combine Data Frames
In R, we use the rbind() and the cbind() function to combine two
data frames together.
rbind() - combines two data frames vertically
cbind() - combines two data frames horizontally
Combine Vertically
Using rbind()
Combine Horizontally
Using cbind()
Length of a Data Frame in R
R Arrays
Compared to matrices, arrays can have more than two dimensions.
We can use the array() function to create an array, and the dim parameter to
specify the dimensions:
Arrays are the R data objects which can store data in more than two dimensions.
For example − If we create an array of dimension (2, 3, 4) then it creates 4
rectangular matrices each with 2 rows and 3 columns. Arrays can store only data
type.
R Arrays
R Array Syntax
There is the following syntax of R arrays:
array_name <- array(data, dim= (row_size, column_size, matrices, dim_names))
Dim_names : Default value = NULL.
Create The Array
1.In the first step, we will create two vectors of different lengths.
2.Once our vectors are created, we take these vectors as inputs
to the array.
# create two 2 by 3 matrix
array1 <- array(c(1:12), dim = c(2,3,2))
print(array1)
Access Array Elements
We use the vector index operator [ ] to access specific elements of an array in R.
The syntax to access an array element is
array[n1, n2, mat_level]
array1 <- array(c(1:12), dim = c(2,3,2))
print(array1)
# access element at 1st row, 3rd column of 2nd matrix
cat("\nDesired Element:", array1[1, 3, 2])
Naming rows and columns
#Creating two vectors of different lengths
vec1 <-c(1,3,5)
vec2 <-c(10,11,12,13,14,15)
#Initializing names for rows, columns and matrices
col_names <- c("Col1","Col2","Col3")
row_names <- c("Row1","Row2","Row3")
matrix_names <- c("Matrix1","Matrix2")
#Taking the vectors as input to the array
res <-
array(c(vec1,vec2),dim=c(3,3,2),dimnames=list(row_names,col_names,matrix_names))
print(res)
Access Entire Row or Column
In R, we can also access the entire row or column based on the value
passed inside [].
[c(n), ,mat_level] - returns the entire element of the nth row.
[ ,c(n), mat_level] - returns the entire element of the nth column.
Access Entire Row or Column
# create a two 2 by 3 matrix
array1 <- array(c(1:12), dim = c(2,3,2))
print(array1)
# access entire elements at 2nd column of 1st matrix
cat("\n2nd Column Elements of 1st matrix:",
array1[,c(2),1])
# access entire elements at 1st row of 2nd matrix
cat("\n1st Row Elements of 2nd Matrix:", array1[c(1), ,2])
R Strings
A string is a sequence of characters.
message1 <- 'Hola Amigos'
print(message1)
message2 <- "Welcome to Programiz"
print(message2)
String Operations in R
• Find the length of a string
• Join two strings
• Compare two strings
• Change the string case
1. Find Length of R String
We use the nchar() method to find the length of a string.
message1 <- "Programiz"
# use of nchar() to find length of message1
nchar(message1) # 9
String Operations in R
2. Join Strings Together
In R, we can use the paste() function to join two or more strings together.
Output
[1] Programiz Pro
message1 <- "Programiz"
message2 <- "Pro"
# use paste() to join two strings
paste(message1, message2)
String Operations in R
3. Compare Two Strings in R Programming
We use the == operator to compare two strings. If two strings are equal, the operator returns
TRUE. Otherwise, it returns FALSE
message1 <- "Hello, World!"
message2 <- "Hola, Mundo!"
message3 <- "Hello, World!" Output
# compare message1 and message2 [1] FALSE
print(message1 == message2) [1] TRUE
# compare message1 and message3
print(message1 == message3)
String Operations in R
4. Change Case of R String toupper() - convert string to uppercase
tolower() - convert string to lowercase
message <- "R Programming"
Output
# change string to uppercase
Uppercase: R PROGRAMMING
message_upper <- toupper(message)
Lowercase: r programming
cat("Uppercase:", message_upper)
# change string to lowercase
message_lower <- tolower(message)
cat("\nLowercase:", message_lower)
Control Structures in R
Control Structures in R
Control Structures can be divided into three categories.
1.Conditional statements.
2.Looping Statements
3.Jump Statements
1.Conditional statements
if statement
The conditional if statement is used to test an expression. If
the test_expression is TRUE, the statement gets executed. But
if it’s FALSE, nothing happens.
if (test_expression)
{
statement
}
Example:Check for Positive Number
if-else Condition in R
The conditional if...else statement is used to test an expression similar
to the if statement. However, rather than nothing happening if the
test_expression is FALSE, the else part of the function will be
evaluated.
if (test_expression)
{
statement
}
else
{
statement
}
Val1<-10
val2 <-5
if (val1 > val2)
{
print("Value 1 is greater than Value 2")
} else if (val1 < val2)
{
print("Value 1 is less than Value 2")
}
x <- c(8, 3, -2, 5)
if(any(x < 0))
{
print("x contains negative numbers")
}
else
{
print("x contains all positive numbers")
}
[1] "x contains negative numbers"
If-Else if Ladder
If-Else statements can be chained using If-Else if Ladder
# Create vector quantity
Syntax: quantity <- 10
if(condition) if (quantity <20)
{ {
Statement1
print('Not enough for today')
}
else if } else if (quantity > 20 &quantity <= 30)
{ {
Statement 2 print('Average day')
} } else Output:
else
{ ## [1] "Not enough for today"
{
Statement 3 print('What a great day!')
} }
Switch:
1. A switch statement allows a variable to be tested for equality against a list of values.
2. Each value is called a case, and the variable being switched on is checked for each
case.
Syntax:
switch(Expression, "Option 1", "Option 2", "Option
3" ................................."OptionN")
Example: Print Department names using Switch
2.Looping Statements
While Loop:
Description: The While loop executes the same code again and again until a stop condition is met.
Syntax:
Example:
Out Put:
while(condition)
{ i <- 1 [1] 1
Statement while (i < 6) [1] 2
} [1] 3
{ [1] 4
[1] 5
print(i)
i <- i + 1
}
For Loop in R
1. It is used to iterate over a collection of objects, such as a vector, a list, a
matrix, or a dataframe, and apply the same set of operations on each
item of a given data structure.
2. sequence is a collection of objects (e.g., a vector)
3. the keywords for and in are compulsory, as well as the parenthesis
The basic syntax of a for-loop in R is the following:
for (variable in sequence)
{
expression
}
For Loop in R
A for loop is used for iterating over a sequence:
Example: Example: Example:
for (x in 1:10) Print every item in a list: values <- c(1,2,3,4,5)
{ for(id in 1:4)
print(x) fruits <- list("apple", "banana", "cherry") {
} print(values[id])
for (x in fruits) {
print(x)
}
}
[1] 1
[1] "apple" [1] 2
[1] "banana" [1] 3
[1] "cherry" [1] 4
repeat loop
1. A repeat loop is used to iterate over a block of code multiple number of times.
2. There is test expression in a repeat loop to end or exit the loop
3. use the break function to exit the loop. Failing to do so will result into an
infinite loop.
Syntax:
repeat
{
Commands
If(condition)
Break
}
repeat loop
x=1
# Repeat loop
repeat { Output:
print(x) [1] 1
[1] 2
# Break statement to terminate if x > 4 [1] 3
if (x > 4) { [1] 4
break [1] 5
}
# Increment x by 1
x=x+1
}
3.Jump Statements
Break :
Terminates the loop statement and transfers execution to the statement
immediately following the loop.
Syntax: break
Example :print numbers till 5
next Statement in R
1. next jumps to the next cycle without completing a particular iteration.
2. Next statement enables to skip the current iteration of a loop without
terminating it.
The syntax of the next statement is:
if (test_condition)
{
next
}
In this example, the for loop will iterate for each element in x; however, when it
gets to the element that equals 3 it will skip the for loop execution of printing the
element and simply jump to the next iteration.
x <- 1:5
for (i in x)
{
if (i == 3)
{
next
}
print(i)
}
## [1] 1
## [1] 2
## [1] 4
## [1] 5
R - Functions
A function is a set of statements organized together to perform a
specific task. R has a large number of in-built functions and the user
can create their own functions.
An R function is created by using the keyword function.
Syntax:
function_name <- function(arg_1, arg_2, ...)
{
Function body
}
Components of Functions
Function Types
Creating a Function Call a Function
To create a function, use the function() keyword:
To call a function, use the function name
followed by parenthesis, like my_function():
Example:
Example
my_function <- function()
{ my_function <- function()
print("Hello World!") {
} print("Hello World!")
}
my_function() # call the function named
Function with Arguments:
Function with Default Argument
LOOPING FUNCTIONS IN R
apply() function
apply() takes Data frame or matrix as an input and gives output in vector, list or
array. Apply function in R is primarily used to avoid explicit uses of loop
constructs. It is the most basic of all collections can be used over a matrice.
This function takes 3 arguments:
apply(X, MARGIN, FUN)
Here:
-x: an array or matrix
-MARGIN: take a value or range between 1 and 2 to define where to apply the function:
-MARGIN=1`: the manipulation is performed on rows
-MARGIN=2`: the manipulation is performed on columns
-MARGIN=c(1,2)` the manipulation is performed on rows and columns
-FUN: tells which function to apply. Built functions like mean, median, sum, min, max and even user-defined
functions can be applied>
m1 <- matrix(C<-(1:10),nrow=5, ncol=6)
m1
a_m1 <- apply(m1, 2, sum)
a_m1
Output:
lapply()
Definition: Loop over a list and evaluate a function on each element
Syntax:
lapply(X, FUN)
Arguments:
-X: A vector or an object
-FUN: Function applied to each element
of x
sapply()
Definition : same as lapply but try to simplify the result .
Syntax:
sapply(X, FUN)
Arguments:
-X: A vector or an object
-FUN: Function applied to each element
of x
sapply()
# create sample data
sample_data<- data.frame( x=c(1,2,3,4,5,6),y=c(3,2,4,2,34,5))
print( "original data:")
sample_data
# apply sapply() function
print("data after sapply():")
sapply(sample_data, max)
tapply()
We use the tapply() function for calculating summary statistics (such as mean, median,
min, max, sum, etc.) for different factors (i.e., categories). It has the following syntax:
salaries <- c(80000, 62000, 113000, 68000, 75000, 79000,
112000, 118000, 65000, 117000)
jobs <- c('DS', 'DA', 'DE', 'DA', 'DS', 'DS', 'DE', 'DE', 'DA', 'DE')
Syntax:
print(tapply(salaries, jobs, mean))
tapply(X, INDEX, FUN)
DA DE DS
65000 115000 78000
