\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. <NA>\n",
"2. <NA>\n",
"3. <NA>\n",
"4. <NA>\n",
"5. <NA>\n",
"6. <NA>\n",
"7. <NA>\n",
"8. <NA>\n",
"9. <NA>\n",
"\n",
"\n"
],
"text/plain": [
"[1] NA NA NA NA NA NA NA NA NA"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"group.factor / 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.3.2 - Handy functions\n",
"\n",
"- `levels`: it yields the different levels.\n",
"- `nlevels`: it yields the count of levels."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- '1'
\n",
"\t- '2'
\n",
"\t- '3'
\n",
"
\n"
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item '1'\n",
"\\item '2'\n",
"\\item '3'\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. '1'\n",
"2. '2'\n",
"3. '3'\n",
"\n",
"\n"
],
"text/plain": [
"[1] \"1\" \"2\" \"3\""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"3"
],
"text/latex": [
"3"
],
"text/markdown": [
"3"
],
"text/plain": [
"[1] 3"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"levels(group.factor)\n",
"nlevels(group.factor)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"With the `levels` function we can also redefine the labels of the factors"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- Label1
\n",
"\t- Label1
\n",
"\t- Label1
\n",
"\t- Label2
\n",
"\t- Label2
\n",
"\t- Label2
\n",
"\t- Label3
\n",
"\t- Label3
\n",
"\t- Label3
\n",
"
\n",
"\n",
"\n",
"\t\n",
"\t\tLevels:\n",
"\t
\n",
"\t\n",
"\t\t- 'Label1'
\n",
"\t\t- 'Label2'
\n",
"\t\t- 'Label3'
\n",
"\t
\n",
" "
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item Label1\n",
"\\item Label1\n",
"\\item Label1\n",
"\\item Label2\n",
"\\item Label2\n",
"\\item Label2\n",
"\\item Label3\n",
"\\item Label3\n",
"\\item Label3\n",
"\\end{enumerate*}\n",
"\n",
"\\emph{Levels}: \\begin{enumerate*}\n",
"\\item 'Label1'\n",
"\\item 'Label2'\n",
"\\item 'Label3'\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. Label1\n",
"2. Label1\n",
"3. Label1\n",
"4. Label2\n",
"5. Label2\n",
"6. Label2\n",
"7. Label3\n",
"8. Label3\n",
"9. Label3\n",
"\n",
"\n",
"\n",
"**Levels**: 1. 'Label1'\n",
"2. 'Label2'\n",
"3. 'Label3'\n",
"\n",
"\n"
],
"text/plain": [
"[1] Label1 Label1 Label1 Label2 Label2 Label2 Label3 Label3 Label3\n",
"Levels: Label1 Label2 Label3"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"levels(group.factor) <- c(\"Label1\",\"Label2\", \"Label3\")\n",
"\n",
"group.factor"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.4 - Lists\n",
"\n",
"A list is an R-object that can contain **many different types** of elements inside it like vectors, functions and even another list inside it. It is a very important data structure in R."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.4.1 - Initialization\n",
"\n",
"List can be initialized with the function `list` as follows in this example:"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- $age
\n",
"\t\t- 37
\n",
"\t- $married
\n",
"\t\t- TRUE
\n",
"\t- $parents
\n",
"\t\t\n",
"\t- 'Joseba'
\n",
"\t- 'Edita'
\n",
"
\n",
"
\n"
],
"text/latex": [
"\\begin{description}\n",
"\\item[\\$age] 37\n",
"\\item[\\$married] TRUE\n",
"\\item[\\$parents] \\begin{enumerate*}\n",
"\\item 'Joseba'\n",
"\\item 'Edita'\n",
"\\end{enumerate*}\n",
"\n",
"\\end{description}\n"
],
"text/markdown": [
"$age\n",
": 37\n",
"$married\n",
": TRUE\n",
"$parents\n",
": 1. 'Joseba'\n",
"2. 'Edita'\n",
"\n",
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
"$age\n",
"[1] 37\n",
"\n",
"$married\n",
"[1] TRUE\n",
"\n",
"$parents\n",
"[1] \"Joseba\" \"Edita\" \n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"Javi <- list( age = 37, married = TRUE, parents = c(\"Joseba\",\"Edita\"))\n",
"Javi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, here this list contains three variables of different kinds (and sizes)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Practice: In the same as we've just seen, create list that contains a variable \"name\" with your name, \"weight\" with your weight, \"films\" with your the name of your favourites films (as a vector), and \"soccer_fan\" as TRUE or FALSE if you like soccer.
"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"#Your answer here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.4.2 - Accessing lists\n",
"\n",
"One can access list variables using the operator \"$\" as follows:"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"37"
],
"text/latex": [
"37"
],
"text/markdown": [
"37"
],
"text/plain": [
"[1] 37"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"TRUE"
],
"text/latex": [
"TRUE"
],
"text/markdown": [
"TRUE"
],
"text/plain": [
"[1] TRUE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n",
"\t- 'Joseba'
\n",
"\t- 'Edita'
\n",
"
\n"
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item 'Joseba'\n",
"\\item 'Edita'\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. 'Joseba'\n",
"2. 'Edita'\n",
"\n",
"\n"
],
"text/plain": [
"[1] \"Joseba\" \"Edita\" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# This accesses my age\n",
"Javi$age\n",
"# this tells whether I am married or not\n",
"Javi$married\n",
"# this shows the names of my parents\n",
"Javi$parents"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.4.3 - Modifying lists\n",
"\n",
"We can again use the operator \"$\" to edit an entry value, or add a new entry. For example:"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- $age
\n",
"\t\t- 37.5
\n",
"\t- $married
\n",
"\t\t- TRUE
\n",
"\t- $parents
\n",
"\t\t\n",
"\t- 'Joseba'
\n",
"\t- 'Edita'
\n",
"
\n",
"- $height
\n",
"\t\t- 177
\n",
"
\n"
],
"text/latex": [
"\\begin{description}\n",
"\\item[\\$age] 37.5\n",
"\\item[\\$married] TRUE\n",
"\\item[\\$parents] \\begin{enumerate*}\n",
"\\item 'Joseba'\n",
"\\item 'Edita'\n",
"\\end{enumerate*}\n",
"\n",
"\\item[\\$height] 177\n",
"\\end{description}\n"
],
"text/markdown": [
"$age\n",
": 37.5\n",
"$married\n",
": TRUE\n",
"$parents\n",
": 1. 'Joseba'\n",
"2. 'Edita'\n",
"\n",
"\n",
"\n",
"$height\n",
": 177\n",
"\n",
"\n"
],
"text/plain": [
"$age\n",
"[1] 37.5\n",
"\n",
"$married\n",
"[1] TRUE\n",
"\n",
"$parents\n",
"[1] \"Joseba\" \"Edita\" \n",
"\n",
"$height\n",
"[1] 177\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Let's modify my age\n",
"Javi$age<- 37.5\n",
"# Let's add my height as a new entry (in cms)\n",
"Javi$height<- 177\n",
"\n",
"Javi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5.5 - Data Frames\n",
"\n",
"Data frames are possibly the most important data structures in R. \n",
"\n",
"Why is it so important? Because it's how usually most tabular data are represented, and when you work with data, you'll likely have this form of data.\n",
"\n",
"A data frame is a special type of list where every entry has same length, that is, a data frame is a like \"rectangular\" list."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.5.1 - Intialization\n",
"\n",
"Data frames are initialized like lists, but using the function `data.frame` instead."
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"| age | gender | score |
|---|
\n",
"\n",
"\t| 17 | female | 12 |
\n",
"\t| 19 | female | 10 |
\n",
"\t| 21 | male | 11 |
\n",
"\t| 37 | female | 15 |
\n",
"\t| 22 | male | 12 |
\n",
"\t| 35 | female | 10 |
\n",
"\t| 18 | male | 11 |
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lll}\n",
" age & gender & score\\\\\n",
"\\hline\n",
"\t 17 & female & 12 \\\\\n",
"\t 19 & female & 10 \\\\\n",
"\t 21 & male & 11 \\\\\n",
"\t 37 & female & 15 \\\\\n",
"\t 22 & male & 12 \\\\\n",
"\t 35 & female & 10 \\\\\n",
"\t 18 & male & 11 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| age | gender | score |\n",
"|---|---|---|\n",
"| 17 | female | 12 |\n",
"| 19 | female | 10 |\n",
"| 21 | male | 11 |\n",
"| 37 | female | 15 |\n",
"| 22 | male | 12 |\n",
"| 35 | female | 10 |\n",
"| 18 | male | 11 |\n",
"\n"
],
"text/plain": [
" age gender score\n",
"1 17 female 12 \n",
"2 19 female 10 \n",
"3 21 male 11 \n",
"4 37 female 15 \n",
"5 22 male 12 \n",
"6 35 female 10 \n",
"7 18 male 11 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"age <- c(17, 19, 21, 37, 22, 35, 18)\n",
"gender<-factor(c(\"female\", \"female\", \"male\", \"female\", \"male\", \"female\", \"male\"))\n",
"score <- c(12, 10, 11, 15, 12, 10, 11)\n",
"\n",
"my.dataframe <- data.frame ( age=age, gender=gender, score=score )\n",
"\n",
"my.dataframe"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we said a few moments ago, data frames are usually used to represent tabular data. This is the kind of data you are usually given in the form of an external file. Data contained in external files can be imported into R in the form of data frames using the functions `read.csv` and `read.table`:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Practice: The dataset below contains 3 measures of ability: SATV, SATQ, ACT (from Arel-Bundock V (2023). *Rdatasets: A collection of datasets originally distributed in various R packages.*). Then, use the function read.csv to load it (Just pass the whole url as an argument to this function). Save the result to a variable called \"dat\", for example.
\n",
"\n",
"url dataset: https://vincentarelbundock.github.io/Rdatasets/csv/psych/sat.act.csv"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Your code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.5.2 - Access and modifying\n",
"\n",
"Like with lists, the operator \"$\" is used to access and modify data frames"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- 17
\n",
"\t- 19
\n",
"\t- 21
\n",
"\t- 37
\n",
"\t- 22
\n",
"\t- 35
\n",
"\t- 18
\n",
"
\n"
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item 17\n",
"\\item 19\n",
"\\item 21\n",
"\\item 37\n",
"\\item 22\n",
"\\item 35\n",
"\\item 18\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. 17\n",
"2. 19\n",
"3. 21\n",
"4. 37\n",
"5. 22\n",
"6. 35\n",
"7. 18\n",
"\n",
"\n"
],
"text/plain": [
"[1] 17 19 21 37 22 35 18"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# This shows the age variable\n",
"my.dataframe$age"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"| age | gender | score | var1 |
|---|
\n",
"\n",
"\t| 17 | female | 12 | 1 |
\n",
"\t| 19 | female | 10 | 1 |
\n",
"\t| 21 | male | 11 | 1 |
\n",
"\t| 37 | female | 15 | 1 |
\n",
"\t| 22 | male | 12 | 1 |
\n",
"\t| 35 | female | 10 | 1 |
\n",
"\t| 18 | male | 11 | 1 |
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|llll}\n",
" age & gender & score & var1\\\\\n",
"\\hline\n",
"\t 17 & female & 12 & 1 \\\\\n",
"\t 19 & female & 10 & 1 \\\\\n",
"\t 21 & male & 11 & 1 \\\\\n",
"\t 37 & female & 15 & 1 \\\\\n",
"\t 22 & male & 12 & 1 \\\\\n",
"\t 35 & female & 10 & 1 \\\\\n",
"\t 18 & male & 11 & 1 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| age | gender | score | var1 |\n",
"|---|---|---|---|\n",
"| 17 | female | 12 | 1 |\n",
"| 19 | female | 10 | 1 |\n",
"| 21 | male | 11 | 1 |\n",
"| 37 | female | 15 | 1 |\n",
"| 22 | male | 12 | 1 |\n",
"| 35 | female | 10 | 1 |\n",
"| 18 | male | 11 | 1 |\n",
"\n"
],
"text/plain": [
" age gender score var1\n",
"1 17 female 12 1 \n",
"2 19 female 10 1 \n",
"3 21 male 11 1 \n",
"4 37 female 15 1 \n",
"5 22 male 12 1 \n",
"6 35 female 10 1 \n",
"7 18 male 11 1 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# This adds an entry called \"var1\", with the same value in all its elements \n",
"my.dataframe$var1<-1\n",
"my.dataframe"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"| age | gender | score | var1 | var2 |
|---|
\n",
"\n",
"\t| 17 | female | 12 | 1 | 1 |
\n",
"\t| 19 | female | 10 | 1 | 2 |
\n",
"\t| 21 | male | 11 | 1 | 3 |
\n",
"\t| 37 | female | 15 | 1 | 4 |
\n",
"\t| 22 | male | 12 | 1 | 5 |
\n",
"\t| 35 | female | 10 | 1 | 6 |
\n",
"\t| 18 | male | 11 | 1 | 7 |
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lllll}\n",
" age & gender & score & var1 & var2\\\\\n",
"\\hline\n",
"\t 17 & female & 12 & 1 & 1 \\\\\n",
"\t 19 & female & 10 & 1 & 2 \\\\\n",
"\t 21 & male & 11 & 1 & 3 \\\\\n",
"\t 37 & female & 15 & 1 & 4 \\\\\n",
"\t 22 & male & 12 & 1 & 5 \\\\\n",
"\t 35 & female & 10 & 1 & 6 \\\\\n",
"\t 18 & male & 11 & 1 & 7 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| age | gender | score | var1 | var2 |\n",
"|---|---|---|---|---|\n",
"| 17 | female | 12 | 1 | 1 |\n",
"| 19 | female | 10 | 1 | 2 |\n",
"| 21 | male | 11 | 1 | 3 |\n",
"| 37 | female | 15 | 1 | 4 |\n",
"| 22 | male | 12 | 1 | 5 |\n",
"| 35 | female | 10 | 1 | 6 |\n",
"| 18 | male | 11 | 1 | 7 |\n",
"\n"
],
"text/plain": [
" age gender score var1 var2\n",
"1 17 female 12 1 1 \n",
"2 19 female 10 1 2 \n",
"3 21 male 11 1 3 \n",
"4 37 female 15 1 4 \n",
"5 22 male 12 1 5 \n",
"6 35 female 10 1 6 \n",
"7 18 male 11 1 7 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# This adds an entry called \"var2\", with different values\n",
"my.dataframe$var2<-c(1:7)\n",
"my.dataframe"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5.5.3 - Handy functions\n",
"\n",
"- `head`: it displays the first six lines (this number can be modified with the argument \"n\") of the data frame."
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"| age | gender | score | var1 | var2 |
|---|
\n",
"\n",
"\t| 17 | female | 12 | 1 | 1 |
\n",
"\t| 19 | female | 10 | 1 | 2 |
\n",
"\t| 21 | male | 11 | 1 | 3 |
\n",
"\t| 37 | female | 15 | 1 | 4 |
\n",
"\t| 22 | male | 12 | 1 | 5 |
\n",
"\t| 35 | female | 10 | 1 | 6 |
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lllll}\n",
" age & gender & score & var1 & var2\\\\\n",
"\\hline\n",
"\t 17 & female & 12 & 1 & 1 \\\\\n",
"\t 19 & female & 10 & 1 & 2 \\\\\n",
"\t 21 & male & 11 & 1 & 3 \\\\\n",
"\t 37 & female & 15 & 1 & 4 \\\\\n",
"\t 22 & male & 12 & 1 & 5 \\\\\n",
"\t 35 & female & 10 & 1 & 6 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| age | gender | score | var1 | var2 |\n",
"|---|---|---|---|---|\n",
"| 17 | female | 12 | 1 | 1 |\n",
"| 19 | female | 10 | 1 | 2 |\n",
"| 21 | male | 11 | 1 | 3 |\n",
"| 37 | female | 15 | 1 | 4 |\n",
"| 22 | male | 12 | 1 | 5 |\n",
"| 35 | female | 10 | 1 | 6 |\n",
"\n"
],
"text/plain": [
" age gender score var1 var2\n",
"1 17 female 12 1 1 \n",
"2 19 female 10 1 2 \n",
"3 21 male 11 1 3 \n",
"4 37 female 15 1 4 \n",
"5 22 male 12 1 5 \n",
"6 35 female 10 1 6 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"head(my.dataframe)"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"| age | gender | score | var1 | var2 |
|---|
\n",
"\n",
"\t| 17 | female | 12 | 1 | 1 |
\n",
"\t| 19 | female | 10 | 1 | 2 |
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lllll}\n",
" age & gender & score & var1 & var2\\\\\n",
"\\hline\n",
"\t 17 & female & 12 & 1 & 1 \\\\\n",
"\t 19 & female & 10 & 1 & 2 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| age | gender | score | var1 | var2 |\n",
"|---|---|---|---|---|\n",
"| 17 | female | 12 | 1 | 1 |\n",
"| 19 | female | 10 | 1 | 2 |\n",
"\n"
],
"text/plain": [
" age gender score var1 var2\n",
"1 17 female 12 1 1 \n",
"2 19 female 10 1 2 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"head(my.dataframe, n = 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `tail`: the same as `head`, but displaying the last six lines"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
" | age | gender | score | var1 | var2 |
|---|
\n",
"\n",
"\t| 2 | 19 | female | 10 | 1 | 2 |
|---|
\n",
"\t| 3 | 21 | male | 11 | 1 | 3 |
|---|
\n",
"\t| 4 | 37 | female | 15 | 1 | 4 |
|---|
\n",
"\t| 5 | 22 | male | 12 | 1 | 5 |
|---|
\n",
"\t| 6 | 35 | female | 10 | 1 | 6 |
|---|
\n",
"\t| 7 | 18 | male | 11 | 1 | 7 |
|---|
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lllll}\n",
" & age & gender & score & var1 & var2\\\\\n",
"\\hline\n",
"\t2 & 19 & female & 10 & 1 & 2 \\\\\n",
"\t3 & 21 & male & 11 & 1 & 3 \\\\\n",
"\t4 & 37 & female & 15 & 1 & 4 \\\\\n",
"\t5 & 22 & male & 12 & 1 & 5 \\\\\n",
"\t6 & 35 & female & 10 & 1 & 6 \\\\\n",
"\t7 & 18 & male & 11 & 1 & 7 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| | age | gender | score | var1 | var2 |\n",
"|---|---|---|---|---|---|\n",
"| 2 | 19 | female | 10 | 1 | 2 |\n",
"| 3 | 21 | male | 11 | 1 | 3 |\n",
"| 4 | 37 | female | 15 | 1 | 4 |\n",
"| 5 | 22 | male | 12 | 1 | 5 |\n",
"| 6 | 35 | female | 10 | 1 | 6 |\n",
"| 7 | 18 | male | 11 | 1 | 7 |\n",
"\n"
],
"text/plain": [
" age gender score var1 var2\n",
"2 19 female 10 1 2 \n",
"3 21 male 11 1 3 \n",
"4 37 female 15 1 4 \n",
"5 22 male 12 1 5 \n",
"6 35 female 10 1 6 \n",
"7 18 male 11 1 7 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"tail(my.dataframe)"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
" | age | gender | score | var1 | var2 |
|---|
\n",
"\n",
"\t| 6 | 35 | female | 10 | 1 | 6 |
|---|
\n",
"\t| 7 | 18 | male | 11 | 1 | 7 |
|---|
\n",
"\n",
"
\n"
],
"text/latex": [
"\\begin{tabular}{r|lllll}\n",
" & age & gender & score & var1 & var2\\\\\n",
"\\hline\n",
"\t6 & 35 & female & 10 & 1 & 6 \\\\\n",
"\t7 & 18 & male & 11 & 1 & 7 \\\\\n",
"\\end{tabular}\n"
],
"text/markdown": [
"\n",
"| | age | gender | score | var1 | var2 |\n",
"|---|---|---|---|---|---|\n",
"| 6 | 35 | female | 10 | 1 | 6 |\n",
"| 7 | 18 | male | 11 | 1 | 7 |\n",
"\n"
],
"text/plain": [
" age gender score var1 var2\n",
"6 35 female 10 1 6 \n",
"7 18 male 11 1 7 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"tail(my.dataframe, n=2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `names`: it show the names all variables stored in the data frame."
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- 'age'
\n",
"\t- 'gender'
\n",
"\t- 'score'
\n",
"\t- 'var1'
\n",
"\t- 'var2'
\n",
"
\n"
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item 'age'\n",
"\\item 'gender'\n",
"\\item 'score'\n",
"\\item 'var1'\n",
"\\item 'var2'\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. 'age'\n",
"2. 'gender'\n",
"3. 'score'\n",
"4. 'var1'\n",
"5. 'var2'\n",
"\n",
"\n"
],
"text/plain": [
"[1] \"age\" \"gender\" \"score\" \"var1\" \"var2\" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"names(my.dataframe)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `str`: it returns the structure of data frame - name, type and preview of data in each column."
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"'data.frame':\t7 obs. of 5 variables:\n",
" $ age : num 17 19 21 37 22 35 18\n",
" $ gender: Factor w/ 2 levels \"female\",\"male\": 1 1 2 1 2 1 2\n",
" $ score : num 12 10 11 15 12 10 11\n",
" $ var1 : num 1 1 1 1 1 1 1\n",
" $ var2 : int 1 2 3 4 5 6 7\n"
]
}
],
"source": [
"str(my.dataframe)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And these are the same that we saw before (You're free to try them out):\n",
"\n",
"- `dim`: it returns the dimensions of data frame (i.e. number of rows and number of columns)\n",
"- `nrow`: it returns the number of rows\n",
"- `ncol`: it returns the number of columns"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 6- Packages"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As in many languages, it is common to have to use pieces of code (functions, data, etc) many times. Here is when the concept of a **package** comes in play. \n",
"\n",
"Basically, a package is just a collection of functions, datasets and other R objects that are all grouped together under a common name. Some packages come installed by default with R, but a vast majority of the R packages will need to be installed manually from the Internet. The large number of packages available for R, and the ease of installing and using them, has been cited as a major factor driving the widespread adoption of the language in data science.\n",
"\n",
"In order to use a package we need to load it, that is, we need to make their functions, data, etc available and visible to our enviroment. (**N.B.** The package needs to be installed in our computer. Visit this to know how to install a package)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6.2 Loading a package\n",
"\n",
"In order to load a library, we just need to call the function `library`. Let's see an example using probably one of the most important libraries in R, ggplot2 (https://ggplot2.tidyverse.org)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Registered S3 methods overwritten by 'tibble':\n",
" method from \n",
" format.tbl pillar\n",
" print.tbl pillar\n",
"\n",
"Registered S3 methods overwritten by 'ggplot2':\n",
" method from \n",
" [.quosures rlang\n",
" c.quosures rlang\n",
" print.quosures rlang\n",
"\n",
"\n",
"Attaching package: ‘ggplot2’\n",
"\n",
"\n",
"The following objects are masked from ‘package:psych’:\n",
"\n",
" %+%, alpha\n",
"\n",
"\n"
]
}
],
"source": [
"library(ggplot2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 7- SOME PROGRAMMING BASICS\n",
"\n",
"At some point, in order to perform and implement complex tasks, you may end up having to write a computer program. As a consequence, it is recommendable that you get familiar with the most very basic programming operations that you can perform in R."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7.1. Conditional statements (IF, IF...ELSE)\n",
"\n",
"A conditional statement is an operation that allows you to switch between different possible commands depending on a specified condition that is specified by the programmer.\n",
"\n",
"The most prominent of example of a conditional statement is the if statement, and the accompanying else statement. \n",
"\n",
"Howver, before jumping to how to define an if statement, let's go over the different logical operations in R. These will give you as a result boolean, that is, a TRUE or FALSE value:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- \"==\" : Equal (e.g. x==y)\n",
"- \"!=\" : Not equal (e.g. x!=y)\n",
"- \">\" : Greater than\t(e.g. x > y)\n",
"- \"<\" : Less than (x < y)\n",
"- \">=\" : Greater than or equal to (e.g. x >= y)\n",
"- \"<=\" : Less than or equal to (e.g. x => y)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"FALSE"
],
"text/latex": [
"FALSE"
],
"text/markdown": [
"FALSE"
],
"text/plain": [
"[1] FALSE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"TRUE"
],
"text/latex": [
"TRUE"
],
"text/markdown": [
"TRUE"
],
"text/plain": [
"[1] TRUE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"FALSE"
],
"text/latex": [
"FALSE"
],
"text/markdown": [
"FALSE"
],
"text/plain": [
"[1] FALSE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"TRUE"
],
"text/latex": [
"TRUE"
],
"text/markdown": [
"TRUE"
],
"text/plain": [
"[1] TRUE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"FALSE"
],
"text/latex": [
"FALSE"
],
"text/markdown": [
"FALSE"
],
"text/plain": [
"[1] FALSE"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"TRUE"
],
"text/latex": [
"TRUE"
],
"text/markdown": [
"TRUE"
],
"text/plain": [
"[1] TRUE"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x<-5\n",
"y<-7\n",
"\n",
"# x equal to y\n",
"x==y\n",
"# x not equal to y\n",
"x!=y\n",
"# x greater that y\n",
"x>y\n",
"# x smaller that y\n",
"x=y\n",
"# x smaller than or equal to y\n",
"x<=y"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The basic format of an if statement in R is as follows:\n",
"\n",
"```\n",
"if ( CONDITION ) {\n",
"STATEMENT1\n",
"STATEMENT2\n",
"ETC\n",
"}\n",
"````"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] \"x greater than 4\"\n"
]
}
],
"source": [
"x=5\n",
"if( x > 4){\n",
" print(\"x greater than 4\")\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, If the condition within the parenthesis is true, then R will execute the statements contained in the curly braces. If the condition is false, then it does nothing.\n",
"\n",
"If you want to perform an operation when the condition within if is not satisfied, you can extend the if statement to include an else statement as well, leading to the following syntax:\n",
"\n",
"```\n",
"if ( CONDITION ) {\n",
"STATEMENT1\n",
"STATEMENT2\n",
"ETC\n",
"} else {\n",
"STATEMENT3\n",
"STATEMENT4\n",
"ETC\n",
"}\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] \"x smaller than 4\"\n"
]
}
],
"source": [
"x<-2\n",
"if( x > 4){\n",
" print(\"x greater than 4\")\n",
"} else {\n",
" print(\"x smaller than 4\")\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, a handy way of applying an if/else statement to several elements in a vector is by the `ifelse` function:"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t- 'EVEN'
\n",
"\t- 'ODD'
\n",
"\t- 'ODD'
\n",
"\t- 'EVEN'
\n",
"\t- 'EVEN'
\n",
"\t- 'ODD'
\n",
"\t- 'ODD'
\n",
"
\n"
],
"text/latex": [
"\\begin{enumerate*}\n",
"\\item 'EVEN'\n",
"\\item 'ODD'\n",
"\\item 'ODD'\n",
"\\item 'EVEN'\n",
"\\item 'EVEN'\n",
"\\item 'ODD'\n",
"\\item 'ODD'\n",
"\\end{enumerate*}\n"
],
"text/markdown": [
"1. 'EVEN'\n",
"2. 'ODD'\n",
"3. 'ODD'\n",
"4. 'EVEN'\n",
"5. 'EVEN'\n",
"6. 'ODD'\n",
"7. 'ODD'\n",
"\n",
"\n"
],
"text/plain": [
"[1] \"EVEN\" \"ODD\" \"ODD\" \"EVEN\" \"EVEN\" \"ODD\" \"ODD\" "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# input vector\n",
"x <- c(12, 9, 23, 14, 20, 1, 5)\n",
"\n",
"# ifelse() function to determine odd/even numbers\n",
"ifelse(x %% 2 == 0, \"EVEN\", \"ODD\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7.2. Loops\n",
"\n",
"Loops are block of codes (i.e., a sequence of commands) that will execute over and over again until some termination criterion is met."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7.2.1 while loop\n",
"\n",
"A while loop is a simple thing. The basic format of the loop looks like this:\n",
"\n",
"```\n",
"while ( CONDITION ) {\n",
"STATEMENT1\n",
"STATEMENT2\n",
"ETC\n",
"}\n",
"```\n",
"\n",
"Whenever R encounters a while statement, it checks to see if the condition within the parenthesis is TRUE. If it is, then R carries on executing all of the commands inside the curly brackets. When it gets to the\n",
"bottom of those statements, it moves back up to the while statement. Then, it checks to see if the condition is TRUE. If it is, then it executes everything again. And it does so until the condition turns out to be FALSE, for which it exits the loop."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] 17\n",
"[1] 34\n",
"[1] 51\n",
"[1] 68\n",
"[1] 85\n",
"[1] 102\n",
"[1] \"I exited the loop, yeah!\"\n"
]
}
],
"source": [
"x <- 0\n",
"while ( x < 100 ) {\n",
"x <- x + 17\n",
"print( x )\n",
"}\n",
"print(\"I exited the loop, yeah!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7.2.2 for loop\n",
"\n",
"The for loop is similar to the while loop, but instead of running while a condition is TRUE, it runs a fixed number of iterations. The sintax in R is as follows:\n",
"\n",
"```\n",
"for ( VAR in VECTOR ) {\n",
"STATEMENT1\n",
"STATEMENT2\n",
"ETC\n",
"}\n",
"```\n",
"\n",
"The for loop will execute the block of code within the curly brackets, but iterations will run through the different elements in the VECTOR and setting the value of VAR to that particular vector element."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] \"hola caracola\"\n",
"[1] \"hola caracola\"\n",
"[1] \"hola caracola\"\n",
"[1] \"hola caracola\"\n",
"[1] \"hola caracola\"\n"
]
}
],
"source": [
"for ( i in c(1:5) ) {\n",
"print( \"hola caracola\" )\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] 1\n",
"[1] 2\n",
"[1] 3\n",
"[1] 4\n",
"[1] 5\n"
]
}
],
"source": [
"for ( i in c(1:5) ) {\n",
" \n",
"print( i)\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Practice: Create a variable \"x\" and set a value 0 to it. Then, create a loop that iterates a vector from 1 to 10. In each iteration update the value of x by adding the value of each element of the vector.
"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# Write your response here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7.3 - Write your own functions\n",
"\n",
"We have already introduced the concept of functions and how to use them. However, we have only used predefined functions. What if we want to write our own functions? This can be helpful in case we want to perform a specific computation.\n",
"\n",
"\n",
"The syntax that you use to create a function is as follows:\n",
"\n",
"``` \n",
"FNAME <- function ( ARG1, ARG2, ETC ) {\n",
"STATEMENT1\n",
"STATEMENT2\n",
"ETC\n",
"return( VALUE )\n",
"}\n",
"```\n",
"\n",
"This will create a function with the name fname, which has arguments arg1, arg2 and so forth.\n",
"Whenever the function is called, R executes the statements in the curly braces, and then outputs the contents of\n",
"value to the user. To note, only the final results in the value are returned. Everything that was set or stored within the function will no be visible after the function is called."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"# Example: This creates a function that multiplies a number by 3\n",
"triple <- function(x) {\n",
"y <- x*3\n",
"return(y)\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"9"
],
"text/latex": [
"9"
],
"text/markdown": [
"9"
],
"text/plain": [
"[1] 9"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x<-3\n",
"triple(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Practice: Create a function \"myabs\" that returns the absolute value of a given number. Test that it works as expected.
"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# Write your response here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Practice: Create a function \"mysquare\", of two arguments, such that it takes the square of the first one, and then it adds the second one to it. Set the second argument to take the value 2 as default. Test it.
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 8- Miscellaneous: some special Values"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Infinity*: It corresponds to a value that is infinitely large. You can also have -Inf. This is the value you'd obtain by dividing a number by 0. R has a built-in value for this, `Inf`"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Inf"
],
"text/latex": [
"Inf"
],
"text/markdown": [
"Inf"
],
"text/plain": [
"[1] Inf"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"1/0"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"-Inf"
],
"text/latex": [
"-Inf"
],
"text/markdown": [
"-Inf"
],
"text/plain": [
"[1] -Inf"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"-1/0"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Inf"
],
"text/latex": [
"Inf"
],
"text/markdown": [
"Inf"
],
"text/plain": [
"[1] Inf"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"Inf"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Not a Number*. The special value of NaN is short for “not a number”, and it’s basically a reserved keyword that means “there isn’t a mathematically defined number for this”. In R, this is reserved for the value `NaN`"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"NaN"
],
"text/latex": [
"NaN"
],
"text/markdown": [
"NaN"
],
"text/plain": [
"[1] NaN"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"0/0"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"NaN"
],
"text/latex": [
"NaN"
],
"text/markdown": [
"NaN"
],
"text/plain": [
"[1] NaN"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"NaN"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Not available*. It indicates that the value that is \"supposed\" to be stored here is missing. This is a typical situation when you read a dataset and observations miss values for some specific measured variables. In R, this is kind of value takes the keyword `NA`"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<NA>"
],
"text/latex": [
""
],
"text/markdown": [
"<NA>"
],
"text/plain": [
"[1] NA"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"NA"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*No value*. It takes the keyword `NULL` in R and it asserts that the variable genuinely has no value whatsoever. "
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"NULL"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"NULL"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Resources for R\n",
"\n",
"- [Base R cheatsheet](https://iqss.github.io/dss-workshops/R/Rintro/base-r-cheat-sheet.pdf)"
]
}
],
"metadata": {
"anaconda-cloud": "",
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "R",
"language": "R",
"name": "ir"
},
"language_info": {
"codemirror_mode": "r",
"file_extension": ".r",
"mimetype": "text/x-r-source",
"name": "R",
"pygments_lexer": "r",
"version": "3.6.1"
}
},
"nbformat": 4,
"nbformat_minor": 1
}