---
# System prepended metadata

title: DataCamp _ Introduction to R

---

# DataCamp _ Introduction to R

### class()
```python
// 檢查變數的型態
my_character <- "universe"
my_logical <- FALSE

class(my_chracter) will shows character
class(my_logical) will shows logical
```
---

## :penguin: Vector
:::info
Vectors are **one-dimension arrays** that can hold numeric data, character data, or logical data.
:::

### Naming a vector -- names() function
```python
// 使用names()

# Poker winnings from Monday to Friday
poker_vector <- c(140, -50, 20, -120, 240)

# The variable days_vector
days_vector <- c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")

names(poker_vector) <- days_vector

output:
it will lable days_vector on poker_vector
```

### Vector selection -- use []
:::info
To select elements of a vector **(and later matrices, data frames, …)**, you can use square brackets.

Except the single integer indexing you can use, you **can also use vector to do the index job** like the example below
:::
```python
poker_vector <- c(140, -50, 20, -120, 240)

poker_midweek <-  poker_vector[c(2,3,4)] # this can abbreviated to [2:4], not showing again afterward

output:
poker_midweek will shows -50 / 20 / -120
```

:::info
If the vector which you created is named by the way, **you can also index subvector by the name** like the example below:
:::
```python
poker_vector <- c(140, -50, 20, -120, 240)
days_vector <- c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")
names(poker_vector) <- days_vector

poker_start <- poker_vector[c("Monday", "Tuesday", "Wednesday")]

output:
poker_start will shows
    Monday   Tuesday Wednesday 
      140       -50        20 
```

:::info
If you got a logical vector after some operations, you can also index subvector by using it.
R knows what to do when you pass a logical vector in square brackets: **it will only select the elements that correspond to TRUE**
Example below:
:::
```python
poker_vector <- c(140, -50, 20, -120, 240)
days_vector <- c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")
names(poker_vector) <- days_vector

selection_vector <- poker_vector > 0 # Monday   Tuesday Wednesday  Thursday    Friday 
                                     # TRUE     FALSE      TRUE     FALSE      TRUE 

poker_winning_days <- poker_vector[selection_vector]

output:
poker_winning_days will shows
     Monday Wednesday    Friday 
      140        20       240 
```

---

## :penguin: Matrix
### Creat a matrix -- Matrix() function
```python
Matrix(1:9, byrow=TRUE, nrow=3)

# or creating in this way

new_hope <- c(460.998, 314.4)
empire_strikes <- c(290.475, 247.900)
return_jedi <- c(309.306, 165.8)

# Create box_office
box_office <- c(new_hope,empire_strikes,return_jedi)

# Construct star_wars_matrix
star_wars_matrix <- matrix(box_office,byrow=TRUE,nrow=3)
```

### Naming a matrix -- colnames() & rownames()
```python
# Vectors region and titles, used for naming
region <- c("US", "non-US")
titles <- c("A New Hope", "The Empire Strikes Back", "Return of the Jedi")

# Name the columns with region
colnames(star_wars_matrix) <- region

# Name the rows with titles
rownames(star_wars_matrix) <- titles
```

### Matrix operation functions
:::info

There are some kind of matrix operation functions like:
- **rowSums():** calculate the sum of each row. 
- **colSums():** calculate the sum of each column
- **cbind():** add a new column to a matrix. Ex: add a vector to a matrix

:warning: By the way, you can use ls() to check the variables which exists in the environment.

- **rbind():** like paste a matrix to another matrix by row direction
:::

---

## :penguin: factor
:::info
### What's a factor
Factor used to store categorical variables.
Ex. Limit the sex categories to "Male" or "Female".
:::
### Creat a factor -- factor() function
```python
# First we create a vector
sex_vector <- c("Male", "Female", "Female", "Male", "Male")

# Obviously, there are two categories, or in R-terms 'factor levels', at work here: "Male" and "Female".
# Convert sex_vector to a factor
factor_sex_vector <- factor(sex_vector)

# Print out factor_sex_vector
print(factor_sex_vector)

output:
[1] Male   Female Female Male   Male  
Levels: Female Male
```

