2-3_Lists_and_strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 2-3\n",
    "\n",
    "# Lists Part 2 and Strings\n",
    "\n",
    "## Week 2 Friday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "Adapted from Chapter 6 of Think Python by Allen B Downey\n",
    "\n",
    "List content adapted from \"Whirlwind Tour of Python\" by Jake VanderPlas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists are mutable\n",
    "This means that methods change the lists themselves. \n",
    "If the list is assigned to another name, both names refer to the exact same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "print(fam)\n",
    "second = fam    # second references fam. second is not a copy of fam.\n",
    "second[0] = \"sister\"  # we make a change to the list 'second'\n",
    "print(second)\n",
    "print(fam) # changing the list 'second' has changed the list 'fam'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['sister', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "print(fam)\n",
    "second = fam[:]  # creates a copy of the list\n",
    "# second = fam.copy() # you can also create a list using the copy() method\n",
    "second[0] = \"sister\"\n",
    "print(second)\n",
    "print(fam) # changing the list second does not modify fam because second is a copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.65, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.65, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "third = fam.copy()\n",
    "print(third)\n",
    "third[1] = 1.65\n",
    "print(third)\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.9, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.9, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "list2 = list(fam)\n",
    "list2[1] = 1.9\n",
    "print(list2)\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "You can use list slicing in conjuction with assignment to change values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.8, 'jenny', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.8, 'jenny', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "print(fam)\n",
    "fam[1:3] = [1.8, \"jenny\"]\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# List Methods\n",
    "\n",
    "- `list.copy()`\n",
    "    - Return a shallow copy of the list. Equivalent to a[:]\n",
    "- `list.append(x)`\n",
    "    - Add an item to the end of the list. Equivalent to a[len(a):] = [x]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me']\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me']\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.append(\"me\")   # unlike R, you don't have to \"capture\" the result of the function. \n",
    "# the list itself is modified. You can only append one item.\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', 1.8]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', 1.8]\n"
     ]
    }
   ],
   "source": [
    "fam = fam + [1.8]  # you can also append to a list with the addition `+` operator\n",
    "# note that this output needs to be 'captured' and assigned back to fam\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "fam.append('miles')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', 1.8, 'miles']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fam.append(['miles', 1.78, 'joe', 1.8]) # append will add the entire object as one list entry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89,\n",
       " 'me',\n",
       " 1.8,\n",
       " 'miles',\n",
       " ['miles', 1.78, 'joe', 1.8]]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89,\n",
       " 'miles',\n",
       " 1.78,\n",
       " 'joe',\n",
       " 1.8]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam + ['miles', 1.78, 'joe', 1.8] # plus operator concatenates the lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89,\n",
       " 'liz',\n",
       " 1.73,\n",
       " 'emma',\n",
       " 1.68,\n",
       " 'mom',\n",
       " 1.71,\n",
       " 'dad',\n",
       " 1.89]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Copy vs. Deep Copy Example\n",
    "\n",
    "`list.copy` and `list[:]` both create shallow copies. A shallow copy creates a copy of the list, but does not create copies of any objects that the list references.\n",
    "\n",
    "a deep copy will copy the list and create copies of objects that the list references."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [\"a\", 1, 2]\n",
    "b = [\"b\", 3, 4]\n",
    "c = [a, b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 1, 2]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 3, 4]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['a', 1, 2], ['b', 3, 4]]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "d = c[:]  # d is a shallow copy of c\n",
    "e = copy.deepcopy(c)  # e is a deep copy of c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['a', 1, 2], ['b', 3, 4]]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['a', 1, 2], ['b', 3, 4]]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 1, 2], ['b', 3, 4], 'x']\n",
      "[['a', 1, 2], ['b', 3, 4]]\n",
      "[['a', 1, 2], ['b', 3, 4]]\n",
      "[['a', 1, 2], ['b', 3, 4], 'x']\n",
      "[['a', 1, 2], ['b', 3, 4]]\n",
      "[['a', 1, 2], ['b', 3, 4]]\n"
     ]
    }
   ],
   "source": [
    "c.append(\"x\")  # modify c\n",
    "print(c) # c reflects the change\n",
    "print(d) # d is a copy and is not changed\n",
    "print(e) # e is a copy and is not changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 1, 2, 'z'], ['b', 3, 4], 'x']\n",
      "[['a', 1, 2, 'z'], ['b', 3, 4]]\n",
      "[['a', 1, 2], ['b', 3, 4]]\n",
      "[['a', 1, 2, 'z'], ['b', 3, 4], 'x']\n",
      "[['a', 1, 2, 'z'], ['b', 3, 4]]\n",
      "[['a', 1, 2], ['b', 3, 4]]\n"
     ]
    }
   ],
   "source": [
    "a.append(\"z\")  # modify list a, an element in c\n",
    "print(c) # c reflects change\n",
    "print(d) # d copies the structure of c and reflects the change\n",
    "print(e) # is a deep copy and is not affected by changes to underlying elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 1, 2, 'z']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.insert(i, x)`\n",
    "    - Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).\n",
    "\n",
    "- `list.extend(iterable)`\n",
    "    - Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'joe', 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'joe', 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, \"joe\") # inserts joe at the location of the 4th comma between 1.68 and mom\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, ['joe', 2.0], 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, ['joe', 2.0], 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, [\"joe\", 2.0])  # trying to insert multiple items by using a list inserts a list\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "insert expected 2 arguments, got 3",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[28], line 2\u001b[0m\n",
      "\u001b[1;32m      1\u001b[0m fam \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mliz\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m1.73\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124memma\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m1.68\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmom\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m1.71\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdad\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m1.89\u001b[39m]\n",
      "\u001b[0;32m----> 2\u001b[0m \u001b[43mfam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minsert\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mjoe\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2.0\u001b[39;49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# like append, you can only insert one item\u001b[39;00m\n",
      "\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m# trying to insert multiple items causes and error\u001b[39;00m\n",
      "\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(fam)\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: insert expected 2 arguments, got 3"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.insert(4, \"joe\", 2.0)  # like append, you can only insert one item\n",
    "# trying to insert multiple items causes and error\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'joe', 2.0]\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'joe', 2.0]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.extend([\"joe\", 2.0]) # lets you add multiple items, but at the end\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 1.73, 'emma', 1.68, 'joe', 2.0, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 1.73, 'emma', 1.68, 'joe', 2.0, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam[4:4] = [\"joe\", 2.0] # Use slice and assignment to insert multiple items in a specific position\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.remove(x)`\n",
    "    - Remove the first item from the list whose value is x. It is an error if there is no such item.\n",
    "\n",
    "- `list.pop([i])`\n",
    "    - Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.\n",
    "\n",
    "- `list.clear()`\n",
    "    - Remove all items from the list. Equivalent to del a[:].\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.remove(\"liz\")\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['liz', 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "['liz', 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.71, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.remove(1.71) # only removes the first match\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.89\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad']\n",
      "1.89\n",
      "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad']\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "j = fam.pop()  # if you don't specify an index, it pops the last item in the list\n",
    "# default behavior of pop() without any arguments is like a stack. last in first out\n",
    "print(j)\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "liz\n",
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n",
      "liz\n",
      "[1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n"
     ]
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "j = fam.pop(0)  # you can also specify an index.\n",
    "# Using index 0 makes pop behave like a queue. first in first out\n",
    "print(j)\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "fam.clear()\n",
    "print(fam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "- `list.index(x)`\n",
    "    - Return zero-based index in the list of the first item whose value is x. Raises a ValueError if there is no such item.\n",
    "- `list.count(x)`\n",
    "    - Return the number of times x appears in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n",
    "fam.index(\"emma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "3 is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[37], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mfam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\n",
      "\u001b[0;31mValueError\u001b[0m: 3 is not in list"
     ]
    }
   ],
   "source": [
    "fam.index(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "letters = [\"a\", \"b\", \"c\", \"a\", \"a\"]\n",
    "print(letters.count(\"a\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "fam2 = [[\"liz\", 1.73],\n",
    "[\"emma\", 1.68],\n",
    "[\"mom\", 1.71],\n",
    "[\"dad\", 1.89]]\n",
    "print(fam2.count(\"emma\"))  # the string by itself does not exist\n",
    "print(fam2.count([\"emma\", 1.68]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `list.sort(key=None, reverse=False)`\n",
    "    - Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).\n",
    "\n",
    "- `list.reverse()`\n",
    "    - Reverse the elements of the list in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fam.reverse()  # no output to 'capture', the list is changed in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.89, 'dad', 1.71, 'mom', 1.68, 'emma', 1.73, 'liz']\n",
      "[1.89, 'dad', 1.71, 'mom', 1.68, 'emma', 1.73, 'liz']\n"
     ]
    }
   ],
   "source": [
    "print(fam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mfam\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# can't sort floats and string\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'float'"
     ]
    }
   ],
   "source": [
    "fam.sort()  # can't sort floats and string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "some_digits = [4, 2, 7, 9, 2, 5.1, 3]\n",
    "some_digits.sort()  # the list is sorted in place. no need to resave the output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'some_digits' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[43], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43msome_digits\u001b[49m)  \u001b[38;5;66;03m# preserves numeric data types\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mNameError\u001b[0m: name 'some_digits' is not defined"
     ]
    }
   ],
   "source": [
    "print(some_digits)  # preserves numeric data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(some_digits[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'some_digits' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[44], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43msome_digits\u001b[49m\u001b[38;5;241m.\u001b[39msort(reverse \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(some_digits)\n",
      "\n",
      "\u001b[0;31mNameError\u001b[0m: name 'some_digits' is not defined"
     ]
    }
   ],
   "source": [
    "some_digits.sort(reverse = True)\n",
    "print(some_digits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "some_digits = [4, 2, 7, 9, 2, 5.1, 3] # create a new list\n",
    "sorted(some_digits)  # sorted will return a sorted copy of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'some_digits' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[45], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43msome_digits\u001b[49m  \u001b[38;5;66;03m# the list is unaffected\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mNameError\u001b[0m: name 'some_digits' is not defined"
     ]
    }
   ],
   "source": [
    "some_digits  # the list is unaffected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Strings\n",
    "\n",
    "## A string is a sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit = \"bananas\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[0]  # Python is 0-indexed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[-1] # last letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "string indices must be integers, not 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[86], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mfruit\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.5\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: string indices must be integers, not 'float'"
     ]
    }
   ],
   "source": [
    "fruit[1.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `len()` tells you the length of a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Subsetting Strings and strings as iterables\n",
    "\n",
    "You can subset and slice a string much like you would a list or tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = 'abcdefghijklmnopqrstuvwxyz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'efghi'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4:9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s[-6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a!\n",
      "b!\n",
      "c!\n",
      "d!\n",
      "e!\n",
      "a!\n",
      "b!\n",
      "c!\n",
      "d!\n",
      "e!\n"
     ]
    }
   ],
   "source": [
    "for x in s[0:5]:\n",
    "    print(x + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings are immutable\n",
    "\n",
    "This means that when you use a method on a string, it does not modify the string itself and returns a new string object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[91], line 2\u001b[0m\n",
      "\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# strings are immutable. You cannot modify a string that has been created.\u001b[39;00m\n",
      "\u001b[0;32m----> 2\u001b[0m \u001b[43ms\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# strings are immutable. You cannot modify a string that has been created.\n",
    "s[0] = 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bbcdefghijklmnopqrstuvwxyz'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'b' + s[1:] # if i wanted the string where the first letter is now b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STATS 21 PYTHON AND OTHER TECHNOLOGIES FOR DATA SCIENCE\n",
      "Stats 21 python and other technologies for data science\n",
      "Stats 21 Python And Other Technologies For Data Science\n",
      "stats 21 python and other technologies for data science\n",
      "STATS 21 python and other technologies for data science\n",
      "STATS 21 PYTHON AND OTHER TECHNOLOGIES FOR DATA SCIENCE\n",
      "Stats 21 python and other technologies for data science\n",
      "Stats 21 Python And Other Technologies For Data Science\n",
      "stats 21 python and other technologies for data science\n",
      "STATS 21 python and other technologies for data science\n"
     ]
    }
   ],
   "source": [
    "name = \"STATS 21 python and other technologies for data science\"\n",
    "print(name.upper())\n",
    "print(name.capitalize()) # first character is capitalized\n",
    "print(name.title())     # first character of each word is capitalized\n",
    "print(name.lower())\n",
    "print(name) # string itself is not modified"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Count how many times a letter appears"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for letter in name:\n",
    "    if letter == \"e\":\n",
    "        count = count + 1\n",
    "print(count)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can be achieved with a simple method:\n",
    "name.count(\"e\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.index('A') # index of the first instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.endswith(\"k\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.endswith(\"e\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.startswith(\"s\")  # case sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   miles chen \n",
      "\n",
      "\n",
      "\n",
      "   miles chen \n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# create multi-line strings with triple quotes\n",
    "name2 = '''   miles chen \n",
    "\n",
    "\n",
    "'''\n",
    "print(name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'miles chen'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2.strip()  # removes extra whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   miles chen \\n\\n\\n'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2 # remember strings are immutable, the original string still has the white space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  string.split() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['miles', 'chen']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2.split() # the result of split() is a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2,3,4,7,8']\n",
      "['2', '3', '4', '7', '8']\n",
      "['2,3,4,7,8']\n",
      "['2', '3', '4', '7', '8']\n"
     ]
    }
   ],
   "source": [
    "num_string = \"2,3,4,7,8\"\n",
    "print(num_string.split()) # defaults to splitting on space\n",
    "print(num_string.split(','))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 7, 8]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list comprehension (covered later) to convert the split strings into int\n",
    "[int(x) for x in num_string.split(',')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 7, 8]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the list comprehension is a more concise version of the following code\n",
    "l = []\n",
    "for x in num_string.split(','):\n",
    "    l.append(int(x))\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STATS 21 python and other technologies for data science\n",
      "False\n",
      "STATS 21 python and other technologies for data science\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(name)\n",
    "print(name.isalpha()) # has spaces and digits, so it is not strictly alpha\n",
    "name3 = \"abbaAZ\"\n",
    "name3.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name4 = \"abbaAZ4\"\n",
    "name4.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LYRICS TO THE SONG HALLELUJAH\n",
      "WELL I'VE HEARD THERE WAS A SECRET CHORD\n",
      "THAT DAVID PLAYED AND IT PLEASED THE LORD\n",
      "BUT YOU DON'T REALLY CARE FOR MUSIC, DO YOU?\n",
      "['Lyrics', 'to', 'the', 'song', 'Hallelujah', 'Well', \"I've\", 'heard', 'there', 'was', 'a', 'secret', 'chord', 'That', 'David', 'played', 'and', 'it', 'pleased', 'the', 'Lord', 'But', 'you', \"don't\", 'really', 'care', 'for', 'music,', 'do', 'you?']\n",
      "LYRICS TO THE SONG HALLELUJAH\n",
      "WELL I'VE HEARD THERE WAS A SECRET CHORD\n",
      "THAT DAVID PLAYED AND IT PLEASED THE LORD\n",
      "BUT YOU DON'T REALLY CARE FOR MUSIC, DO YOU?\n",
      "['Lyrics', 'to', 'the', 'song', 'Hallelujah', 'Well', \"I've\", 'heard', 'there', 'was', 'a', 'secret', 'chord', 'That', 'David', 'played', 'and', 'it', 'pleased', 'the', 'Lord', 'But', 'you', \"don't\", 'really', 'care', 'for', 'music,', 'do', 'you?']\n"
     ]
    }
   ],
   "source": [
    "# strings can span multiple lines with triple quotes \n",
    "long_string = \"\"\"Lyrics to the song Hallelujah\n",
    "Well I've heard there was a secret chord\n",
    "That David played and it pleased the Lord\n",
    "But you don't really care for music, do you?\"\"\"\n",
    "shout = long_string.upper()\n",
    "print(shout)\n",
    "word_list = long_string.split() # separates at spaces\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Lyrics to the song Hallelujah',\n",
       " \"Well I've heard there was a secret chord\",\n",
       " 'That David played and it pleased the Lord',\n",
       " \"But you don't really care for music, do you?\"]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_string.splitlines() # separates at line ends\n",
    "# you'll notice that python defaults to using single quotes, but if the string contains an apostrophe,\n",
    "# it will use double quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_string.count(\"e\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Searching for a letter\n",
    "\n",
    "~~~\n",
    "long_string = \"\"\"Lyrics to the song Hallelujah\n",
    "Well I've heard there was a secret chord\n",
    "That David played and it pleased the Lord\n",
    "But you don't really care for music, do you?\"\"\"\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def myfind(string, letter):\n",
    "    index = 0\n",
    "    while index < len(string):\n",
    "        if string[index] == letter:\n",
    "            return index\n",
    "        index = index + 1\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfind(long_string, \"t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python already has a find method built in\n",
    "long_string.find(\"t\") # index of the first instance of 't'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_string.index('t') # string.index() and string.find() are similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_string.find('$') # string.find() returns a -1 if the character doesn't exist in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[71], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mlong_string\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m$\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# string.index() returns error if the character doesn't exist in the string.\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "long_string.index('$')  # string.index() returns error if the character doesn't exist in the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `in` operator\n",
    "\n",
    "returns a boolean value if the first string is a substring of the second string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'a' in 'bananas'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'nan' in 'bananas'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'bad' in 'bananas'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# String comparisons\n",
    "\n",
    "Use of `>` or `<` compares strings in alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A' < 'B'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' < 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Z' < 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# digits are less than capital letters\n",
    "'1' < 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'0' < '00'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# must treat digits like \"letters\" with alphabetical rules\n",
    "'11' < '101'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'!' < '@' # the sorting of symbols feels very arbitrary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['!', '#', '$', '%', '&', '(', ')', '*', ',', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '>', '?', '@', 'A', 'B', 'C', 'X', 'Y', 'Z', '[', '\\\\', ']', '^', 'a', 'b', 'c', 'x', 'y', 'z', '{', '|', '}']\n",
      "['!', '#', '$', '%', '&', '(', ')', '*', ',', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '>', '?', '@', 'A', 'B', 'C', 'X', 'Y', 'Z', '[', '\\\\', ']', '^', 'a', 'b', 'c', 'x', 'y', 'z', '{', '|', '}']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<positron-console-cell-81>:2: SyntaxWarning: invalid escape sequence '\\|'\n"
     ]
    }
   ],
   "source": [
    "# sorted order\n",
    "string = '!@#$%^&*()[]{}\\|;:,.<>/?1234567890ABCXYZabcxyz'\n",
    "x = sorted(string)\n",
    "print(x)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}