03_Python_fall_2022/02_python_intermediate_student_copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Intermediate Guide to Python\n",
    "\n",
    "*Avery Fernandez*\n",
    "\n",
    "University of Alabama Libraries, Research Data Services"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Outline for today:\n",
    "* data structures\n",
    "    - lists\n",
    "    - dictionaries\n",
    "    - tuple (brief)\n",
    "    - set (brief)\n",
    "* for loops\n",
    "    - lists\n",
    "    - dictionaries\n",
    "    - files\n",
    "* import libraries\n",
    "    - pip install\n",
    "* Open files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Data Structures\n",
    "\n",
    "There are 4 commonly used built-in data structures in python [1]:\n",
    "\n",
    "* lists\n",
    "* dictionaries\n",
    "* tuples\n",
    "* sets\n",
    "\n",
    "Data structures can store any of the basic data types\n",
    "\n",
    "[1] https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/06-Built-in-Data-Structures.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Lists\n",
    "Lists are a variable that can store multiple items\n",
    "\n",
    "What separates lists from other data structures is:\n",
    "* Order Matters\n",
    "* Can have duplicates\n",
    "* Can be changed\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Declare our first list\n",
    "myList = [\"apple\", \"orange\", \"apple\", \"banana\"] # lists are denoted by [] with commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'apple', 'banana']\n"
     ]
    }
   ],
   "source": [
    "# Each value has an index\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "orange\n",
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "print(myList[0])\n",
    "print(myList[1])\n",
    "print(myList[2])\n",
    "print(myList[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Indexing\n",
    "\n",
    "Extracting specific data.\n",
    "\n",
    "We can do 3 main things with indexing:\n",
    "* Regular Indexing\n",
    "* Negative Indexing\n",
    "* Ranges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n"
     ]
    }
   ],
   "source": [
    "print(myList[0]) # First Item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n"
     ]
    }
   ],
   "source": [
    "print(myList[-1]) # the last item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['orange', 'apple']\n",
      "['orange', 'apple']\n"
     ]
    }
   ],
   "source": [
    "print(myList[1:3]) # prints the indicated range of items\n",
    "print(myList[1:-1]) # works with negatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Common List Functions\n",
    "\n",
    "https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range\n",
    "\n",
    "Functions:\n",
    "* len(), outputs size of list\n",
    "* changing values\n",
    "* insert(), inputs value at given index\n",
    "* append(), adds to end of list\n",
    "* extend(), adds list to end of list\n",
    "* remove(), removes given item\n",
    "* pop(), removes index\n",
    "* del, removes index\n",
    "* clear(), clear list\n",
    "* copy(), copy lists\n",
    "* count(), outputs number of certain value\n",
    "* index(), returns index of given value\n",
    "* sorts(), sorts list\n",
    "* reverse(), reverse list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apples', 'oranges', 'bananas']\n"
     ]
    }
   ],
   "source": [
    "# creates a list of fruits\n",
    "fruits = [\"apples\", \"oranges\", \"bananas\"]\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# prints the number of elements in the list\n",
    "print(len(fruits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apples', 'grapes', 'bananas']\n"
     ]
    }
   ],
   "source": [
    "# changes the second item with grapes\n",
    "fruits[1] = \"grapes\"\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apples', 'grapes', 'oranges', 'bananas']\n"
     ]
    }
   ],
   "source": [
    "# inserts oranges in the position 2\n",
    "fruits.insert(2, \"oranges\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apples', 'grapes', 'oranges', 'bananas', 'strawberries']\n"
     ]
    }
   ],
   "source": [
    "# adds strawberries to the end of the list\n",
    "fruits.append(\"strawberries\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['raspberries', 'blueberries', 'peaches']\n"
     ]
    }
   ],
   "source": [
    "# creates a new list\n",
    "more_fruits = [\"raspberries\", \"blueberries\", \"peaches\"]\n",
    "print(more_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apples', 'grapes', 'oranges', 'bananas', 'strawberries', 'raspberries', 'blueberries', 'peaches']\n"
     ]
    }
   ],
   "source": [
    "# adds the more_fruits list to the end of the fruits list\n",
    "fruits.extend(more_fruits)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['grapes', 'oranges', 'bananas', 'strawberries', 'raspberries', 'blueberries', 'peaches']\n"
     ]
    }
   ],
   "source": [
    "# removes the element apples\n",
    "fruits.remove(\"apples\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['grapes', 'oranges', 'bananas', 'strawberries', 'raspberries', 'blueberries']\n"
     ]
    }
   ],
   "source": [
    "# removes the last element\n",
    "fruits.pop()\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['grapes', 'oranges', 'strawberries', 'raspberries', 'blueberries']\n"
     ]
    }
   ],
   "source": [
    "# removes the item in the index 2\n",
    "fruits.pop(2)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['grapes', 'oranges', 'strawberries', 'blueberries']\n"
     ]
    }
   ],
   "source": [
    "# removes the item in the index 3\n",
    "del fruits[3]\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'more_fruits' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/3993172110.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# deletes the list\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[0;32mdel\u001b[0m \u001b[0mmore_fruits\u001b[0m\u001b[0;34m\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[0mmore_fruits\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'more_fruits' is not defined"
     ]
    }
   ],
   "source": [
    "# deletes the list\n",
    "del more_fruits\n",
    "print(more_fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# empties the list\n",
    "fruits.clear()\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 4, 2, 4, 3, 6, 1, 8, 7]\n"
     ]
    }
   ],
   "source": [
    "# creates an array of numbers\n",
    "numbers = [3, 5, 4, 2, 4, 3, 6, 1, 8, 7]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 4, 2, 4, 3, 6, 1, 8, 7]\n"
     ]
    }
   ],
   "source": [
    "# copies the numbers to the second list\n",
    "numbers_two = numbers.copy()\n",
    "print(numbers_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# counts the number of 4s\n",
    "print(numbers.count(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# returns the index value for the number 2\n",
    "print(numbers.index(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "# sorts the numbers in order\n",
    "numbers.sort()\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 7, 6, 5, 4, 4, 3, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# reverse sorts\n",
    "numbers.reverse()\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Exercise One\n",
    "Create a list of with at least 5 vegetables, sort it in alphabetical order, print out the third item, then clear the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Garlic\n"
     ]
    }
   ],
   "source": [
    "vegetables = [\"Broccoli\", \"Lettuce\", \"Onion\", \"Garlic\", \"Cucumber\"]\n",
    "vegetables.sort()\n",
    "print(vegetables[2])\n",
    "vegetables.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Dictionaries\n",
    "Dictionaries use key and value pairs\n",
    "\n",
    "What separates dictionaries from the other storage types is:\n",
    "* Indexing is done with the keys\n",
    "* It is ordered\n",
    "* Can't have duplicates\n",
    "* Changeable\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html#dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# create our first dictionary\n",
    "myDictionary = {\"name\": \"John\", \"age\": 25, \"height\":5.123, \"adult\":False}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'John', 'age': 25, 'height': 5.123, 'adult': False}\n"
     ]
    }
   ],
   "source": [
    "print(myDictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/1020316534.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# you can't index like you did with lists\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmyDictionary\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "# you can't index like you did with lists\n",
    "print(myDictionary[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# indexing is instead done with the keys\n",
    "print(myDictionary[\"age\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Indexing\n",
    "As we saw above, dictionaries are not indexed with index values, but with their keys\n",
    "\n",
    "There are 3 functions that are useful for looking at the data stored in dictionaries\n",
    "* keys()\n",
    "* values()\n",
    "* items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['name', 'age', 'height', 'adult'])\n"
     ]
    }
   ],
   "source": [
    "# shows us the possible keys\n",
    "keys = myDictionary.keys()\n",
    "print(keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['John', 25, 5.123, False])\n"
     ]
    }
   ],
   "source": [
    "# shows us all the values\n",
    "values = myDictionary.values()\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('name', 'John'), ('age', 25), ('height', 5.123), ('adult', False)])\n"
     ]
    }
   ],
   "source": [
    "# shows us all the item combos\n",
    "items = myDictionary.items()\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Common Dictionary Functions\n",
    "\n",
    "Functions:\n",
    "* copy(), copy dictionary\n",
    "* changing values\n",
    "* get(), grabs the value of the given pair\n",
    "* update(), changes the values of the key value pair or adds the value\n",
    "* popitem(), removes last item inserted in\n",
    "* pop(), removes the item with the given key\n",
    "* del, removes index\n",
    "* dict(), can be used to copy\n",
    "* clear(), clear dictionary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'apples', 'vegetables': 'lettuce', 'soda': 'sprite'}\n"
     ]
    }
   ],
   "source": [
    "# creates new dictionary\n",
    "produce = {\"fruits\": \"apples\", \"vegetables\": \"lettuce\", \"soda\":\"sprite\"}\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'apples', 'vegetables': 'lettuce', 'soda': 'sprite'}\n"
     ]
    }
   ],
   "source": [
    "produce2 = produce.copy()\n",
    "print(produce2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'apples', 'vegetables': 'lettuce', 'soda': 'sprite', 'cheese': 'cheddar'}\n"
     ]
    }
   ],
   "source": [
    "# adds new key pair value\n",
    "produce[\"cheese\"] = \"cheddar\"\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'vegetables': 'lettuce', 'soda': 'sprite', 'cheese': 'cheddar'}\n"
     ]
    }
   ],
   "source": [
    "# changes the value for the key\n",
    "produce[\"fruits\"] = \"oranges\"\n",
    "print(produce)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oranges\n"
     ]
    }
   ],
   "source": [
    "# returns the value for the given key\n",
    "print(produce.get(\"fruits\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oranges\n"
     ]
    }
   ],
   "source": [
    "# returns the value for the given key\n",
    "print(produce[\"fruits\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'vegetables': 'celery', 'soda': 'sprite', 'cheese': 'cheddar'}\n"
     ]
    }
   ],
   "source": [
    "# changes the value for the key\n",
    "produce.update({\"vegetables\": \"celery\"})\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'vegetables': 'celery', 'soda': 'sprite', 'cheese': 'cheddar', 'chips': 'fritos'}\n"
     ]
    }
   ],
   "source": [
    "# adds if doesn't already exist\n",
    "produce.update({\"chips\": \"fritos\"})\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'vegetables': 'celery', 'soda': 'sprite', 'cheese': 'cheddar'}\n"
     ]
    }
   ],
   "source": [
    "# removes last pair added\n",
    "produce.popitem()\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'soda': 'sprite', 'cheese': 'cheddar'}\n"
     ]
    }
   ],
   "source": [
    "# removes pair with given key\n",
    "produce.pop(\"vegetables\")\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'oranges', 'soda': 'sprite'}\n"
     ]
    }
   ],
   "source": [
    "# removes pair with given key\n",
    "del produce[\"cheese\"]\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'produce' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/3392837558.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# deletes dictionary\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[0;32mdel\u001b[0m \u001b[0mproduce\u001b[0m\u001b[0;34m\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[0mproduce\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'produce' is not defined"
     ]
    }
   ],
   "source": [
    "# deletes dictionary\n",
    "del produce\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruits': 'apples', 'vegetables': 'lettuce', 'soda': 'sprite'}\n"
     ]
    }
   ],
   "source": [
    "# copies dictionary\n",
    "produce = dict(produce2)\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "# empties dictionary\n",
    "produce.clear()\n",
    "print(produce)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 2\n",
    "* Create a dictionary 5 food types and their foods like soda and sprite.\n",
    "* Print one of your values using key indexing.\n",
    "* Clear the dictionary, do not delete it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kit Kat\n"
     ]
    }
   ],
   "source": [
    "foodTypes = {\n",
    "    \"Soda\": \"Sprite\",\n",
    "    \"Chips\": \"Cheddar Lays\",\n",
    "    \"Sandwich\": \"Grilled Cheese\",\n",
    "    \"Candy\": \"Skittles\",\n",
    "    \"Chocolate\": \"Kit Kat\"\n",
    "}\n",
    "print(foodTypes[\"Chocolate\"])\n",
    "foodTypes.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Tuples\n",
    "A storage type that stores preset values\n",
    "\n",
    "Properties include:\n",
    "* Cannot be changed\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 5)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 3, 5)\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/4276842784.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# note that we can't change it:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# note that we can't change it:\n",
    "my_tuple[0] = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Sets\n",
    "One use-case is in removing duplicates of data\n",
    "\n",
    "Properties:\n",
    "* No duplicates allowed\n",
    "* Unordered\n",
    "* No index\n",
    "\n",
    "For more examples of sets, see: https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/06-Built-in-Data-Structures.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'banana', 'apple', 'orange'}\n"
     ]
    }
   ],
   "source": [
    "sets = {\"apple\", \"banana\", \"banana\", \"orange\"}\n",
    "print(sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Multi-dimensional Storage Types\n",
    "While it sounds complicated, it is just put storage types in other storage types:\n",
    "* Dictionaries in Lists\n",
    "* Lists in Dictionaries\n",
    "* Etc.\n",
    "\n",
    "https://nbviewer.org/github/jakevdp/WhirlwindTourOfPython/blob/master/06-Built-in-Data-Structures.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[255, 200, 255], [243, 123, 153]]\n",
      "255\n"
     ]
    }
   ],
   "source": [
    "# Lists in Lists\n",
    "pixels = [\n",
    "    [255, 200, 255],\n",
    "    [243, 123, 153]\n",
    "]\n",
    "print(pixels)\n",
    "print(pixels[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'name': 'Daniel', 'year': 'Sophmore'}, {'name': 'Tristan', 'year': 'Junior'}]\n",
      "Daniel\n"
     ]
    }
   ],
   "source": [
    "# Dictionaries in Lists\n",
    "students = [\n",
    "    {\n",
    "        \"name\": \"Daniel\",\n",
    "        \"year\": \"Sophmore\"\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Tristan\",\n",
    "        \"year\": \"Junior\"\n",
    "    }\n",
    "]\n",
    "print(students)\n",
    "print(students[0][\"name\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dataTypes': ['String', 'Int', 'Floats', 'Booleans'], 'storageTypes': ['Lists', 'Dictionaries', 'Sets', 'Tuples']}\n",
      "Lists\n"
     ]
    }
   ],
   "source": [
    "# Lists in Dictionaries\n",
    "teaching = {\n",
    "    \"dataTypes\": [\"String\", \"Int\", \"Floats\", \"Booleans\"],\n",
    "    \"storageTypes\": [\"Lists\", \"Dictionaries\", \"Sets\", \"Tuples\"]\n",
    "}\n",
    "print(teaching)\n",
    "print(teaching[\"storageTypes\"][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## For Loops\n",
    "\n",
    "With python, looping through these data sets will be a lot easier.\n",
    "\n",
    "for in range() is just looping through a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Looping is practically all the same, just slightly different\n",
    "\n",
    "Types of For Loops:\n",
    "* Lists\n",
    "* Dictionaries\n",
    "* Multi-Dimensional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### For Loops: Lists\n",
    "\n",
    "For loops with list can be achieved 2 ways:\n",
    "* values\n",
    "* indexes\n",
    "\n",
    "https://nbviewer.org/github/jakevdp/WhirlwindTourOfPython/blob/master/07-Control-Flow-Statements.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Lists: Value For Loop\n",
    "Just like for in range():\n",
    "\n",
    "Syntax: ```for {variableName} in {listName}:```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "Looping through the List and print out each value\n",
    "\n",
    "myList = [\"Lists\", \"Dictionaries\", \"Sets\", \"Tuples\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lists\n",
      "Dictionaries\n",
      "Sets\n",
      "Tuples\n"
     ]
    }
   ],
   "source": [
    "# looping through the values\n",
    "myList = [\"Lists\", \"Dictionaries\", \"Sets\", \"Tuples\"]\n",
    "for storageType in myList:\n",
    "    print(storageType)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Lists: Index For Loop\n",
    "We will loop through using the index values\n",
    "Syntax: ```for {variableName} in range(len({listName})):```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Lists\n",
      "1 Dictionaries\n",
      "2 Sets\n",
      "3 Tuples\n"
     ]
    }
   ],
   "source": [
    "for index in range(len(myList)):\n",
    "    print(index, myList[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Lists\n",
      "1 Dictionaries\n",
      "2 Sets\n",
      "3 Tuples\n"
     ]
    }
   ],
   "source": [
    "# Here is a similar way with enumerate:\n",
    "for idx, storageType in enumerate(myList):\n",
    "    print(idx, storageType)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Daniel', 'Sophomore', [90, 20, 100]]\n",
      "['Tristan', 'Junior', [100, 65, 87]]\n"
     ]
    }
   ],
   "source": [
    "# lists of lists\n",
    "students = [\n",
    "    [\"Daniel\", \"Sophomore\",[90,20,100]],\n",
    "    [\"Tristan\",\"Junior\", [100,65,87]]\n",
    "]\n",
    "for student in students:\n",
    "    print(student)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4 - loop through a lists of list and print only the scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "students = [\n",
    "    [\"Daniel\", \"Sophomore\",[90,20,100]],\n",
    "    [\"Tristan\",\"Junior\", [100,65,87]]\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90\n",
      "20\n",
      "100\n",
      "100\n",
      "65\n",
      "87\n"
     ]
    }
   ],
   "source": [
    "# extract and print just the numbers\n",
    "for student in students:\n",
    "    for score in student[2]:\n",
    "        print(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### For Loops: Dictionaries\n",
    "You can loop through multiple things based off what you want to do\n",
    "* keys\n",
    "* pairs\n",
    "\n",
    "https://realpython.com/iterate-through-dictionary-python/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Dictionaries: Keys For Loop\n",
    "Syntax: ```for {variableName} in {dictionary}:```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AL Alabama\n",
      "AK Alaska\n",
      "AZ Arizona\n",
      "AR Arkansas\n"
     ]
    }
   ],
   "source": [
    "# keys Loop\n",
    "states = {\n",
    "    \"AL\": \"Alabama\",\n",
    "    \"AK\": \"Alaska\",\n",
    "    \"AZ\": \"Arizona\",\n",
    "    \"AR\": \"Arkansas\"\n",
    "}\n",
    "for abbreviations in states:\n",
    "    print(abbreviations, states[abbreviations])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries: Pair For Loop\n",
    "Syntax: ```for {variableName} in {dictionary}:```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AL Alabama\n",
      "AK Alaska\n",
      "AZ Arizona\n",
      "AR Arkansas\n"
     ]
    }
   ],
   "source": [
    "# pairs Loop\n",
    "states = {\n",
    "    \"AL\": \"Alabama\",\n",
    "    \"AK\": \"Alaska\",\n",
    "    \"AZ\": \"Arizona\",\n",
    "    \"AR\": \"Arkansas\"\n",
    "}\n",
    "for abbreviations,state in states.items():\n",
    "    print(abbreviations, state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### For Loops: Multi-dimensional\n",
    "Multi-dimensional for loops are just integrating the separate for loops\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html#nested-list-comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5 - dictionary within list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name Daniel\n",
      "year Sophmore\n",
      "name Tristan\n",
      "year Junior\n"
     ]
    }
   ],
   "source": [
    "students = [\n",
    "    {\n",
    "        \"name\": \"Daniel\",\n",
    "        \"year\": \"Sophmore\"\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Tristan\",\n",
    "        \"year\": \"Junior\"\n",
    "    }\n",
    "]\n",
    "for student in students:\n",
    "    for info in student:\n",
    "        print(info, student[info])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Importing Libraries\n",
    "What makes python super powerful is that we can import vast amounts for libraries for almost any use case\n",
    "\n",
    "We will cover:\n",
    "* Pip Installing\n",
    "* Importing\n",
    "* Managing Files\n",
    "\n",
    "https://github.com/ualibweb/UALIB_Workshops/tree/master/06_Conda_fall_2022"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Installing Libraries\n",
    "We will be installing Numpy\n",
    "1. Open up the terminal\n",
    "2. Type ```pip install numpy```\n",
    "\n",
    "https://pip.pypa.io/en/stable/getting-started/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Importing\n",
    "Now we just have to tell python that we are going to use the library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "# import library\n",
    "import numpy\n",
    "print(numpy.random.randint(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77\n"
     ]
    }
   ],
   "source": [
    "# import specific functions\n",
    "from numpy import random\n",
    "print(random.randint(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97\n"
     ]
    }
   ],
   "source": [
    "# change import name\n",
    "import numpy as np\n",
    "print(np.random.randint(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Managing Files\n",
    "Now that we can download libraries and use them, lets quickly cover how to keep track of them\n",
    "\n",
    "* Find Packages\n",
    "* List Packages\n",
    "* Remove Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Find Packages\n",
    "https://pypi.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### List Packages\n",
    "In terminal type:\n",
    "```pip list```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Remove Packages\n",
    "In terminal type:\n",
    "```pip uninstall {packageName}```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Files\n",
    "Files allows us to store data for later uses or to import data\n",
    "\n",
    "* Reading Files\n",
    "* Writing Files\n",
    "* Deleting Files\n",
    "* Looping\n",
    "\n",
    "https://docs.python.org/3/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Reading Files\n",
    "Syntax: ```open({fileName}, \"r\")```\n",
    "\n",
    "Functions:\n",
    "* read()\n",
    "* readline()\n",
    "* close()\n",
    "\n",
    "https://docs.python.org/3/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"02_text_file.txt\", \"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this workshop, students will learn how to:\n",
      "* work with data structures including:\n",
      "- lists\n",
      "- dictionaries\n",
      "- tuples\n",
      "- sets\n",
      "* use for loops with:\n",
      "- lists\n",
      "- dictionaries\n",
      "- files\n",
      "* use conditional flow statements\n",
      "* import files, libraries, and install packages\n"
     ]
    }
   ],
   "source": [
    "# Prints out file\n",
    "f = open(\"02_text_file.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this wo\n"
     ]
    }
   ],
   "source": [
    "# Prints out first 10 characters\n",
    "f = open(\"02_text_file.txt\", \"r\")\n",
    "print(f.read(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this workshop, students will learn how to:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Prints out first line\n",
    "f = open(\"02_text_file.txt\", \"r\")\n",
    "print(f.readline())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this workshop, students will learn how to:\n",
      "\n",
      "* work with data structures including:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Prints out first two lines\n",
    "f = open(\"02_text_file.txt\", \"r\")\n",
    "print(f.readline())\n",
    "print(f.readline())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# closes files\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/2695178694.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"02_text_file.txt\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0minFile\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: I/O operation on closed file."
     ]
    }
   ],
   "source": [
    "with open(\"02_text_file.txt\", \"r\") as inFile:\n",
    "    f.readline()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Writing Files\n",
    "* Writing to a file\n",
    "* Appending to a file\n",
    "\n",
    "https://docs.python.org/3/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '02_write_file.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_203700/2015238865.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# File is empty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"02_write_file.txt\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '02_write_file.txt'"
     ]
    }
   ],
   "source": [
    "# File is empty\n",
    "f = open(\"02_write_file.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Write to a file, clears previous txt\n",
    "f = open(\"02_write_file.txt\", \"w\")\n",
    "f.write(\"Hi\\n\")\n",
    "f.write(\"Dear Reader,\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "Dear Reader,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Outputs File\n",
    "f = open(\"02_write_file.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Appends to file\n",
    "f = open(\"02_write_file.txt\", \"a\")\n",
    "f.write(\"Even more writing\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "Dear Reader,\n",
      "Even more writing\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Outputs File\n",
    "f = open(\"02_write_file.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# removes file\n",
    "import os\n",
    "os.remove(\"02_write_file.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Looping through files\n",
    "This allows us to go through each individual line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this workshop, students will learn how to:\n",
      "\n",
      "* work with data structures including:\n",
      "\n",
      "- lists\n",
      "\n",
      "- dictionaries\n",
      "\n",
      "- tuples\n",
      "\n",
      "- sets\n",
      "\n",
      "* use for loops with:\n",
      "\n",
      "- lists\n",
      "\n",
      "- dictionaries\n",
      "\n",
      "- files\n",
      "\n",
      "* use conditional flow statements\n",
      "\n",
      "* import files, libraries, and install packages\n"
     ]
    }
   ],
   "source": [
    "# Avery's maybe awesome method\n",
    "\n",
    "for line in open(\"02_text_file.txt\"):\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In this workshop, students will learn how to:\n",
      "\n",
      "* work with data structures including:\n",
      "\n",
      "- lists\n",
      "\n",
      "- dictionaries\n",
      "\n",
      "- tuples\n",
      "\n",
      "- sets\n",
      "\n",
      "* use for loops with:\n",
      "\n",
      "- lists\n",
      "\n",
      "- dictionaries\n",
      "\n",
      "- files\n",
      "\n",
      "* use conditional flow statements\n",
      "\n",
      "* import files, libraries, and install packages\n"
     ]
    }
   ],
   "source": [
    "# more explicit and useful for reading/writing\n",
    "\n",
    "with open('02_text_file.txt', 'r') as infile:\n",
    "          for line in infile:\n",
    "              print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Exercise 6\n",
    "* Create a List with at least 5 elements\n",
    "* Loop through the list\n",
    "* Write elements to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "myList = [\"Hotdog\", \"Ketchup\", \"Mustard\", \"Bun\", \"Relish\"]\n",
    "with open(\"02_output_file.txt\", \"w\") as outFile:\n",
    "    for item in myList:\n",
    "        outFile.write(item+\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}