### Categorical type
:::info
- **Nominal categorical variable:** is a categorical variable without an implied order. Meanwhile, you're not allowed to compare the elements in nominal type factor.
- **Ordinal categorical variable:** do have a natural ordering. :warning:Hint: If there's order between elements, in the factor() function you need to set the **order & levels** parameters.
:::

### Summarizing a factor
```python
# When it still a vector survey_vector <- c("M", "F", "F", "M", "M")
summary(survey_vector)

output:
Length     Class      Mode 
        5 character character 

# When the vector become a factor and use summary() function
factor_survey_vector <- factor(survey_vector)
levels(factor_survey_vector) <- c("Female", "Male")
summary(factor_survey_vector)

output:
Female   Male 
     2      3 
```

### Comparing elements in ordinal type factor
:::info
After you get the elements and save as a variable, you can simply compare with it by >... operators.
:::

---

## :penguin: DataFrame
:::info
Beforehand instruction of DataFrame like slicing are like vector or matrix, and further use some functions like **head()** or **str()**. But at slicing part, one of the different is you can use feature name as column index (Example below).
:::
```python
# Hardly know the position number of the column we want, we can instead use its name to pick it up.
# Select first 5 values of diameter column
planets_df[1:5,"diameter"]

output:
[1]  0.382  0.949  1.000  0.532 11.209
```

```python
# We can also select full elements from a feature by "$" sign.
rings_vector <- planets_df$rings

output:
[1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE
```

### Take Partial of the DataFrame (1)
:::info
DataFrame itself contains "rings" feature, and we take the value of "rings" feature alone saved as rings_vector.
If we use boolean like vector to be the index, R will take the **TRUE** option to be the index.
:::
```python
# Select all columns for planets with rings
planets_df[rings_vector, ]

output:
     name      type diameter rotation rings
5 Jupiter Gas giant   11.209     0.41  TRUE
6  Saturn Gas giant    9.449     0.43  TRUE
7  Uranus Gas giant    4.007    -0.72  TRUE
8 Neptune Gas giant    3.883     0.67  TRUE
```

### Take Partial of the DataFrame (2)
```python
# We use subset() to acheive the same result above
subset(planets_df, subset = rings) # this will have same result from above

subset(planets_df, subset = diameter < 1)

output:
     name               type diameter rotation rings
1 Mercury Terrestrial planet    0.382    58.64 FALSE
2   Venus Terrestrial planet    0.949  -243.02 FALSE
4    Mars Terrestrial planet    0.532     1.03 FALSE
```

### Sorting
```python
a <- c(100, 10, 1000)
order(a)

output:
[1] 2 1 3 # Seems like it returns the index value of elements from min to max.

a[order(a)] # reshuffle a vector

output:
[1]   10  100 1000
```

```python
# Use order() to create positions
positions <-  order(planets_df$diameter) # A vector store index value

# Use positions to sort planets_df
planets_df[positions,]
```

--- 

## :penguin: List
:::info
A list in R allows you to gather a variety of objects under one name (that is, the name of the list) in an ordered way. These objects can be matrices, vectors, data frames, even other lists, etc.
:::

### Creating a list -- list() function
```python
# Vector with numerics from 1 up to 10
my_vector <- 1:10 

# Matrix with numerics from 1 up to 9
my_matrix <- matrix(1:9, ncol = 3)

# First 10 elements of the built-in data frame mtcars
my_df <- mtcars[1:10,]

# Construct list with these different elements:
my_list <- list(my_vector, my_matrix, my_df)

output:
[[1]]: vector [[2]]: matrix [[3]]: dataframe
```

### Nameing your list
:::info
:warning: To avoid not knowing the components of your list.
:::
```python
# First way
my_list <- list(name1 = your_comp1, 
                name2 = your_comp2)

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

# Second way (Same as we name a vector, using vector include the name and names() function)
my_list <- list(your_comp1, your_comp2) # Create your list
names(my_list) <- c("name1", "name2") # Name your list
```

### Selecting elements from a list
```python
# We already have shining_list contains vector matrix and dataframe

# Select the component in the list
shining_list[[2]]
or
shining_list[["actors"]]
shining_list$actors

# Select specific elements out of these components
shining_list[["actors"]][2]
```









