Week-11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# What are dictionaries and why do we want to bother with something so complex and annoying?\n",
    "\n",
    "Dictionaries offer an elegantly complex data structure to store data via named values.  Dictionaries can then also handle very complex data structures, including one -> many relationships where lines of data would not do very well.  Simple data can usually remain in lists without a problem, but moving things to dictionaries will make your code much more readable (because you can use names of things rather than position names) and more flexible (because you can allow the data to shift around, so long as the names for things remain the same).\n",
    "\n",
    "The basic syntax of a dictionary is `{key: value}`.\n",
    "\n",
    "* Keys are unique values (of any object type, although you can use stuff at your own peril). \n",
    "* You may not repeat keys within a dictionary.\n",
    "* values can be repeated across keys or empty objects, but you have to have something"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say_what = {'greeting': \"Hello, Human\", \n",
    "            'robot': 'beep beep, boop boop', \n",
    "            'farewell': 'So long, human, have a nice mortal life'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things to note in this syntax:\n",
    "\n",
    "* The keys and values are all strings\n",
    "* A colon is used to separate the key from the value\n",
    "* Commas separate each of the key:value pairs\n",
    "* My keys are all unique\n",
    "* The curly braces `{}` define a list\n",
    "\n",
    "There are so many ways to deal with dictionaries!!! So many tools, etc.  You'll find your own way and style."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries have no order!\n",
    "\n",
    "I know that you see the order I put the items into that dictionary, but there's no inherit order to them.  There is no 'first element' or 'last element'.  \n",
    "\n",
    "Elements within dictionaries are accessed by **name** instead of position.\n",
    "\n",
    "So if I want the value of greeting..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Human\n"
     ]
    }
   ],
   "source": [
    "print(say_what['greeting'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beep beep, boop boop\n"
     ]
    }
   ],
   "source": [
    "print(say_what['robot'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So long, human, have a nice mortal life\n"
     ]
    }
   ],
   "source": [
    "print(say_what['farewell'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attempting to use position numbers will produce an error.  See that this is called \"KeyError\" meaning that I might have integer values as my keys, but even though we're using brackets like we do with lists they thing we put in the brackets does not have the same semantic meaning.\n",
    "\n",
    "In a list we might say \"I want the item at position `0`.  So `print(my_list[0])`.\n",
    "\n",
    "In a dictionary, we would say \"I want the item with the key value of `0`, so `print(my_dict[0])`.\n",
    "\n",
    "They look the same, but in no way do they work similarly.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "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<ipython-input-11-096aa895b5c5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msay_what\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[0m",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "print(say_what[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some key methods\n",
    "\n",
    "There are going to be times when you want just the keys and just the values.  Not shockingly, we do that with `.keys()` and `.values()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['farewell', 'robot', 'greeting'])\n"
     ]
    }
   ],
   "source": [
    "print(say_what.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['So long, human, have a nice mortal life', 'beep beep, boop boop', 'Hello, Human'])\n"
     ]
    }
   ],
   "source": [
    "print(say_what.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating over dictionaries\n",
    "\n",
    "This is where your personal style will really come out.  There are many ways to accomplish this one, so pick your pleasure or poison.  However, here's a few:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## .items()\n",
    "\n",
    "I think this one is the most straight foward, as it gives you consistent and named access to the values of the keys and values.  But you do use that funky multi-assignment-tuple-business that we explored in the raven pairs example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('farewell', 'So long, human, have a nice mortal life'), ('robot', 'beep beep, boop boop'), ('greeting', 'Hello, Human')])\n"
     ]
    }
   ],
   "source": [
    "print(say_what.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So this gives you a list of tuples, each of length 2.  The first item in the tuple is the value of the key and the second value is the value of the ... value.  Talking about dictionaries is hard.  Anyhow, we can loop over this list as such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dictionary will say So long, human, have a nice mortal life as a farewell\n",
      "The dictionary will say beep beep, boop boop as a robot\n",
      "The dictionary will say Hello, Human as a greeting\n"
     ]
    }
   ],
   "source": [
    "for key, value in say_what.items():\n",
    "    print(\"The dictionary will say\", value, \"as a\", key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you can also loop over a list of keys and access the values like that.  For example, we can sort the list of keys alphabetically, and then look up the values like that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted keys are: ['farewell', 'robot', 'greeting']\n",
      "Sorted keys are: ['farewell', 'greeting', 'robot']\n"
     ]
    }
   ],
   "source": [
    "keys = list(say_what.keys()) # screw you, py3\n",
    "print(\"Unsorted keys are:\", keys)\n",
    "keys.sort()\n",
    "print(\"Sorted keys are:\", keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So long, human, have a nice mortal life\n",
      "Hello, Human\n",
      "beep beep, boop boop\n"
     ]
    }
   ],
   "source": [
    "for key in keys:\n",
    "    print(say_what[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Handling more complex data in dictionaries\n",
    "\n",
    "Let's play with how dictionaries can be powerful.\n",
    "\n",
    "The problem:  create a dictionary of line counts for each chapter in dracula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['drac_chaps/Dracula-Chapter-1-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-10-Mina_Murrays_Journal.txt', 'drac_chaps/Dracula-Chapter-11-Lucy_Westenras_Diary.txt', 'drac_chaps/Dracula-Chapter-12-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-13-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-14-Mina_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-15-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-16-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-17-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-18-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-19-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-2-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-20-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-21-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-22-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-23-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-24-Dr_Sewards_Phonograph_Diary_spoken_by_Van_Helsing.txt', 'drac_chaps/Dracula-Chapter-25-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-26-Dr_Sewards_Diary.txt', 'drac_chaps/Dracula-Chapter-27-Mina_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-3-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-4-Jonathan_Harkers_Journal.txt', 'drac_chaps/Dracula-Chapter-5-LettersLucy_and_Mina.txt', 'drac_chaps/Dracula-Chapter-6-Mina_Murrays_Journal.txt', 'drac_chaps/Dracula-Chapter-7-Cutting_from_The_Dailygraph_8_August.txt', 'drac_chaps/Dracula-Chapter-8-Mina_Murrays_Journal.txt', 'drac_chaps/Dracula-Chapter-9-Mina_Murrays_Journal.txt']\n"
     ]
    }
   ],
   "source": [
    "# now that we have the chapters separated, we can use those files to our benefit\n",
    "\n",
    "import glob\n",
    "\n",
    "files = glob.glob('drac_chaps/Dracula*.txt')\n",
    "print(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drac_chaps/Dracula-Chapter-1-Jonathan_Harkers_Journal.txt\n",
      "1\n",
      "drac_chaps/Dracula-Chapter-10-Mina_Murrays_Journal.txt\n",
      "10\n",
      "drac_chaps/Dracula-Chapter-11-Lucy_Westenras_Diary.txt\n",
      "11\n",
      "drac_chaps/Dracula-Chapter-12-Dr_Sewards_Diary.txt\n",
      "12\n",
      "drac_chaps/Dracula-Chapter-13-Dr_Sewards_Diary.txt\n",
      "13\n",
      "drac_chaps/Dracula-Chapter-14-Mina_Harkers_Journal.txt\n",
      "14\n",
      "drac_chaps/Dracula-Chapter-15-Dr_Sewards_Diary.txt\n",
      "15\n",
      "drac_chaps/Dracula-Chapter-16-Dr_Sewards_Diary.txt\n",
      "16\n",
      "drac_chaps/Dracula-Chapter-17-Dr_Sewards_Diary.txt\n",
      "17\n",
      "drac_chaps/Dracula-Chapter-18-Dr_Sewards_Diary.txt\n",
      "18\n",
      "drac_chaps/Dracula-Chapter-19-Jonathan_Harkers_Journal.txt\n",
      "19\n",
      "drac_chaps/Dracula-Chapter-2-Jonathan_Harkers_Journal.txt\n",
      "2\n",
      "drac_chaps/Dracula-Chapter-20-Jonathan_Harkers_Journal.txt\n",
      "20\n",
      "drac_chaps/Dracula-Chapter-21-Dr_Sewards_Diary.txt\n",
      "21\n",
      "drac_chaps/Dracula-Chapter-22-Jonathan_Harkers_Journal.txt\n",
      "22\n",
      "drac_chaps/Dracula-Chapter-23-Dr_Sewards_Diary.txt\n",
      "23\n",
      "drac_chaps/Dracula-Chapter-24-Dr_Sewards_Phonograph_Diary_spoken_by_Van_Helsing.txt\n",
      "24\n",
      "drac_chaps/Dracula-Chapter-25-Dr_Sewards_Diary.txt\n",
      "25\n",
      "drac_chaps/Dracula-Chapter-26-Dr_Sewards_Diary.txt\n",
      "26\n",
      "drac_chaps/Dracula-Chapter-27-Mina_Harkers_Journal.txt\n",
      "27\n",
      "drac_chaps/Dracula-Chapter-3-Jonathan_Harkers_Journal.txt\n",
      "3\n",
      "drac_chaps/Dracula-Chapter-4-Jonathan_Harkers_Journal.txt\n",
      "4\n",
      "drac_chaps/Dracula-Chapter-5-LettersLucy_and_Mina.txt\n",
      "5\n",
      "drac_chaps/Dracula-Chapter-6-Mina_Murrays_Journal.txt\n",
      "6\n",
      "drac_chaps/Dracula-Chapter-7-Cutting_from_The_Dailygraph_8_August.txt\n",
      "7\n",
      "drac_chaps/Dracula-Chapter-8-Mina_Murrays_Journal.txt\n",
      "8\n",
      "drac_chaps/Dracula-Chapter-9-Mina_Murrays_Journal.txt\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# first up, let's loop through the files and get the chapter number out\n",
    "\n",
    "for f in files:\n",
    "    print(f)\n",
    "    print(f.split(\"-\")[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drac_chaps/Dracula-Chapter-1-Jonathan_Harkers_Journal.txt\n",
      "01\n",
      "drac_chaps/Dracula-Chapter-10-Mina_Murrays_Journal.txt\n",
      "10\n",
      "drac_chaps/Dracula-Chapter-11-Lucy_Westenras_Diary.txt\n",
      "11\n",
      "drac_chaps/Dracula-Chapter-12-Dr_Sewards_Diary.txt\n",
      "12\n",
      "drac_chaps/Dracula-Chapter-13-Dr_Sewards_Diary.txt\n",
      "13\n",
      "drac_chaps/Dracula-Chapter-14-Mina_Harkers_Journal.txt\n",
      "14\n",
      "drac_chaps/Dracula-Chapter-15-Dr_Sewards_Diary.txt\n",
      "15\n",
      "drac_chaps/Dracula-Chapter-16-Dr_Sewards_Diary.txt\n",
      "16\n",
      "drac_chaps/Dracula-Chapter-17-Dr_Sewards_Diary.txt\n",
      "17\n",
      "drac_chaps/Dracula-Chapter-18-Dr_Sewards_Diary.txt\n",
      "18\n",
      "drac_chaps/Dracula-Chapter-19-Jonathan_Harkers_Journal.txt\n",
      "19\n",
      "drac_chaps/Dracula-Chapter-2-Jonathan_Harkers_Journal.txt\n",
      "02\n",
      "drac_chaps/Dracula-Chapter-20-Jonathan_Harkers_Journal.txt\n",
      "20\n",
      "drac_chaps/Dracula-Chapter-21-Dr_Sewards_Diary.txt\n",
      "21\n",
      "drac_chaps/Dracula-Chapter-22-Jonathan_Harkers_Journal.txt\n",
      "22\n",
      "drac_chaps/Dracula-Chapter-23-Dr_Sewards_Diary.txt\n",
      "23\n",
      "drac_chaps/Dracula-Chapter-24-Dr_Sewards_Phonograph_Diary_spoken_by_Van_Helsing.txt\n",
      "24\n",
      "drac_chaps/Dracula-Chapter-25-Dr_Sewards_Diary.txt\n",
      "25\n",
      "drac_chaps/Dracula-Chapter-26-Dr_Sewards_Diary.txt\n",
      "26\n",
      "drac_chaps/Dracula-Chapter-27-Mina_Harkers_Journal.txt\n",
      "27\n",
      "drac_chaps/Dracula-Chapter-3-Jonathan_Harkers_Journal.txt\n",
      "03\n",
      "drac_chaps/Dracula-Chapter-4-Jonathan_Harkers_Journal.txt\n",
      "04\n",
      "drac_chaps/Dracula-Chapter-5-LettersLucy_and_Mina.txt\n",
      "05\n",
      "drac_chaps/Dracula-Chapter-6-Mina_Murrays_Journal.txt\n",
      "06\n",
      "drac_chaps/Dracula-Chapter-7-Cutting_from_The_Dailygraph_8_August.txt\n",
      "07\n",
      "drac_chaps/Dracula-Chapter-8-Mina_Murrays_Journal.txt\n",
      "08\n",
      "drac_chaps/Dracula-Chapter-9-Mina_Murrays_Journal.txt\n",
      "09\n"
     ]
    }
   ],
   "source": [
    "# sweet, now let's add some leading zeros\n",
    "\n",
    "for f in files:\n",
    "    print(f)\n",
    "    print(f.split(\"-\")[2].zfill(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chapter 01 has 506 lines\n",
      "Chapter 10 has 597 lines\n",
      "Chapter 11 has 513 lines\n",
      "Chapter 12 has 714 lines\n",
      "Chapter 13 has 659 lines\n",
      "Chapter 14 has 643 lines\n",
      "Chapter 15 has 593 lines\n",
      "Chapter 16 has 438 lines\n",
      "Chapter 17 has 547 lines\n",
      "Chapter 18 has 641 lines\n",
      "Chapter 19 has 492 lines\n",
      "Chapter 02 has 502 lines\n",
      "Chapter 20 has 618 lines\n",
      "Chapter 21 has 563 lines\n",
      "Chapter 22 has 496 lines\n",
      "Chapter 23 has 548 lines\n",
      "Chapter 24 has 583 lines\n",
      "Chapter 25 has 602 lines\n",
      "Chapter 26 has 706 lines\n",
      "Chapter 27 has 712 lines\n",
      "Chapter 03 has 499 lines\n",
      "Chapter 04 has 570 lines\n",
      "Chapter 05 has 343 lines\n",
      "Chapter 06 has 525 lines\n",
      "Chapter 07 has 544 lines\n",
      "Chapter 08 has 592 lines\n",
      "Chapter 09 has 574 lines\n"
     ]
    }
   ],
   "source": [
    "# now we'll read in the file and do stuff to it\n",
    "\n",
    "for f in files:\n",
    "    chap_num = f.split(\"-\")[2].zfill(2)\n",
    "    \n",
    "    with open(f, 'r') as file_in:\n",
    "        chap_lines_length = len(file_in.readlines())\n",
    "        \n",
    "    print(\"Chapter\", chap_num, \"has\", chap_lines_length, \"lines\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adding values to dictionaries\n",
    "\n",
    "## New values\n",
    "\n",
    "Yup, you use an assignment statement.\n",
    "\n",
    "Yup, it's confusing.\n",
    "\n",
    "So:  `my_dict[new_key] = new_value`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say_what['trains'] = \"chuchu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'farewell': 'So long, human, have a nice mortal life', 'robot': 'beep beep, boop boop', 'greeting': 'Hello, Human', 'trains': 'chuchu'}\n"
     ]
    }
   ],
   "source": [
    "print(say_what)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things to note about the above:  my new key is in quotes becuase it's a string.  DO NOT FORGET THE QUOTES.  Students do this all the time.  I don't need to do any funky stuff like say_what = say_what['trains'] = 'chuchu'.  The new key declaration is on the left, the new value is on the right of the assignment operator.\n",
    "\n",
    "## Overwriting values\n",
    "\n",
    "You can use the same syntax to overwrite values within a dictionary.  This is why you can can't repeat values.\n",
    "\n",
    "So I'm told that my onomatopoeia for trains is incorrect, and likely influenced by studying Japanese kanas too much.  So we can fix that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "say_what['trains'] = 'choo choo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'farewell': 'So long, human, have a nice mortal life', 'robot': 'beep beep, boop boop', 'greeting': 'Hello, Human', 'trains': 'choo choo'}\n"
     ]
    }
   ],
   "source": [
    "print(say_what)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now let's do this to our dracula data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Cool, so we're getting the data, now let's store it somewhere we can do something neat to it.\n",
    "# we'll be storing the chapter names like strings, but with the leading zeros we'll be able\n",
    "# to sort them correctly without a problem\n",
    "\n",
    "drac_data = {}  # accumulator pattern again~~!!!\n",
    "\n",
    "for f in files:\n",
    "    chap_num = \"C\" + f.split(\"-\")[2].zfill(2) \n",
    "    # adding a letter so we can see a visual diff between the keys and values\n",
    "    \n",
    "    with open(f, 'r') as file_in:\n",
    "        chap_lines_length = len(file_in.readlines())\n",
    "        \n",
    "    # now let's add the data for each file to the dictionary\n",
    "    drac_data[chap_num] = chap_lines_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C21': 563, 'C27': 712, 'C15': 593, 'C01': 506, 'C05': 343, 'C02': 502, 'C06': 525, 'C18': 641, 'C26': 706, 'C08': 592, 'C25': 602, 'C04': 570, 'C19': 492, 'C03': 499, 'C16': 438, 'C23': 548, 'C17': 547, 'C07': 544, 'C09': 574, 'C12': 714, 'C20': 618, 'C10': 597, 'C22': 496, 'C13': 659, 'C11': 513, 'C14': 643, 'C24': 583}\n"
     ]
    }
   ],
   "source": [
    "print(drac_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# And now, math\n",
    "\n",
    "Per page 350, here's some math functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def mean(nums):\n",
    "    sum = 0.0\n",
    "    for num in nums:\n",
    "        sum = sum + num\n",
    "    return sum / len(nums)\n",
    "\n",
    "def stdDev(nums, xbar):\n",
    "    sumDevSq = 0.0\n",
    "    for num in nums:\n",
    "        dev = num - xbar\n",
    "        sumDevSq = sumDevSq + dev * dev\n",
    "    return sqrt(sumDevSq/(len(nums) -1 ))\n",
    "\n",
    "def median(nums):\n",
    "    nums = list(nums)\n",
    "    nums.sort()\n",
    "    size = len(nums)\n",
    "    midPos = size // 2\n",
    "    if size % 2 == 0:\n",
    "        median = (nums[midPos] + nums[midPos -1]) / 2.0\n",
    "    else:\n",
    "        median = nums[midPos]\n",
    "    return median"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# remember that our data is in a dictionary structure, but we can get the values out\n",
    "\n",
    "drac_math = {'mean_length': mean(drac_data.values()),\n",
    "             'stdDev_length': stdDev(drac_data.values(), mean(drac_data.values())),\n",
    "             'median_length': median(drac_data.values())}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mean_length': 567.4074074074074,\n",
       " 'median_length': 570,\n",
       " 'stdDev_length': 84.1350833523819}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drac_math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So maybe we're curious about the standard deviation, and we want to see how different each length is from the mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chapter C21 is -4.407407407407391 lines from the mean\n",
      "Chapter C27 is 144.5925925925926 lines from the mean\n",
      "Chapter C15 is 25.59259259259261 lines from the mean\n",
      "Chapter C01 is -61.40740740740739 lines from the mean\n",
      "Chapter C05 is -224.4074074074074 lines from the mean\n",
      "Chapter C02 is -65.40740740740739 lines from the mean\n",
      "Chapter C06 is -42.40740740740739 lines from the mean\n",
      "Chapter C18 is 73.59259259259261 lines from the mean\n",
      "Chapter C26 is 138.5925925925926 lines from the mean\n",
      "Chapter C08 is 24.59259259259261 lines from the mean\n",
      "Chapter C25 is 34.59259259259261 lines from the mean\n",
      "Chapter C04 is 2.5925925925926094 lines from the mean\n",
      "Chapter C19 is -75.40740740740739 lines from the mean\n",
      "Chapter C03 is -68.40740740740739 lines from the mean\n",
      "Chapter C16 is -129.4074074074074 lines from the mean\n",
      "Chapter C23 is -19.40740740740739 lines from the mean\n",
      "Chapter C17 is -20.40740740740739 lines from the mean\n",
      "Chapter C07 is -23.40740740740739 lines from the mean\n",
      "Chapter C09 is 6.592592592592609 lines from the mean\n",
      "Chapter C12 is 146.5925925925926 lines from the mean\n",
      "Chapter C20 is 50.59259259259261 lines from the mean\n",
      "Chapter C10 is 29.59259259259261 lines from the mean\n",
      "Chapter C22 is -71.40740740740739 lines from the mean\n",
      "Chapter C13 is 91.59259259259261 lines from the mean\n",
      "Chapter C11 is -54.40740740740739 lines from the mean\n",
      "Chapter C14 is 75.59259259259261 lines from the mean\n",
      "Chapter C24 is 15.59259259259261 lines from the mean\n"
     ]
    }
   ],
   "source": [
    "for chap_num, chap_length in drac_data.items():\n",
    "    print(\"Chapter\", chap_num, \"is\", chap_length - drac_math['mean_length'], \"lines from the mean\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That lack of order is super annoying!!!!!!!  Let's sort the chapter numbers and then take more of a look at things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C01 -61.40740740740739\n",
      "C02 -65.40740740740739\n",
      "C03 -68.40740740740739\n",
      "C04 2.5925925925926094\n",
      "C05 -224.4074074074074\n",
      "C06 -42.40740740740739\n",
      "C07 -23.40740740740739\n",
      "C08 24.59259259259261\n",
      "C09 6.592592592592609\n",
      "C10 29.59259259259261\n",
      "C11 -54.40740740740739\n",
      "C12 146.5925925925926\n",
      "C13 91.59259259259261\n",
      "C14 75.59259259259261\n",
      "C15 25.59259259259261\n",
      "C16 -129.4074074074074\n",
      "C17 -20.40740740740739\n",
      "C18 73.59259259259261\n",
      "C19 -75.40740740740739\n",
      "C20 50.59259259259261\n",
      "C21 -4.407407407407391\n",
      "C22 -71.40740740740739\n",
      "C23 -19.40740740740739\n",
      "C24 15.59259259259261\n",
      "C25 34.59259259259261\n",
      "C26 138.5925925925926\n",
      "C27 144.5925925925926\n"
     ]
    }
   ],
   "source": [
    "chap_nums = list(drac_data.keys())\n",
    "chap_nums.sort()\n",
    "\n",
    "for chap_num in chap_nums:\n",
    "    print(chap_num, drac_data[chap_num] - drac_math['mean_length'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's this `sorted()` function with a ton of options.  `sorted(list)` differs from `list.sort()`.  The `sorted()` function will **return** a new list that has been sorted.  Meanwhile, `list.sort()` will **mutate** the list that you call it on.\n",
    "\n",
    "The power of `sorted()` is revealed with the optional `key =` parameter that you can use. From the [documentation](https://docs.python.org/3/howto/sorting.html):  \"The value of the key parameter should be a function that takes a single argument and returns a key to use for sorting purposes. This technique is fast because the key function is called exactly once for each input record.\"  \n",
    "\n",
    "This means that it will unpack each value within the collection item you, put it through that function, and sort the list on those values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sally', 'Sally', 'She', 'The', 'are', 'by', 'does', 'from', 'not', 'sad', 'sea.', 'seashells', 'seashore.', 'sell', 'sells', 'sells', 'shells', 'shells.', 'surely', 'the', 'the']\n"
     ]
    }
   ],
   "source": [
    "sentence = \"\"\"Sally sells seashells by the seashore.  \n",
    "              The shells Sally sells are surely from the sea. \n",
    "              She does not sell sad shells.\"\"\"\n",
    "\n",
    "print(sorted(sentence.split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see in the example above that (because we know ASCII tables!) the upper case letters were sorted before the lower case letters.  Perhaps we're okay with this.  Perhaps we're not.  Let's say we deeply care about this so we can do something interesting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['are', 'by', 'does', 'from', 'not', 'sad', 'Sally', 'Sally', 'sea.', 'seashells', 'seashore.', 'sell', 'sells', 'sells', 'She', 'shells', 'shells.', 'surely', 'the', 'The', 'the']\n"
     ]
    }
   ],
   "source": [
    "print(sorted(sentence.split(), key = str.lower))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps you can now see the value of doing it this way.  It will sort the values on the transformed list but then return a list back to you with the origianl values.  So we can see that 'sad' has been correctly sorted before 'Sally' but the original value is back.\n",
    "\n",
    "So going back to dracula, we have the chapter lengths and the chapter, and we want to sort the chapters by how different the chapter length (in lines) is from the mean, so starting from the positive numbers (meaning that they are longer than average) and going to the negative numbers (meaning that they are shorter than average)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# first we make a basic function to compute the difference\n",
    "# this function takes a key (remember that we want the chapter number)\n",
    "# looks up the value, does the computation, and then \n",
    "# returns the difference value\n",
    "\n",
    "def how_much_lower_than_mean(key):\n",
    "    return drac_math['mean_length'] - drac_data[key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C12',\n",
       " 'C27',\n",
       " 'C26',\n",
       " 'C13',\n",
       " 'C14',\n",
       " 'C18',\n",
       " 'C20',\n",
       " 'C25',\n",
       " 'C10',\n",
       " 'C15',\n",
       " 'C08',\n",
       " 'C24',\n",
       " 'C09',\n",
       " 'C04',\n",
       " 'C21',\n",
       " 'C23',\n",
       " 'C17',\n",
       " 'C07',\n",
       " 'C06',\n",
       " 'C11',\n",
       " 'C01',\n",
       " 'C02',\n",
       " 'C03',\n",
       " 'C22',\n",
       " 'C19',\n",
       " 'C16',\n",
       " 'C05']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now we pass in drac data into sorted and have it run the function over it.\n",
    "# We then get back a list of the chapter titles (keys in the dict)\n",
    "# that have been sorted by the values we generated with how_much_lower_than_mean\n",
    "\n",
    "sorted(drac_data, key = how_much_lower_than_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maybe you don't believe me, that's fine. So let's look these numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "minny = min(drac_data.values())//10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "maxxy = max(drac_data.values())//10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A visual representation of how much shorter each chapter is from the mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Csd                                                xxxxxxxx|xxxxxxxx\n",
      "C01                                                  ******|\n",
      "C02                                                  ******|\n",
      "C03                                                  ******|\n",
      "C04                                                        |\n",
      "C05                                  **********************|\n",
      "C06                                                    ****|\n",
      "C07                                                      **|\n",
      "C08                                                        |**\n",
      "C09                                                        |\n",
      "C10                                                        |**\n",
      "C11                                                   *****|\n",
      "C12                                                        |**************\n",
      "C13                                                        |*********\n",
      "C14                                                        |*******\n",
      "C15                                                        |**\n",
      "C16                                            ************|\n",
      "C17                                                      **|\n",
      "C18                                                        |*******\n",
      "C19                                                 *******|\n",
      "C20                                                        |*****\n",
      "C21                                                        |\n",
      "C22                                                 *******|\n",
      "C23                                                       *|\n",
      "C24                                                        |*\n",
      "C25                                                        |***\n",
      "C26                                                        |*************\n",
      "C27                                                        |**************\n"
     ]
    }
   ],
   "source": [
    "std_stars = int(drac_math['stdDev_length'] // 10)\n",
    "std_spaces = int(drac_math['mean_length'] // 10) - std_stars\n",
    "\n",
    "print(\"Csd\" + std_spaces * \" \" + std_stars * \"x\" + \"|\" + std_stars * \"x\")\n",
    "for chap_num in chap_nums:\n",
    "    diff = drac_data[chap_num] - drac_math['mean_length']\n",
    "    print(chap_num, end = \"\")\n",
    "    if diff > 0:\n",
    "        print(int(drac_math['mean_length'] // 10) * \" \" + \"|\" + int(diff) // 10 * \"*\")\n",
    "    else:\n",
    "        num_stars = (int(diff) * -1) // 10\n",
    "        num_spaces = int(drac_math['mean_length'] // 10) - num_stars\n",
    "        print(num_spaces * \" \" + num_stars * \"*\" + \"|\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Csd                                                xxxxxxxx|xxxxxxxx\n",
      "C12                                                        |**************\n",
      "C27                                                        |**************\n",
      "C26                                                        |*************\n",
      "C13                                                        |*********\n",
      "C14                                                        |*******\n",
      "C18                                                        |*******\n",
      "C20                                                        |*****\n",
      "C25                                                        |***\n",
      "C10                                                        |**\n",
      "C15                                                        |**\n",
      "C08                                                        |**\n",
      "C24                                                        |*\n",
      "C09                                                        |\n",
      "C04                                                        |\n",
      "C21                                                        |\n",
      "C23                                                       *|\n",
      "C17                                                      **|\n",
      "C07                                                      **|\n",
      "C06                                                    ****|\n",
      "C11                                                   *****|\n",
      "C01                                                  ******|\n",
      "C02                                                  ******|\n",
      "C03                                                  ******|\n",
      "C22                                                 *******|\n",
      "C19                                                 *******|\n",
      "C16                                            ************|\n",
      "C05                                  **********************|\n"
     ]
    }
   ],
   "source": [
    "# and now we can do this display in order because we've sorted the chapters by these lengths.  \n",
    "\n",
    "sortedids = sorted(drac_data, key = how_much_lower_than_mean)\n",
    "\n",
    "std_stars = int(drac_math['stdDev_length'] // 10)\n",
    "std_spaces = int(drac_math['mean_length'] // 10) - std_stars\n",
    "\n",
    "print(\"Csd\" + std_spaces * \" \" + std_stars * \"x\" + \"|\" + std_stars * \"x\")\n",
    "for chap_num in sortedids:\n",
    "    diff = drac_data[chap_num] - drac_math['mean_length']\n",
    "    print(chap_num, end = \"\")\n",
    "    if diff > 0:\n",
    "        print(int(drac_math['mean_length'] // 10) * \" \" + \"|\" + int(diff) // 10 * \"*\")\n",
    "    else:\n",
    "        num_stars = (int(diff) * -1) // 10\n",
    "        num_spaces = int(drac_math['mean_length'] // 10) - num_stars\n",
    "        print(num_spaces * \" \" + num_stars * \"*\" + \"|\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# and now the median, because we can\n",
    "\n",
    "Because we have named values, we don't have to wrangle a bunch of stupid numbers, we can just change the names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "std_stars = int(drac_math['stdDev_length'] // 10)\n",
    "std_spaces = int(drac_math['median_length'] // 10) - std_stars\n",
    "\n",
    "print(\"Csd\" + std_spaces * \" \" + std_stars * \"x\" + \"|\" + std_stars * \"x\")\n",
    "for chap_num in chap_nums:\n",
    "    diff = drac_data[chap_num] - drac_math['median_length']\n",
    "    print(chap_num, end = \"\")\n",
    "    if diff > 0:\n",
    "        print(int(drac_math['median_length'] // 10) * \" \" + \"|\" + int(diff) // 10 * \"*\")\n",
    "    else:\n",
    "        num_stars = (int(diff) * -1) // 10\n",
    "        num_spaces = int(drac_math['median_length'] // 10) - num_stars\n",
    "        print(num_spaces * \" \" + num_stars * \"*\" + \"|\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'drac_math' 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<ipython-input-6-94a50dc483b8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstd_stars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdrac_math\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'stdDev_length'\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      2\u001b[0m \u001b[0mstd_spaces\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdrac_math\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'median_length'\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[0mstd_stars\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Csd\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstd_spaces\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstd_stars\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m\"x\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"|\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstd_stars\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m\"x\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mchap_num\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msortedids\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'drac_math' is not defined"
     ]
    }
   ],
   "source": [
    "std_stars = int(drac_math['stdDev_length'] // 10)\n",
    "std_spaces = int(drac_math['median_length'] // 10) - std_stars\n",
    "\n",
    "print(\"Csd\" + std_spaces * \" \" + std_stars * \"x\" + \"|\" + std_stars * \"x\")\n",
    "for chap_num in sortedids:\n",
    "    diff = drac_data[chap_num] - drac_math['median_length']\n",
    "    print(chap_num, end = \"\")\n",
    "    if diff > 0:\n",
    "        print(int(drac_math['median_length'] // 10) * \" \" + \"|\" + int(diff) // 10 * \"*\")\n",
    "    else:\n",
    "        num_stars = (int(diff) * -1) // 10\n",
    "        num_spaces = int(drac_math['median_length'] // 10) - num_stars\n",
    "        print(num_spaces * \" \" + num_stars * \"*\" + \"|\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📖01|💩💩💩💩💩💩\n",
      "📖02|💩💩💩💩💩💩\n",
      "📖03|💩💩💩💩💩💩\n",
      "📖04|\n",
      "📖05|💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩\n",
      "📖06|💩💩💩💩\n",
      "📖07|💩💩\n",
      "📖08|💩💩\n",
      "📖09|\n",
      "📖10|💩💩\n",
      "📖11|💩💩💩💩💩\n",
      "📖12|💩💩💩💩💩💩💩💩💩💩💩💩💩💩\n",
      "📖13|💩💩💩💩💩💩💩💩💩\n",
      "📖14|💩💩💩💩💩💩💩\n",
      "📖15|💩💩\n",
      "📖16|💩💩💩💩💩💩💩💩💩💩💩💩\n",
      "📖17|💩💩\n",
      "📖18|💩💩💩💩💩💩💩\n",
      "📖19|💩💩💩💩💩💩💩\n",
      "📖20|💩💩💩💩💩\n",
      "📖21|\n",
      "📖22|💩💩💩💩💩💩💩\n",
      "📖23|💩\n",
      "📖24|💩\n",
      "📖25|💩💩💩\n",
      "📖26|💩💩💩💩💩💩💩💩💩💩💩💩💩\n",
      "📖27|💩💩💩💩💩💩💩💩💩💩💩💩💩💩\n"
     ]
    }
   ],
   "source": [
    "viz_char = u'\\U0001F4A9'\n",
    "\n",
    "# and now we can do this display in order because we've sorted the chapters by these lengths.  \n",
    "\n",
    "std_stars = int(drac_math['stdDev_length'] // 10)\n",
    "std_spaces = int(drac_math['mean_length'] // 10) - std_stars\n",
    "\n",
    "#print(\"Csd\" + std_spaces * \" \" + std_stars * \"x\" + \"|\" + std_stars * \"x\")\n",
    "for chap_num in chap_nums:\n",
    "    diff = abs(drac_data[chap_num] - drac_math['mean_length'])\n",
    "    print(chap_num.replace(\"C\", u\"\\U0001F4D6\"), end = \"\")\n",
    "    if diff > 0:\n",
    "        print(\"|\" + int(diff) // 10 * viz_char)\n",
    "\n",
    "#         print(int(drac_math['mean_length'] // 10) * \" \" + \"|\" + int(diff) // 10 * \"*\")\n",
    "    else:\n",
    "        num_stars = (int(diff) * -1) // 10\n",
    "        num_spaces = int(drac_math['mean_length'] // 10) - num_stars\n",
    "        print(num_spaces * \" \" + num_stars * \"*\" + \"|\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}