Libraries:

The Tidyverse
includes several popular R packages, such as:
dplyr: for data manipulation and analysis

ggplot2: for data visualization

tidyr: for data transformation and reshaping

readr and writexl: for data import and export

purrr: for functional programming and data manipulation

stringr: for string manipulation

forcats: for categorical data manipulation

The MDSR Library :

Explore the MDSR datasets, using the data() function
Use the MDSR functions, such as mdsr_clean() and mdsr_visualize()
Take advantage of the MDSR utilities, such as mdsr_import() and mdsr_export()
Work through the MDSR course and book series, using the library to support your
learning

Lubridate is an R package that provides a set of functions for working with dates
and Tidyverse: This is a collection of packages that provide a consistent and intuitive
way of working with data in R. The core packages in the tidyverse are:

 Tidyverse: This is a collection of packages that provide a consistent and intuitive way of
working with data in R. The core packages in the tidyverse are:
 dplyr: For data manipulation and filtering
 tidyr: For data transformation and reshaping
 ggplot2: For data visualization
 readr: For reading and parsing data files
 lubridate: For working with dates and times

Other Important Packages:

 stringr: For string manipulation and text analysis

 magrittr: For piping operations together
 pacman: For package management and installation

Key Functions to Know:

 dplyr:
 filter(): For filtering data
  select(): For selecting specific columns
 mutate(): For creating new columns
 group_by(): For grouping data
 summarise() : For summarizing data
 glimpse is a function from the dplyr package, which is part of the tidyverse. It provides a
concise summary of a data frame, similar to str() or summary()
 tidyr:
 pivot_longer(): For converting data from wide to long format
 pivot_wider() : For converting data from long to wide format
 drop_na(): For removing missing values
 lubridate:
 year(): For extracting the year from a date
 month(): For extracting the month from a date
 day(): For extracting the day from a date
 ggplot2:
 ggplot(): For creating visualizations
 aes(): For mapping variables to visual properties
 geom_point(): For creating scatter plots
 geom_bar(): For creating bar charts
 nycflights13 Package? flights: all flights that departed from NYC in 2013
 weather: hourly meterological data for each airport
 planes: construction information about each plane
 airports: airport names and locations
 airlines: translation between two-letter carrier codes and na
Functions :
filter(): Select specific rows or columns based on conditions.

arrange(): Sort data in ascending or descending order.

group_by(): Divide data into groups based on one or more variables.
summarise(): Calculate summary statistics for each group.
mutate(): Add new columns to the data.

select(): Select specific columns from the data.

 select is for selecting columns

 filter is for selecting rows based on conditions
note that in R, you need to use the & operator to combine multiple conditions,
rather than chaining them together with < and >

Mutate:
ymd(): parses a character string into a Date object
mdy(): parses a character string into a Date object (month-day-year
format)
dmy(): parses a character string into a Date object (day-month-year
format)
interval(): creates an interval object representing a specific time
span
duration(): creates a duration object representing a specific length
of time
period(): creates a period object representing a specific length of
time

inner_join():inner_join(table1, table2, by = "id")

left_join()
full_join()
nrow(flights)

glimpse is a function from the dplyr package, which is part of the tidyverse. It provides a
concise summary of a data frame, similar to str() or summary()

Other methods and functions:

class(A),str(A) Finding the Type of Output
head(A)// summary(A)//glimpse ()
package_name::function_name
?function_name or help(function_name)
As.integer or ……..
Tribble // make table
Paste() for concate: paste is a function that concatenates strings or vectors of strings
into a single string.
n_distinct
sum(!is.na(name))
sorted()
*** important difference between sort and arrange :
As you can see, the arrange function returns a new data frame with the rows sorted in
ascending order by yearID. The output is a data frame with the same structure as the original
data frame, but with the rows rearranged according to the sorting criteria.
As you can see, the sort function returns a sorted vector, not a data frame. The output is a
single vector with the sorted values of the yearID column.
df <- data.frame(yearID = c(1992, 1990, 1991, 1992, 1990, 1991),
2 teamID = c(10, 10, 10, 10, 10, 10),
3 playerID = c(123, 123, 123, 123, 123, 123))
4
5sorted_df <- sort(df, by = "yearID")
6 sorted_df <- df %>% arrange(yearID)
7sorted_df

Out put sort : [1] 1990 1990 1991 1991 1992 1992

Output of arrange:

yearID teamID playerID

21 1990 10 123
32 1990 10 123
43 1991 10 123
54 1991 10 123
65 1992 10 123
76 1992 10 123
sum(): This function calculates the sum of a numeric vector. It's not
suitable for counting the number of characters in a string, as you've
noticed.
length(): This function returns the number of elements in a vector,
including strings. However, it doesn't count the number of characters
within a string.
nchar(): This function returns the number of characters in a string.
It's what you need to count the number of characters in a string, like
the name column in your example.
nzchar()

strsplit()

The syntax is x %in% y, where x is the vector or column you want to check, and y is the vector
or column you want to check against. %in% can be used with both columns and rows,
depending on the context

Details of making Table:

1: Using the data.frame function:
# Create a table with 3 columns and 4 rows

