wk2/MY470_wk2_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# Data Types in Python\n",
    "### Week 2 Lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "* About Python\n",
    "* Scalars: `int`, `float`, `bool`, `None`\n",
    "    * Operators: arithmetic, boolean, comparison, assignment, membership\n",
    "* Non-scalars: `list`, `tuple`, `str`, `set`, `dict`\n",
    "    * Methods\n",
    "    * Ordered vs. unordered non-scalars       \n",
    "    * Mutable vs. immutable non-scalars\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![Python on xkcd](figs/xkcd.png \"Python on xkcd\")\n",
    "\n",
    "   Source: http://xkcd.com/353/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why Python?\n",
    "\n",
    "![Python](figs/python.png \"Python\")\n",
    "\n",
    "* Open-source – free and well-documented\n",
    "* Simple and concise syntax\n",
    "* Many useful libraries\n",
    "* Cross-platform\n",
    "* [Widely used in industry and science](https://youtu.be/cKzP61Gjf00)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python vs. Java: Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Java\n",
    "\n",
    "```[java]\n",
    "public class HelloWorld\n",
    "{\n",
    "    public static void main (String[] args)\n",
    "    {\n",
    "        System.out.println(\"Hello world!\");\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python vs. R and Other Languages: Speed\n",
    "\n",
    "![Language comparison 1](figs/plb-lang.png \"Language comparison 1\")\n",
    "\n",
    "![Language comparison 2](figs/plb-lib.png \"Language comparison 2\")\n",
    "\n",
    "Source: https://attractivechaos.github.io/plb/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Brief History of Python\n",
    "\n",
    "![Guido van Rossum](figs/van_rossum_2006.jpg \"Guido van Rossum\")\n",
    "\n",
    "* Started in December 1989 by Guido van Rossum, BDFL (Benevolent Dictator for Life)\n",
    "* Python 2.0 released in 2000\n",
    "* Python 3.0, which is backward-incompatible, released in 2008\n",
    "* End of Life date for Python 2.7 was January 1st, 2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## From Last Week: Objects, Data Types, and Expressions\n",
    "\n",
    "* Computer programs manipulate objects\n",
    "* Objects have types\n",
    "  * Scalar — indivisible\n",
    "  * Non-scalar — with internal structure\n",
    "* Expressions combine objects and operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scalar Data Types\n",
    "\n",
    "* Integer\n",
    "* Float\n",
    "* Boolean\n",
    "* NoneType\n",
    "* (String is non-scalar in Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2))\n",
    "print(type(1.125))\n",
    "print(type(True))\n",
    "print(type(None))\n",
    "print(type('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting between Scalar Data Types\n",
    "\n",
    "* Use the name of a type to convert values to that type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123.0 32\n"
     ]
    }
   ],
   "source": [
    "a = float(123)\n",
    "b = int('32')\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operators\n",
    "\n",
    "\n",
    "* Arithmetic\n",
    "* Boolean\n",
    "* Comparison\n",
    "* Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Arithmetic Operators\n",
    "\n",
    "* `+` &nbsp;&nbsp; addition\n",
    "* `-` &nbsp;&nbsp; subtraction\n",
    "* `*` &nbsp;&nbsp; multiplication\n",
    "* `/` &nbsp;&nbsp; division\n",
    "* `%` &nbsp;&nbsp; modulus\n",
    "* `//` &nbsp;&nbsp; floor division\n",
    "* `**` &nbsp;&nbsp; exponent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "abc\n",
      "6\n",
      "aaah!\n"
     ]
    }
   ],
   "source": [
    "# + and * have different meanings depending on the types of objects with which they are used\n",
    "print(2 + 2)\n",
    "print('a' + 'bc')\n",
    "print(3 * 2)\n",
    "print(3 * 'a' + 'h!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean Operators\n",
    "\n",
    "* `and`\n",
    "* `or`\n",
    "* `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True and False)\n",
    "print(True or False)\n",
    "print(not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparison Operators\n",
    "\n",
    "* `==` &nbsp;&nbsp; equals\n",
    "* `!=` &nbsp;&nbsp; does not equal\n",
    "* `>` &nbsp;&nbsp; is greater than\n",
    "* `<=` &nbsp;&nbsp; is less than or equal, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignment Operators\n",
    "\n",
    "* `=` &nbsp;&nbsp; assign right operand to left operand\n",
    "* `+=` &nbsp;&nbsp; add right operand to left operand and assign to left operand\n",
    "* `-=` &nbsp;&nbsp; subtract right operand from left operand and assign to left operand, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "a += 3  # Equivalent to a = a + 3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparison vs. Assignment Operators\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 2  # This is assignment\n",
    "print(a == 1)  # This is test for equality. It returns bool."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Non-Scalar Data Types\n",
    "\n",
    "* List – a mutable ordered sequence of values\n",
    "* Tuple – an immutable ordered sequence of values\n",
    "* String – an immutable ordered sequence of characters\n",
    "* Set – a mutable unordered collection of unique values\n",
    "* Dictionary – a set of key/value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 'a', 'a'] {'b', 1, 2, 'a'}\n"
     ]
    }
   ],
   "source": [
    "list_var = [1, 2, 2, 'a', 'a']  # list\n",
    "tuple_var = (1, 2, 'a', 'b')  # tuple\n",
    "set_var = {1, 2, 2, 'a', 'b'}  # set \n",
    "dict_var = {1: 'a', 2: 'b', 3: 'c'}  # dictionary\n",
    "print(list_var, set_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting between Non-Scalar Data Types\n",
    "\n",
    "* Use the name of a type to convert values to that type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) {1: 'a', 2: 'b', 3: 'c'}\n"
     ]
    }
   ],
   "source": [
    "tup = tuple([1, 2, 3]) \n",
    "dic = dict( [(1, 'a'), (2, 'b'), (3, 'c')] )\n",
    "print(tup, dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Membership Operator\n",
    "\n",
    "* `in` &nbsp;&nbsp; left element is in right non-scalar\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print('x' not in 'abcdefg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Length of Non-Scalar Objects\n",
    "\n",
    "* The `len()` function returns the length of the element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "5\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print( len( [0, 1, 2] ) )\n",
    "print( len('ab') )\n",
    "print( len( (1, 2, 3, 4, 'a') ) )\n",
    "print( len( {1: 'a', 2: 'b'} ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Non-Scalar Data Types: Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Use len() to count the number of unique letters in the string below\n",
    "\n",
    "s = 'jackie will budget for the most expensive zoology equipment'\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings\n",
    "\n",
    "* You can write string literals in different ways\n",
    "  * Single quotes: `'allows embedded \"double\" quotes'`\n",
    "  * Double quotes: `\"allows embedded 'single' quotes\"`\n",
    "  * Triple quoted: `'''Three single quotes'''`, `\"\"\"Three double quotes\"\"\"`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Triple quoted strings may span multiple lines - \\nall associated whitespace will be included \\nin the string literal.'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Triple quoted strings may span multiple lines - \n",
    "all associated whitespace will be included \n",
    "in the string literal.'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Strings implement all of the common sequence operations we will shortly discuss, along with some additional methods: http://docs.python.org/3/library/stdtypes.html#string-methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objects Have Methods Associated with Them\n",
    "\n",
    "### `object.method()`\n",
    "\n",
    "Use the period `.` to link the method to the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string1 = 'Hello'\n",
    "\n",
    "string1 + '!'  # This is an operator. Operators combine objects in expressions.\n",
    "len(string1)  # This is a function. Functions take objects as arguments.\n",
    "string1.upper()  # This is a method. Methods are attached to objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String Methods: Formatting\n",
    "\n",
    "* `S.upper()` – change to upper case\n",
    "* `S.lower()` – change to lower case\n",
    "* `S.capitalize()` – capitalize the first word\n",
    "* `S.find(S1)` – return the index of the first instance of input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAKE ME SCREAM!\n",
      "Make this into a proper sentence.\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print('Make me scream!'.upper())\n",
    "x = 'make this into a proper sentence'\n",
    "print(x.capitalize() + '.')\n",
    "\n",
    "print('Find the first \"i\" in this sentence.'.find('i'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String Methods: `strip` and `replace`\n",
    "\n",
    "* `S.replace(S1, S2)` – find all instances of S1 and change to S2\n",
    "* `S.strip(S1)` – remove whitespace characters from the beginning and end of a string (useful when reading in from a file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ThiS iS a long Sentence that we will uSe aS an example.\n",
      "\n",
      "This is a long sentence that we will use as an example.\n",
      "Thisisalongsentencethatwewilluseasanexample.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = ' This is a long sentence that we will use as an example.\\n'\n",
    "print(x.replace('s', 'S'))\n",
    "print(x.strip())\n",
    "print(x.replace(' ', ''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String Methods: `split` and `join`\n",
    "\n",
    "* `S.split(S1)` – split the string into a list\n",
    "* `S.join(L)` – combine the input sequence into a single string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this', 'is', 'a', 'collection', 'of', 'words', 'i', 'would', 'like', 'to', 'break', 'it', 'into', 'tokens']\n",
      "['this is a c', 'llecti', 'n ', 'f w', 'rds i w', 'uld like t', ' break it int', ' t', 'kens']\n",
      "this-is-a-collection-of-words-i-would-like-to-break-it-into-tokens\n"
     ]
    }
   ],
   "source": [
    "x = 'this is a collection of words i would like to break it into tokens'\n",
    "y = x.split()    # default is to split on ' '\n",
    "print(y)\n",
    "print(x.split('o')) \n",
    "\n",
    "x_new = '-'.join(y)\n",
    "print(x_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String Methods: Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Use string methods to create a properly formatted sentence \n",
    "# from the words below:\n",
    "\n",
    "ls = ['  ThiS', 'SenTence', 'NEEDS', 'bEttEr!', 'foRmatting']\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Unordered Types vs. Sequences\n",
    "\n",
    "* Unordered types: `set`, `dict`\n",
    "* Ordered (sequence) types: `str`, `list`, `tuple`\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b', 1, 2, 'a'}\n"
     ]
    }
   ],
   "source": [
    "st = {1, 2, 2, 'a', 'b'}  # sets are unordered\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Set Methods\n",
    "\n",
    "![Set operations](figs/sets.png \"Set operations\")\n",
    "\n",
    "* `S1.union(S2)`, `S1 | S2` — elements in S1 or S2, or both\n",
    "* `S1.intersection(S2)`, `S1 & S2` — elements in both S1 and S2\n",
    "* `S1.difference(S2)`, `S1 - S2` — elements in S1 but not in S2\n",
    "* `S1.symmetric_difference(S2)`, `S1 ^ S2` — elements in S1 or S2 but not both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'m', 'r', 'e', 't'}\n"
     ]
    }
   ],
   "source": [
    "st1 = set('homophily')\n",
    "st2 = set('heterophily')\n",
    "print(st1 ^ st2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionary Operations: Indexing\n",
    "\n",
    "* Dictionaries are indexed by keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "astrophysicist\n"
     ]
    }
   ],
   "source": [
    "mydic = {'Howard': 'aerospace engineer', 'Leonard': 'physicist', \n",
    "         'Sheldon': 'physicist', 'Penny': 'waitress', \n",
    "         'Raj': 'astrophysicist'}\n",
    "print(mydic['Raj'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequence Operations: Indexing\n",
    "\n",
    "* Lists, tuples, and strings are indexed by numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ABCDEFG'[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing in Python starts from 0!\n",
    "\n",
    "![Indexing sequences](figs/indexing.jpg \"Indexing sequences\")\n",
    "\n",
    "Source: https://devrant.com/rants/1798534/array-start-from-zero-d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequence Operations: Indexing\n",
    "\n",
    "* Use `elem[index]` to extract individual sub-elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "c\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-3b1b01b1ae7f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;34m'abc'\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# use negative numbers to index from the end\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print( 'abc'[0] ) \n",
    "print( ('a', 'b', 'c')[-1])  # use negative numbers to index from the end\n",
    "print( ['a', 'b', 'c'][3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequence Operations: Slicing\n",
    "\n",
    "* Use `elem[start:end]` to get sub-sequence starting from index `start` and ending at index `end-1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 30, 40]\n",
      "[10, 20, 30]\n",
      "[20, 30, 40, 50]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [10, 20, 30, 40, 50]\n",
    "print( ls[1:4] ) \n",
    "print( ls[:3] )\n",
    "print( ls[1:] )\n",
    "\n",
    "ls[:] == ls[0:len(ls)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequence Operations: Extended Slices\n",
    "\n",
    "* Use `elem[start:end:step]` to get sub-sequence starting from index `start`, in steps of `step`, ending at index `end-1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 30, 50]\n",
      "[50, 40, 30, 20, 10]\n"
     ]
    }
   ],
   "source": [
    "ls = [10, 20, 30, 40, 50]\n",
    "print( ls[::2] )  # get elements with even indeces\n",
    "print( ls[::-1] )  # get elements in reverse order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing and Slicing: Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Use indexing and slicing to create a new string that contains \n",
    "# the 2nd, 4th, 5th, 6th, and last characters from the string below\n",
    "\n",
    "s = 'abcdefghijklmnopqrstuvwxyz'\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More Sequence Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1) (1, 1, 1, 2, 2)\n",
      "2\n",
      "7\n",
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "tup1 = 3 * (1,)  # Notice that tuple of length 1 needs comma!\n",
    "tup2 = tup1 + (2, 2)  # Concatenate the two elements\n",
    "print(tup1, tup2)\n",
    "\n",
    "print( max(tup2) )  # or min()\n",
    "print( sum(tup2) )\n",
    "print( tup2.count(1) )\n",
    "print( tup2.index(2) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Why use tuples? \n",
    "    * ⚡️ They use less memory than lists\n",
    "    * They can be used as dictionary keys; lists can't"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mutability\n",
    "\n",
    "* Immutable types: `str`, `tuple`, and all scalars\n",
    "* Mutable types: `list`, `set`, `dict`\n",
    "\n",
    "**Objects of mutable types can be modified once they are created.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c'}\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "dic = {1:'a', 2:'b'}\n",
    "dic[3] = 'c'\n",
    "print(dic)\n",
    "\n",
    "ls = [5, 4, 1, 3, 2]\n",
    "ls.sort()\n",
    "print(ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mutability Can Be Quite Convenient\n",
    "\n",
    "There are several useful list methods, see http://docs.python.org/3/library/stdtypes.html#mutable-sequence-types:\n",
    "\n",
    "* `L.append(e)`\n",
    "* `L.insert(i, e)`\n",
    "* `L.remove(e)`\n",
    "* `L.extend(L1)`\n",
    "* `L.pop(i)`\n",
    "* `L.sort()`\n",
    "* `L.reverse()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "ls1 = [1, 2, 3]\n",
    "ls1.append(4)\n",
    "print(ls1)\n",
    "ls1.extend([5, 6, 7, 8, 9, 10])\n",
    "print(ls1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mutability Can Also Be Dangerous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [4, 5, 6, 7]]\n",
      "[1, 2, 3, [4, 5, 6, 7, 8, 9, 10]]\n"
     ]
    }
   ],
   "source": [
    "ls1 = [1, 2, 3]\n",
    "ls2 = [4, 5, 6, 7]\n",
    "\n",
    "ls1.append(ls2)\n",
    "print(ls1)\n",
    "\n",
    "ls2.extend([8, 9, 10])\n",
    "print(ls1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Aliasing vs. Cloning\n",
    "\n",
    "![Aliasing](figs/aliasing.png \"Aliasing\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "ls1 = [1, 2, 3]\n",
    "ls2 = ls1[:]  # Using [:] is one way to clone\n",
    "\n",
    "ls1.reverse()\n",
    "print(ls2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Methods:  `append` vs. `extend`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 4, 5, 8, 7, 6]\n"
     ]
    }
   ],
   "source": [
    "mylist = [1, 2, 3, 4]\n",
    "mylist.append(5)\n",
    "print(mylist)\n",
    "\n",
    "mylist.extend([8, 7, 6])\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Methods: `remove` vs. `pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n",
      "3 [2, 4]\n"
     ]
    }
   ],
   "source": [
    "mylist = [1, 2, 3, 4]\n",
    "\n",
    "mylist.remove(1)\n",
    "print(mylist)\n",
    "\n",
    "popped = mylist.pop(1)\n",
    "print(popped, mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Methods: `L.sort()` vs. `sorted(L)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[10, 9, 6, 8, 7]\n",
      "[10, 9, 6, 8, 7] [6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "mylist = [4, 5, 2, 1, 3]\n",
    "mylist.sort()  # Sorts in-place. It is more efficient but overwrites the input.\n",
    "print(mylist)\n",
    "\n",
    "mylist = [10, 9, 6, 8, 7]\n",
    "sorted(mylist) \n",
    "print(mylist)\n",
    "\n",
    "newlist = sorted(mylist)  # Creates a new list that is sorted, not changing the original.\n",
    "print(mylist, newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Aliasing and Cloning: Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "What will the following program print?\n",
    "\n",
    "```\n",
    "ls1 = [11, 3, 8, 6, 6, 1]\n",
    "ls2 = ls1\n",
    "ls2[2] = 0\n",
    "print(ls1)\n",
    "```\n",
    "\n",
    "* (A) [11, 3, 8, 6, 6, 1]\n",
    "* (B) [11, 0, 8, 6, 6, 1]\n",
    "* (C) [11, 3, 0, 6, 6, 1]\n",
    "* (D) 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Types in Python\n",
    "\n",
    "\n",
    "| Type     | Scalar     | Mutability | Order   \n",
    "| :------: |:----------:|:----------:| :---------:\n",
    "| `int`    | scalar     | immutable  |             \n",
    "| `float`  | scalar     | immutable  |  \n",
    "| `bool`   | scalar     | immutable  | \n",
    "| `None`   | scalar     | immutable  | \n",
    "| `str`    | non-scalar | immutable  | ordered\n",
    "| `tuple`  | non-scalar | immutable  | ordered\n",
    "| `list`   | non-scalar | mutable    | ordered\n",
    "| `set`    | non-scalar | mutable    | unordered\n",
    "| `dict`   | non-scalar | mutable    | unordered\n",
    "\n",
    "* Objects have types\n",
    "* Objects have methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "-------\n",
    "\n",
    "* **Lab**: Lists, lists, lists (and some strings)\n",
    "* **Next week**: Control flow in Python"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}