Lecture19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will learn about vectors in R.\n",
    "\n",
    "* [Vector basics](#Vector-basics)\n",
    "* [Special values](#Special-values)\n",
    "* [Type conversions](#Type-conversions)\n",
    "* [Recycling](#Recycling)\n",
    "* [Naming and subsetting](#Naming-and-subsetting)\n",
    "* [List basics](#List-basics)\n",
    "* [List subsetting](#List-subsetting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading tidyverse: ggplot2\n",
      "Loading tidyverse: tibble\n",
      "Loading tidyverse: tidyr\n",
      "Loading tidyverse: readr\n",
      "Loading tidyverse: purrr\n",
      "Loading tidyverse: dplyr\n",
      "Conflicts with tidy packages ---------------------------------------------------\n",
      "filter(): dplyr, stats\n",
      "lag():    dplyr, stats\n"
     ]
    }
   ],
   "source": [
    "library(tidyverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vector basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "R has two types of vectors:\n",
    "\n",
    "1. Atomic vectors, of six types: logical, integer, double, character, complex, and raw. Integer and double vectors are collectively known as numeric vectors.\n",
    "2. Lists, also called recursive vectors because lists can contain other lists.\n",
    "\n",
    "Atomic vectors are **homogeneous**, while lists are allowed to be **heterogeneous**. \n",
    "\n",
    "There’s one other related object: `NULL` (that's what gets returned if your function doesn't return anything).\n",
    "\n",
    "NULL denotes the absence of a vector (as opposed to `NA` which represents the absence of a value in a vector). NULL behaves like a vector of length 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'character'"
      ],
      "text/latex": [
       "'character'"
      ],
      "text/markdown": [
       "'character'"
      ],
      "text/plain": [
       "[1] \"character\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'double'"
      ],
      "text/latex": [
       "'double'"
      ],
      "text/markdown": [
       "'double'"
      ],
      "text/plain": [
       "[1] \"double\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(runif(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'integer'"
      ],
      "text/latex": [
       "'integer'"
      ],
      "text/markdown": [
       "'integer'"
      ],
      "text/plain": [
       "[1] \"integer\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(1:100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "26"
      ],
      "text/latex": [
       "26"
      ],
      "text/markdown": [
       "26"
      ],
      "text/plain": [
       "[1] 26"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "10"
      ],
      "text/latex": [
       "10"
      ],
      "text/markdown": [
       "10"
      ],
      "text/plain": [
       "[1] 10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length(runif(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "100"
      ],
      "text/latex": [
       "100"
      ],
      "text/markdown": [
       "100"
      ],
      "text/plain": [
       "[1] 100"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "length(1:100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'double'"
      ],
      "text/latex": [
       "'double'"
      ],
      "text/markdown": [
       "'double'"
      ],
      "text/plain": [
       "[1] \"double\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x <- c(1, 2, 3, 4, 5) # numeric constants are of type double by default\n",
    "typeof(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'integer'"
      ],
      "text/latex": [
       "'integer'"
      ],
      "text/markdown": [
       "'integer'"
      ],
      "text/plain": [
       "[1] \"integer\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x <- c(1L, 2L, 3L, 4L, 5L) # add 'L' at the end if you want integers\n",
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical and integer vectors only have one special values: `NA`.\n",
    "Double vectors have fours: `NaN`, `Inf`, `-Inf`, and `NA`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message in sqrt(-1):\n",
      "“NaNs produced”"
     ]
    },
    {
     "data": {
      "text/html": [
       "NaN"
      ],
      "text/latex": [
       "NaN"
      ],
      "text/markdown": [
       "NaN"
      ],
      "text/plain": [
       "[1] NaN"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sqrt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Inf"
      ],
      "text/latex": [
       "Inf"
      ],
      "text/markdown": [
       "Inf"
      ],
      "text/plain": [
       "[1] Inf"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sqrt(Inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message in sqrt(-Inf):\n",
      "“NaNs produced”"
     ]
    },
    {
     "data": {
      "text/html": [
       "NaN"
      ],
      "text/latex": [
       "NaN"
      ],
      "text/markdown": [
       "NaN"
      ],
      "text/plain": [
       "[1] NaN"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sqrt(-Inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1] NA"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sqrt(NA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "NaN"
      ],
      "text/latex": [
       "NaN"
      ],
      "text/markdown": [
       "NaN"
      ],
      "text/plain": [
       "[1] NaN"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sqrt(NaN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. FALSE\n",
       "4. FALSE\n",
       "5. TRUE\n",
       "6. TRUE\n",
       "7. TRUE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x <- c(Inf, -Inf, NaN, NA, 1, 0, 100)\n",
    "is.finite(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. TRUE\n",
       "2. TRUE\n",
       "3. FALSE\n",
       "4. FALSE\n",
       "5. FALSE\n",
       "6. FALSE\n",
       "7. FALSE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1]  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.infinite(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. TRUE\n",
       "4. TRUE\n",
       "5. FALSE\n",
       "6. FALSE\n",
       "7. FALSE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.na(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. TRUE\n",
       "4. FALSE\n",
       "5. FALSE\n",
       "6. FALSE\n",
       "7. FALSE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE FALSE  TRUE FALSE FALSE FALSE FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.nan(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type conversions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. TRUE\n",
       "3. TRUE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] FALSE  TRUE  TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "as.logical(0:2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "</ol>\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"
    }
   ],
   "source": [
    "as.integer(c(\"1\", \"2\", \"3\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>FALSE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>TRUE</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item FALSE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\item TRUE\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. FALSE\n",
       "2. FALSE\n",
       "3. FALSE\n",
       "4. FALSE\n",
       "5. FALSE\n",
       "6. TRUE\n",
       "7. TRUE\n",
       "8. TRUE\n",
       "9. TRUE\n",
       "10. TRUE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1:10 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "5"
      ],
      "text/latex": [
       "5"
      ],
      "text/markdown": [
       "5"
      ],
      "text/plain": [
       "[1] 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sum(1:10 > 5) # TRUE is converted to 1, FALSE to 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When creating vectors using `c()`, the most complex type wins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>0</li>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 0\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 0\n",
       "3. 1\n",
       "4. 2\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 0 1 2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c(TRUE, FALSE, 1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "'double'"
      ],
      "text/latex": [
       "'double'"
      ],
      "text/markdown": [
       "'double'"
      ],
      "text/plain": [
       "[1] \"double\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(c(1L, 2L, 3.4, 5.6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>'TRUE'</li>\n",
       "\t<li>'1'</li>\n",
       "\t<li>'1.1'</li>\n",
       "\t<li>'a'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'TRUE'\n",
       "\\item '1'\n",
       "\\item '1.1'\n",
       "\\item 'a'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'TRUE'\n",
       "2. '1'\n",
       "3. '1.1'\n",
       "4. 'a'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"TRUE\" \"1\"    \"1.1\"  \"a\"   "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c(TRUE, 1, 1.1, \"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.numeric(1:10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.numeric(runif(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is.numeric(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tidyverse package **purrr** has replacement functions, such as `is_numeric()`, that behave more consistently than base R functions, such as `is.numeric()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recycling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "\t<li>4</li>\n",
       "\t<li>5</li>\n",
       "\t<li>6</li>\n",
       "\t<li>7</li>\n",
       "\t<li>8</li>\n",
       "\t<li>9</li>\n",
       "\t<li>10</li>\n",
       "\t<li>11</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\item 4\n",
       "\\item 5\n",
       "\\item 6\n",
       "\\item 7\n",
       "\\item 8\n",
       "\\item 9\n",
       "\\item 10\n",
       "\\item 11\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 2\n",
       "2. 3\n",
       "3. 4\n",
       "4. 5\n",
       "5. 6\n",
       "6. 7\n",
       "7. 8\n",
       "8. 9\n",
       "9. 10\n",
       "10. 11\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  2  3  4  5  6  7  8  9 10 11"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1 + 1:10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning message in 1:3 + 1:10:\n",
      "“longer object length is not a multiple of shorter object length”"
     ]
    },
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>2</li>\n",
       "\t<li>4</li>\n",
       "\t<li>6</li>\n",
       "\t<li>5</li>\n",
       "\t<li>7</li>\n",
       "\t<li>9</li>\n",
       "\t<li>8</li>\n",
       "\t<li>10</li>\n",
       "\t<li>12</li>\n",
       "\t<li>11</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 2\n",
       "\\item 4\n",
       "\\item 6\n",
       "\\item 5\n",
       "\\item 7\n",
       "\\item 9\n",
       "\\item 8\n",
       "\\item 10\n",
       "\\item 12\n",
       "\\item 11\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 2\n",
       "2. 4\n",
       "3. 6\n",
       "4. 5\n",
       "5. 7\n",
       "6. 9\n",
       "7. 8\n",
       "8. 10\n",
       "9. 12\n",
       "10. 11\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  2  4  6  5  7  9  8 10 12 11"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1:3 + 1:10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>2</li>\n",
       "\t<li>4</li>\n",
       "\t<li>4</li>\n",
       "\t<li>6</li>\n",
       "\t<li>6</li>\n",
       "\t<li>8</li>\n",
       "\t<li>8</li>\n",
       "\t<li>10</li>\n",
       "\t<li>10</li>\n",
       "\t<li>12</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 2\n",
       "\\item 4\n",
       "\\item 4\n",
       "\\item 6\n",
       "\\item 6\n",
       "\\item 8\n",
       "\\item 8\n",
       "\\item 10\n",
       "\\item 10\n",
       "\\item 12\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 2\n",
       "2. 4\n",
       "3. 4\n",
       "4. 6\n",
       "5. 6\n",
       "6. 8\n",
       "7. 8\n",
       "8. 10\n",
       "9. 10\n",
       "10. 12\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1]  2  4  4  6  6  8  8 10 10 12"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "1:2 + 1:10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>'a1A'</li>\n",
       "\t<li>'b2B'</li>\n",
       "\t<li>'c3C'</li>\n",
       "\t<li>'d4D'</li>\n",
       "\t<li>'e5E'</li>\n",
       "\t<li>'f6F'</li>\n",
       "\t<li>'g7G'</li>\n",
       "\t<li>'h8H'</li>\n",
       "\t<li>'i9I'</li>\n",
       "\t<li>'j10J'</li>\n",
       "\t<li>'k11K'</li>\n",
       "\t<li>'l12L'</li>\n",
       "\t<li>'m13M'</li>\n",
       "\t<li>'n1N'</li>\n",
       "\t<li>'o2O'</li>\n",
       "\t<li>'p3P'</li>\n",
       "\t<li>'q4Q'</li>\n",
       "\t<li>'r5R'</li>\n",
       "\t<li>'s6S'</li>\n",
       "\t<li>'t7T'</li>\n",
       "\t<li>'u8U'</li>\n",
       "\t<li>'v9V'</li>\n",
       "\t<li>'w10W'</li>\n",
       "\t<li>'x11X'</li>\n",
       "\t<li>'y12Y'</li>\n",
       "\t<li>'z13Z'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'a1A'\n",
       "\\item 'b2B'\n",
       "\\item 'c3C'\n",
       "\\item 'd4D'\n",
       "\\item 'e5E'\n",
       "\\item 'f6F'\n",
       "\\item 'g7G'\n",
       "\\item 'h8H'\n",
       "\\item 'i9I'\n",
       "\\item 'j10J'\n",
       "\\item 'k11K'\n",
       "\\item 'l12L'\n",
       "\\item 'm13M'\n",
       "\\item 'n1N'\n",
       "\\item 'o2O'\n",
       "\\item 'p3P'\n",
       "\\item 'q4Q'\n",
       "\\item 'r5R'\n",
       "\\item 's6S'\n",
       "\\item 't7T'\n",
       "\\item 'u8U'\n",
       "\\item 'v9V'\n",
       "\\item 'w10W'\n",
       "\\item 'x11X'\n",
       "\\item 'y12Y'\n",
       "\\item 'z13Z'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'a1A'\n",
       "2. 'b2B'\n",
       "3. 'c3C'\n",
       "4. 'd4D'\n",
       "5. 'e5E'\n",
       "6. 'f6F'\n",
       "7. 'g7G'\n",
       "8. 'h8H'\n",
       "9. 'i9I'\n",
       "10. 'j10J'\n",
       "11. 'k11K'\n",
       "12. 'l12L'\n",
       "13. 'm13M'\n",
       "14. 'n1N'\n",
       "15. 'o2O'\n",
       "16. 'p3P'\n",
       "17. 'q4Q'\n",
       "18. 'r5R'\n",
       "19. 's6S'\n",
       "20. 't7T'\n",
       "21. 'u8U'\n",
       "22. 'v9V'\n",
       "23. 'w10W'\n",
       "24. 'x11X'\n",
       "25. 'y12Y'\n",
       "26. 'z13Z'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1] \"a1A\"  \"b2B\"  \"c3C\"  \"d4D\"  \"e5E\"  \"f6F\"  \"g7G\"  \"h8H\"  \"i9I\"  \"j10J\"\n",
       "[11] \"k11K\" \"l12L\" \"m13M\" \"n1N\"  \"o2O\"  \"p3P\"  \"q4Q\"  \"r5R\"  \"s6S\"  \"t7T\" \n",
       "[21] \"u8U\"  \"v9V\"  \"w10W\" \"x11X\" \"y12Y\" \"z13Z\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stringr::str_c(letters, 1:13, LETTERS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naming and subsetting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x <- c(Alice = 50, Bob = 60, Charlie = 70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Alice     Bob Charlie \n",
      "     50      60      70 \n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<strong>Alice:</strong> 50"
      ],
      "text/latex": [
       "\\textbf{Alice:} 50"
      ],
      "text/markdown": [
       "**Alice:** 50"
      ],
      "text/plain": [
       "Alice \n",
       "   50 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[\"Alice\"] # if named, can use character vector to subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<strong>Charlie:</strong> 70"
      ],
      "text/latex": [
       "\\textbf{Charlie:} 70"
      ],
      "text/markdown": [
       "**Charlie:** 70"
      ],
      "text/plain": [
       "Charlie \n",
       "     70 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[\"Charlie\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<strong>Alice:</strong> 50"
      ],
      "text/latex": [
       "\\textbf{Alice:} 50"
      ],
      "text/markdown": [
       "**Alice:** 50"
      ],
      "text/plain": [
       "Alice \n",
       "   50 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[1] # integer vector can be used to subset, extracts by positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl class=dl-horizontal>\n",
       "\t<dt>Alice</dt>\n",
       "\t\t<dd>50</dd>\n",
       "\t<dt>Bob</dt>\n",
       "\t\t<dd>60</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description*}\n",
       "\\item[Alice] 50\n",
       "\\item[Bob] 60\n",
       "\\end{description*}\n"
      ],
      "text/markdown": [
       "Alice\n",
       ":   50Bob\n",
       ":   60\n",
       "\n"
      ],
      "text/plain": [
       "Alice   Bob \n",
       "   50    60 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl class=dl-horizontal>\n",
       "\t<dt>Alice</dt>\n",
       "\t\t<dd>50</dd>\n",
       "\t<dt>Charlie</dt>\n",
       "\t\t<dd>70</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description*}\n",
       "\\item[Alice] 50\n",
       "\\item[Charlie] 70\n",
       "\\end{description*}\n"
      ],
      "text/markdown": [
       "Alice\n",
       ":   50Charlie\n",
       ":   70\n",
       "\n"
      ],
      "text/plain": [
       "  Alice Charlie \n",
       "     50      70 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[c(1,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl class=dl-horizontal>\n",
       "\t<dt>Bob</dt>\n",
       "\t\t<dd>60</dd>\n",
       "\t<dt>Charlie</dt>\n",
       "\t\t<dd>70</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description*}\n",
       "\\item[Bob] 60\n",
       "\\item[Charlie] 70\n",
       "\\end{description*}\n"
      ],
      "text/markdown": [
       "Bob\n",
       ":   60Charlie\n",
       ":   70\n",
       "\n"
      ],
      "text/plain": [
       "    Bob Charlie \n",
       "     60      70 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[x > 50] # logical vector extracts elements correponding to TRUE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operator `[[` extracts a single elements and always drops names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in x[[1:2]]: attempt to select more than one element in vectorIndex\n",
     "output_type": "error",
     "traceback": [
      "Error in x[[1:2]]: attempt to select more than one element in vectorIndex\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "x[[1:2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "50"
      ],
      "text/latex": [
       "50"
      ],
      "text/markdown": [
       "50"
      ],
      "text/plain": [
       "[1] 50"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x[[1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atomic vectors are created using `c()`, lists are created using `list()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x <- list(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[1] 1\n",
      "\n",
      "[[2]]\n",
      "[1] 2\n",
      "\n",
      "[[3]]\n",
      "[1] 3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y <- list(1, 2, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[1] 1\n",
      "\n",
      "[[2]]\n",
      "[1] 2\n",
      "\n",
      "[[3]]\n",
      "[[3]][[1]]\n",
      "[1] 1\n",
      "\n",
      "[[3]][[2]]\n",
      "[1] 2\n",
      "\n",
      "[[3]][[3]]\n",
      "[1] 3\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 3\n",
      " $ : num 1\n",
      " $ : num 2\n",
      " $ :List of 3\n",
      "  ..$ : num 1\n",
      "  ..$ : num 2\n",
      "  ..$ : num 3\n"
     ]
    }
   ],
   "source": [
    "str(y) # focus on structure, not contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. 1\n",
       "4. 2\n",
       "5. 3\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 2 1 2 3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c(1, 2, c(1, 2, 3)) # nesting doesn't happen for atomic vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>'1'</li>\n",
       "\t<li>'2'</li>\n",
       "\t<li>'TRUE'</li>\n",
       "\t<li>'true'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item '1'\n",
       "\\item '2'\n",
       "\\item 'TRUE'\n",
       "\\item 'true'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. '1'\n",
       "2. '2'\n",
       "3. 'TRUE'\n",
       "4. 'true'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"1\"    \"2\"    \"TRUE\" \"true\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c(1, 2, TRUE, \"true\") # everything gets converted to character type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>TRUE</li>\n",
       "\t<li>'true'</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item TRUE\n",
       "\\item 'true'\n",
       "\\end{enumerate}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 2\n",
       "3. TRUE\n",
       "4. 'true'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[[1]]\n",
       "[1] 1\n",
       "\n",
       "[[2]]\n",
       "[1] 2\n",
       "\n",
       "[[3]]\n",
       "[1] TRUE\n",
       "\n",
       "[[4]]\n",
       "[1] \"true\"\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "list(1, 2, TRUE, \"true\") # can mix types in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 4\n",
      " $ : num 1\n",
      " $ : num 2\n",
      " $ : logi TRUE\n",
      " $ : chr \"true\"\n"
     ]
    }
   ],
   "source": [
    "str(list(1, 2, TRUE, \"true\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mylist <- list(num = 1:3, char = list(\"a\", \"b\", \"c\"), logi = FALSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl>\n",
       "\t<dt>$num</dt>\n",
       "\t\t<dd><ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "</ol>\n",
       "</dd>\n",
       "\t<dt>$char</dt>\n",
       "\t\t<dd><ol>\n",
       "\t<li>'a'</li>\n",
       "\t<li>'b'</li>\n",
       "\t<li>'c'</li>\n",
       "</ol>\n",
       "</dd>\n",
       "\t<dt>$logi</dt>\n",
       "\t\t<dd>FALSE</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description}\n",
       "\\item[\\$num] \\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\end{enumerate*}\n",
       "\n",
       "\\item[\\$char] \\begin{enumerate}\n",
       "\\item 'a'\n",
       "\\item 'b'\n",
       "\\item 'c'\n",
       "\\end{enumerate}\n",
       "\n",
       "\\item[\\$logi] FALSE\n",
       "\\end{description}\n"
      ],
      "text/markdown": [
       "$num\n",
       ":   1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "\n",
       "\n",
       "\n",
       "$char\n",
       ":   1. 'a'\n",
       "2. 'b'\n",
       "3. 'c'\n",
       "\n",
       "\n",
       "\n",
       "$logi\n",
       ":   FALSE\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "$num\n",
       "[1] 1 2 3\n",
       "\n",
       "$char\n",
       "$char[[1]]\n",
       "[1] \"a\"\n",
       "\n",
       "$char[[2]]\n",
       "[1] \"b\"\n",
       "\n",
       "$char[[3]]\n",
       "[1] \"c\"\n",
       "\n",
       "\n",
       "$logi\n",
       "[1] FALSE\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 3\n",
      " $ num : int [1:3] 1 2 3\n",
      " $ char:List of 3\n",
      "  ..$ : chr \"a\"\n",
      "  ..$ : chr \"b\"\n",
      "  ..$ : chr \"c\"\n",
      " $ logi: logi FALSE\n"
     ]
    }
   ],
   "source": [
    "str(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List subsetting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl>\n",
       "\t<dt>$logi</dt>\n",
       "\t\t<dd>FALSE</dd>\n",
       "\t<dt>$num</dt>\n",
       "\t\t<dd><ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "</ol>\n",
       "</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description}\n",
       "\\item[\\$logi] FALSE\n",
       "\\item[\\$num] \\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\end{enumerate*}\n",
       "\n",
       "\\end{description}\n"
      ],
      "text/markdown": [
       "$logi\n",
       ":   FALSE\n",
       "$num\n",
       ":   1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "$logi\n",
       "[1] FALSE\n",
       "\n",
       "$num\n",
       "[1] 1 2 3\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist[c(\"logi\", \"num\")] # subset using character vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl>\n",
       "\t<dt>$num</dt>\n",
       "\t\t<dd><ol class=list-inline>\n",
       "\t<li>1</li>\n",
       "\t<li>2</li>\n",
       "\t<li>3</li>\n",
       "</ol>\n",
       "</dd>\n",
       "\t<dt>$char</dt>\n",
       "\t\t<dd><ol>\n",
       "\t<li>'a'</li>\n",
       "\t<li>'b'</li>\n",
       "\t<li>'c'</li>\n",
       "</ol>\n",
       "</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description}\n",
       "\\item[\\$num] \\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 2\n",
       "\\item 3\n",
       "\\end{enumerate*}\n",
       "\n",
       "\\item[\\$char] \\begin{enumerate}\n",
       "\\item 'a'\n",
       "\\item 'b'\n",
       "\\item 'c'\n",
       "\\end{enumerate}\n",
       "\n",
       "\\end{description}\n"
      ],
      "text/markdown": [
       "$num\n",
       ":   1. 1\n",
       "2. 2\n",
       "3. 3\n",
       "\n",
       "\n",
       "\n",
       "$char\n",
       ":   1. 'a'\n",
       "2. 'b'\n",
       "3. 'c'\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "$num\n",
       "[1] 1 2 3\n",
       "\n",
       "$char\n",
       "$char[[1]]\n",
       "[1] \"a\"\n",
       "\n",
       "$char[[2]]\n",
       "[1] \"b\"\n",
       "\n",
       "$char[[3]]\n",
       "[1] \"c\"\n",
       "\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist[1:2] # subset using integer vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mylist2 <- list(dbl = runif(10), na = NA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl>\n",
       "\t<dt>$dbl</dt>\n",
       "\t\t<dd><ol class=list-inline>\n",
       "\t<li>0.514759342884645</li>\n",
       "\t<li>0.638313413597643</li>\n",
       "\t<li>0.282991295214742</li>\n",
       "\t<li>0.0872707669623196</li>\n",
       "\t<li>0.542495011352003</li>\n",
       "\t<li>0.0923747781198472</li>\n",
       "\t<li>0.329722634050995</li>\n",
       "\t<li>0.494008915731683</li>\n",
       "\t<li>0.117010592017323</li>\n",
       "\t<li>0.452013414120302</li>\n",
       "</ol>\n",
       "</dd>\n",
       "\t<dt>$na</dt>\n",
       "\t\t<dd>NA</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description}\n",
       "\\item[\\$dbl] \\begin{enumerate*}\n",
       "\\item 0.514759342884645\n",
       "\\item 0.638313413597643\n",
       "\\item 0.282991295214742\n",
       "\\item 0.0872707669623196\n",
       "\\item 0.542495011352003\n",
       "\\item 0.0923747781198472\n",
       "\\item 0.329722634050995\n",
       "\\item 0.494008915731683\n",
       "\\item 0.117010592017323\n",
       "\\item 0.452013414120302\n",
       "\\end{enumerate*}\n",
       "\n",
       "\\item[\\$na] NA\n",
       "\\end{description}\n"
      ],
      "text/markdown": [
       "$dbl\n",
       ":   1. 0.514759342884645\n",
       "2. 0.638313413597643\n",
       "3. 0.282991295214742\n",
       "4. 0.0872707669623196\n",
       "5. 0.542495011352003\n",
       "6. 0.0923747781198472\n",
       "7. 0.329722634050995\n",
       "8. 0.494008915731683\n",
       "9. 0.117010592017323\n",
       "10. 0.452013414120302\n",
       "\n",
       "\n",
       "\n",
       "$na\n",
       ":   NA\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "$dbl\n",
       " [1] 0.51475934 0.63831341 0.28299130 0.08727077 0.54249501 0.09237478\n",
       " [7] 0.32972263 0.49400892 0.11701059 0.45201341\n",
       "\n",
       "$na\n",
       "[1] NA\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<strong>$dbl</strong> = <ol class=list-inline>\n",
       "\t<li>0.514759342884645</li>\n",
       "\t<li>0.638313413597643</li>\n",
       "\t<li>0.282991295214742</li>\n",
       "\t<li>0.0872707669623196</li>\n",
       "\t<li>0.542495011352003</li>\n",
       "\t<li>0.0923747781198472</li>\n",
       "\t<li>0.329722634050995</li>\n",
       "\t<li>0.494008915731683</li>\n",
       "\t<li>0.117010592017323</li>\n",
       "\t<li>0.452013414120302</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\textbf{\\$dbl} = \\begin{enumerate*}\n",
       "\\item 0.514759342884645\n",
       "\\item 0.638313413597643\n",
       "\\item 0.282991295214742\n",
       "\\item 0.0872707669623196\n",
       "\\item 0.542495011352003\n",
       "\\item 0.0923747781198472\n",
       "\\item 0.329722634050995\n",
       "\\item 0.494008915731683\n",
       "\\item 0.117010592017323\n",
       "\\item 0.452013414120302\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "**$dbl** = 1. 0.514759342884645\n",
       "2. 0.638313413597643\n",
       "3. 0.282991295214742\n",
       "4. 0.0872707669623196\n",
       "5. 0.542495011352003\n",
       "6. 0.0923747781198472\n",
       "7. 0.329722634050995\n",
       "8. 0.494008915731683\n",
       "9. 0.117010592017323\n",
       "10. 0.452013414120302\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "$dbl\n",
       " [1] 0.51475934 0.63831341 0.28299130 0.08727077 0.54249501 0.09237478\n",
       " [7] 0.32972263 0.49400892 0.11701059 0.45201341\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist2[!is.na(mylist2)] # logical subsetting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`[[` extract a single elements. However, it **reduces** one level of hierarchy in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of 1\n",
      " $ num: int [1:3] 1 2 3\n"
     ]
    }
   ],
   "source": [
    "str(mylist[1]) # two levels of nesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int [1:3] 1 2 3\n"
     ]
    }
   ],
   "source": [
    "str(mylist[[1]]) # just one level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally `$` is just like `[[` except that it uses names and you don't need to supply quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist$logi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mylist[['logi']]"
   ]
  }
 ],
 "metadata": {
  "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.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}