table <- data.frame(

Name = c("John", "Mary", "David", "Emily"),

Age = c(25, 31, 42, 28),

Country = c("USA", "Canada", "UK", "Australia")

)
# Print the table

Table

Method 2: Using the tibble function

# Create a table with 3 columns and 4 rows

library(tibble)
table <- tibble(
Name = c("John", "Mary", "David", "Emily"),
Age = c(25, 31, 42, 28),
Country = c("USA", "Canada", "UK", "Australia")
)
# Print the table
Table

Method 3: Using a matrix

# Create a matrix with 3 columns and 4 rows

matrix <- matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), nrow = 4, ncol = 3)

# Convert the matrix to a table

table <- as.data.frame(matrix)

# Print the table

table

Method 4|: Reading in data from a file

If you have data in a file (e.g., CSV, Excel, or text file), you can read it into R using various functions
suc # Read in a CSV file

2table <- read.csv("data.csv")

4# Print the table

5tableh as read.csv, read.table, or read_excel. Here's an example

Conditional operators :

Loops and if condition:

List :

Vector:

Matrix:

Dataframe:
Create data frame:
df <- data.frame(
column1 = c(values),
column2 = c(values),
...
)
Functionns on dataframe
str(df)- see in console output

print(df) see output in console like a table and tidy

sample_n() function-> from the dplyr package. This function allows you to take a
random sample of rows from a dataframe.
Or
Alternatively, you can use the sample() function to take a random sample of
rows. Here's an example:
# Take a random sample of 3 rows
2Random_subset <- df[sample(nrow(df), 3), ]
4# Print the random subset
5print(Random_subset)
# Create a dataframe
3df <- data.frame(name = c("Welcome", "to", "Geeks", "for", "Geeks"),
4 year = c(10, 51, 19, 126, 99),
5 length = c(40, NA, NA, 100, 95),
6 education = c("yes", "yes", "no", "no", "yes"))
7
8# Take a random sample of 3 rows
9Random_subset <- df %>% sample_n(3)
10
11# Print the random subset
12print(Random_subset)

Column:
names(df) or str(df) to see the column names
access specific columns in a dataframe using the $ operator or the [[ ]] :
df$year or df[["year"]]

Removing a column: df %>% select(-year) or df$year <- NULL

Converting a column to a string: df$year <- as.character(df$year)

Applying a function to a specific column : To apply a function to a specific

column, you can use the mutate function from the dplyr package.

df %>% mutate(n_sqrt = sqrt(n)) -----

mutate(prop = prop * 10000000/1000000) -- result in column no create new column
or you can use you can use the $ operator to access the column and apply the function
directly, like this: df$n <- sqrt(df$n)

Finding columns with NaN values: sapply(df, function(x) any(is.nan(x)))

Finding duplicate values in a column: df %>%

2 group_by(name) %>%
3 filter(n() > 1)

ROW :
 **access the first row of the df dataframe df[1,] access first column df[,1]

------------------------------------------------------------------------------------------------------------

Adding a row : r bind

new_row <- c(2022, "M", "John", 50, 0.0001)

2df <- rbind(df, new_row)

Deleting a row : function slice from the dplyr : The slice function takes a
dataframe and a vector of row indices as arguments. df <- df %>% slice(-1) all rows except first
row

Or : Alternatively, you can use the [- operator to remove the first row, like df <- df[-1,]

Changing a row :
To change a row in a dataframe, you can use the [ operator to access the row and
assign new values to it.For example, to change the first row of the df dataframe, you can
use:

df[1,] <- c(2022, "M", "John", 50, 0.0001)

Applying a function to a specific row :

you can use the rowwise function from the dplyr package. The rowwise function allows
you to apply a function to each row of a dataframe.

df %>% rowwise() %>% mutate(sum = sum(n, prop))

1. rowwise():
 This is a function from the dplyr package that groups the dataframe by rows.
 When you use rowwise(), each row of the dataframe is treated as a separate group.
 This is similar to using apply(df, 1, ...) in base R, but rowwise() is more concise
and efficient.
 rowwise() and mutate() functions, the code applies the sum() function to each row of the
dataframe, and the result is added as a new column sum to the dataframe.

df$sum <- apply(df[,c("n", "prop")], 1, sum) :

 The apply function takes three arguments:
 The first argument is the dataframe or matrix that we want to apply the function to. In
this case, it's df[,c("n", "prop")].
 The second argument is the MARGIN argument, which specifies whether we want to
apply the function to rows (1) or columns (2). In this case, we're using 1, which means
we want to apply the function to each row.
 The third argument is the function that we want to apply. In this case, it's
the sum function.
Finding rows with NaN values: df[is.nan(df$prop), ] This will return all rows
where the prop column has NaN values.

Finding duplicate rows: df[duplicated(df) | duplicated(df, fromLast = TRUE), ] To find

duplicate rows, we can use the duplicated() function:

Alternatively, we can use the group_by() and filter() functions from

the dplyr package:

library(dplyr)
2df %>%
3 group_by(year, sex, name, n, prop) %>%
4 filter(n() > 1)

operator.Class:

Seq:

Function Armethic:

Operators: