lecture_18_dicts_strings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as pl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is a way to store data. It uses a key (usually text like a word or a number) that points to a value. Think of a real dictionary. You look up a word (the key) in the dictionary to find the definition (the value).\n",
    "\n",
    "\n",
    "The keys can be int, float, str, or tuple.\n",
    "\n",
    "Dictionaries can be nested like lists.\n",
    "\n",
    "With a list, we must remember the order of the items in the list. \n",
    "\n",
    "Let's look at average temperatures in European cities as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cityList = ['Oslo', 'London', 'Paris']\n",
    "tempList = [13, 15.4, 17.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, if we were interested in picking out the average temperature in London, the lists are small enough that we can determine the corresponding index visually.\n",
    "\n",
    "Q. How could we get to the average temperature of London?\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London\n",
      "15.4\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(cityList[1])\n",
    "print(tempList[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What if our \"temps\" and \"cities\" lists had 1000 elements? How could we pick out the average temperature in a city of our choosing?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index: 1\n",
      "Value: 15.4\n"
     ]
    }
   ],
   "source": [
    "# We could have sublists consisting of cities and temperatures\n",
    "# and search for London, then its corresponding temperature.\n",
    "\n",
    "# Alternatively, we could index the cities list:\n",
    "\n",
    "i = cityList.index('London')\n",
    "print(\"Index:\", i)\n",
    "print(\"Value:\", tempList[i])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Or, we could do this using a dictionary -- note the brackets {}.\n",
    "\n",
    "Dictionaries are of the form {keyA: valueA, keyB: valueB, ...}\n",
    "\n",
    "The \"keys\" have associated \"values\". In this example, the keys are strings and the values are numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempDict = {'Oslo': 13, 'London': 15.4, 'Paris': 17.5}\n",
    "tempDict"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp2Dict = dict(Oslo=13, London=15.4, Paris=17.5)\n",
    "temp2Dict"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Now, rather than first determining the index of a particular city, then accessing that element in \"temps\" we access it by name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London: 15.4\n"
     ]
    }
   ],
   "source": [
    "print(\"London:\", tempDict['London'])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If we'd like, we can add another city to tempDict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 15.4, 'Madrid': 26.0, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempDict['Madrid'] = 26.0\n",
    "tempDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Oslo', 'London', 'Paris']\n",
      "[13, 15.4, 17.5]\n"
     ]
    }
   ],
   "source": [
    "print(cityList)\n",
    "print(tempList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What is the analogous list operation to do this?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Oslo', 'London', 'Paris', 'Madrid']\n",
      "[13, 15.4, 17.5, 26.0]\n"
     ]
    }
   ],
   "source": [
    "cityList.append(\"Madrid\")\n",
    "tempList.append(26.0)\n",
    "print(cityList)\n",
    "print(tempList)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Looping over the keys is analogous to looping over the indices of lists and arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average temperature in Paris is 17.5.\n",
      "The average temperature in Oslo is 13.\n",
      "The average temperature in Madrid is 26.\n",
      "The average temperature in London is 15.4.\n"
     ]
    }
   ],
   "source": [
    "for city in sorted(tempDict, reverse=True):\n",
    "    print('The average temperature in {} is {:g}.'.format(city, tempDict[city]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check if 'Berlin' is in temps with a Boolean expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Berlin' in tempDict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or 'Oslo':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oslo: 13\n"
     ]
    }
   ],
   "source": [
    "if 'Oslo' in tempDict:\n",
    "    print('Oslo:', tempDict['Oslo'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keys and values can be extracted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['London', 'Oslo', 'Paris', 'Madrid'])\n",
      "dict_values([15.4, 13, 17.5, 26.0])\n",
      "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5, 'Madrid': 26.0}\n"
     ]
    }
   ],
   "source": [
    "print(tempDict.keys())\n",
    "print(tempDict.values())\n",
    "print(tempDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an important distinction between dictionaries and lists:\n",
    "\n",
    "**In dictionaries, the order of the keys is not preserved!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London 15.4\n",
      "Oslo 13\n",
      "Paris 17.5\n",
      "Madrid 26.0\n"
     ]
    }
   ],
   "source": [
    "for city in tempDict:\n",
    "    print(city, tempDict[city])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If you want to force keys to be ordered, you can do so, e.g. \n",
    "using sorted():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "London 15.4\n",
      "Madrid 26.0\n",
      "Oslo 13\n",
      "Paris 17.5\n"
     ]
    }
   ],
   "source": [
    "# This accomplishes an alphabetical sorting:\n",
    "for city in sorted(tempDict, reverse = False):\n",
    "    print(city, tempDict[city])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To delete a key and its associated value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del tempDict['Madrid']\n",
    "tempDict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. Now, what do you predict this will be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tempDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like arrays, if we assign a new variable to a dictionary, **changes to values in one will be changed for both**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp3Dict = tempDict\n",
    "tempDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temp3Dict['London'] = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this yield?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'London': 0.0, 'Oslo': 13, 'Paris': 17.5}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempDict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The reason for this: in the above example, \"temp3Dict\" is a **reference** to \"tempDict\".\n",
    "\n",
    "\n",
    "If this is not the desired behavior, create a copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'London': 1000000.0, 'Oslo': 13, 'Paris': 17.5}\n",
      "{'London': 15.4, 'Oslo': 13, 'Paris': 17.5}\n"
     ]
    }
   ],
   "source": [
    "tempCopyDict = tempDict.copy()\n",
    "\n",
    "tempCopyDict['London'] = 1e6\n",
    "tempDict['London'] = 15.4\n",
    "\n",
    "print(tempCopyDict)\n",
    "print(tempDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Earlier in the semester I pointed you to a blog post about this. We've now covered all concepts that appeared in that discussion:\n",
    "\n",
    "    http://nedbatchelder.com/text/names.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final note -- dictionary elements can be anything: ints, floats, lists, arrays, dictionaries, class instances... more in today's tutorial!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We will discuss string manipulation with a series of examples.\n",
    "\n",
    "There are many examples in Section 6.3 of the book; read these, we'll just show some important ones.\n",
    "\n",
    "Operations we'll skip are joining strings, replacing upper case with lower case and vice versa, stripping out spaces, and testing for the presence of numbers. \n",
    "\n",
    "\n",
    "Substrings can be specified like lists, where the index refers to the character number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temp = 'One Two Three'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e T'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To search for a substring, use the find() method, which reports the index of the start of the first appearance of the substring."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp.find('Two')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the string is not found:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp.find('Four')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test whether a substring occurs within a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Four' in temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Four not found\n"
     ]
    }
   ],
   "source": [
    "# An example:\n",
    "\n",
    "if 'Four' in temp:\n",
    "    print('Four is in temp')\n",
    "else:\n",
    "    print('Four not found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This syntax is acceptable for lists, dictionaries, and strings!\n",
    "\n",
    "The startswith and endswith methods test whether a string starts or ends with a specified substring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'One Two Three'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q. What should this be?\n",
    "\n",
    "temp.endswith('Three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The replace method replaces substrings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One Two Three\n",
      "On3 Two Thr33\n",
      "One Two Three\n"
     ]
    }
   ],
   "source": [
    "print(temp)\n",
    "temp2 = temp.replace('e', '3')\n",
    "print(temp2)\n",
    "print(temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String splitting:  very useful for reading text files.\n",
    "\n",
    "The split method splits strings into words separated by spaces (by default, other characters can be used too)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['One', 'Two', 'Three']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = temp.split()\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also works for multiline files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One\r\n",
      "Two\r\n",
      "Three\n",
      "['One', 'Two', 'Three']\n"
     ]
    }
   ],
   "source": [
    "temp3 = 'One\\r\\nTwo\\r\\nThree'\n",
    "temp4 = temp3.splitlines()\n",
    "print(temp3)\n",
    "print(temp4)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Joining strings together. The delimiter (the thing between each text string) is specified inbetween quotes.  Then a .join with a list of the strings for input to join()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'May uh the uh force uh be with you'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text1 = \"May\"\n",
    "text2 = \"the\"\n",
    "text3 = \"force\"\n",
    "text4 = \"be with you\"\n",
    "\n",
    "combined = \" uh \".join([text1, text2, text3, text4])\n",
    "combined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manipulating text's uppercase/lowercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upper case:   IT'S CLOBBERIN' TIME!\n",
      "Lower case:   it's clobberin' time!\n",
      "Reverse case: IT'S clobberin' TIME!\n",
      "Title case:   It'S Clobberin' Time!\n",
      "Capital Case: It's clobberin' time!\n"
     ]
    }
   ],
   "source": [
    "marvelText = \"it's CLOBBERIN' time!\"\n",
    "\n",
    "print(\"Upper case:  \", marvelText.upper())\n",
    "print(\"Lower case:  \", marvelText.lower())\n",
    "print(\"Reverse case:\", marvelText.swapcase())\n",
    "print(\"Title case:  \", marvelText.title())\n",
    "print(\"Capital Case:\", marvelText.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PL4NCK'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Pl4nck'.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Splitting strings up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Have', 'you', 'ever', 'danced', 'with', 'the', 'devil', 'in', 'the', 'pale', 'moonlight?']\n",
      "['Have you ever danced with ', ' devil in ', ' pale moonlight?']\n"
     ]
    }
   ],
   "source": [
    "dcText = \"Have you ever danced with the devil in the pale moonlight?\"\n",
    "print(dcText.split())\n",
    "print(dcText.split(\"the\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do an example reading a data file string_example.dat and converting the data to numbers. First, let's see what's in the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# x    y \r\n",
      "0.67614818  0.06612175\r\n",
      "0.72452745  0.91697594\r\n",
      "0.49721092  0.74321783\r\n",
      "0.11647754  0.31299047\r\n",
      "0.74159754  0.58894824\r\n",
      "0.88066725  0.98678083\r\n",
      "0.24524501  0.59950154\r\n",
      "0.65850022  0.75670362\r\n",
      "0.15512891  0.57762052\r\n",
      "0.32754741  0.53567974"
     ]
    }
   ],
   "source": [
    "cat string_example.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. Would this code successfully read in the data? Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: '#'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-0dc609cdcc10>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mwords\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m         \u001b[0mnumber1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwords\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[1;32m      8\u001b[0m         \u001b[0mnumber2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0mpair\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mnumber1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumber2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: '#'"
     ]
    }
   ],
   "source": [
    "pairs = []\n",
    "\n",
    "with open(\"string_example.dat\", \"r\") as FILE:\n",
    "    for line in FILE:\n",
    "        words = line.split()\n",
    "        \n",
    "        number1 = float(words[0])\n",
    "        number2 = float(words[1])\n",
    "        pair = [number1, number2]\n",
    "        pairs.append(pair)\n",
    "\n",
    "pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a nice place for a dictionary!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# x    y \n",
      "\n",
      "0.67614818  0.06612175\n",
      "\n",
      "0.72452745  0.91697594\n",
      "\n",
      "0.49721092  0.74321783\n",
      "\n",
      "0.11647754  0.31299047\n",
      "\n",
      "0.74159754  0.58894824\n",
      "\n",
      "0.88066725  0.98678083\n",
      "\n",
      "0.24524501  0.59950154\n",
      "\n",
      "0.65850022  0.75670362\n",
      "\n",
      "0.15512891  0.57762052\n",
      "\n",
      "0.32754741  0.53567974\n",
      "{'y': [0.06612175, 0.91697594, 0.74321783, 0.31299047, 0.58894824, 0.98678083, 0.59950154, 0.75670362, 0.57762052, 0.53567974], 'x': [0.67614818, 0.72452745, 0.49721092, 0.11647754, 0.74159754, 0.88066725, 0.24524501, 0.65850022, 0.15512891, 0.32754741]}\n"
     ]
    }
   ],
   "source": [
    "data = {'x': [], 'y': []}\n",
    "\n",
    "with open(\"string_example.dat\", \"r\") as FILE:\n",
    "    for line in FILE:\n",
    "        print(line)\n",
    "        if line[0] == '#':\n",
    "            continue\n",
    "        \n",
    "        words = line.split()\n",
    "        \n",
    "        data['x'].append(float(words[0]))\n",
    "        data['y'].append(float(words[1]))\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x118082be0>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIS9JBTPkJalghrwkFcyQl6SC/T8aze314FrkggAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x115c64828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pl.scatter(data['x'], data['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [stable]",
   "language": "python",
   "name": "Python [stable]"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}