Chapter 8 - Parsing XML.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parsing XML in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XML in a nutshell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have primarily dealt with unstructured data in this course: we have learned to read, for example, the contents of plain text files in the previous chapters. Such raw textual data is often called 'unstructured', because it lacks annotations that make explicit the function or meaning of the words in the documents. If we read the contents of a play as a plain text, for instance, we don't have a clue to which scene or act a particular utterance belongs, or by which character the utterance was made. Nowadays, it is therefore increasingly common to add annotations to a text that give us a better insight into the\n",
    "semantics and structure of the data. Adding annotations to texts (e.g. scholarly editions of Shakepeare), is typically done using some form of markup. Various markup-languages exist that allow us to provide structured and unambiguous annotations to a (digital) text. XML or the \"eXtensible Mark-up Language\" is currently one of the dominant standards to encode texts in the Digital Humanities. In this chapter, we'll assume that have at least some notion of XML, although we will have a quick refresher below. XML is a pretty straightforward mark-up language: let's have a look at Shakepeare's well-known sonnet 18 encoded in XML (you can find this poem also as `sonnet.txt` in your `data/TEI` folder)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<?xml version=\"1.0\"?>\n",
    "<sonnet author=\"William Shakepeare\" year=\"1609\">\n",
    "<line n=\"1\">Shall I compare thee to a summer's <rhyme>day</rhyme>?</line>\n",
    "\t<line n=\"2\">Thou art more lovely and more <rhyme>temperate</rhyme>:</line>\n",
    "    <line n=\"3\">Rough winds do shake the darling buds of <rhyme>May</rhyme><break n=\"3\"/>,</line>\n",
    "\t<line n=\"4\">And summer's lease hath all too short a <rhyme>date</rhyme>:</line>\n",
    "\t<line n=\"5\">Sometime too hot the eye of heaven <rhyme>shines</rhyme>,</line>\n",
    "\t<line n=\"6\">And often is his gold complexion <rhyme>dimm'd</rhyme>;</line>\n",
    "\t<line n=\"7\">And every fair from fair sometime <rhyme>declines</rhyme>,</line>\n",
    "\t<line n=\"8\">By chance, or nature's changing course, <rhyme>untrimm'd</rhyme>;</line>\n",
    "    <volta/>\n",
    "\t<line n=\"9\">But thy eternal summer shall not <rhyme>fade</rhyme></line>\n",
    "\t<line n=\"10\">Nor lose possession of that fair thou <rhyme>ow'st</rhyme>;</line>\n",
    "\t<line n=\"11\">Nor shall Death brag thou wander'st in his <rhyme>shade</rhyme>,</line>\n",
    "\t<line n=\"12\">When in eternal lines to time thou <rhyme>grow'st</rhyme>;</line>\n",
    "\t<line n=\"13\">So long as men can breathe or eyes can <rhyme>see</rhyme>,</line>\n",
    "\t<line n=\"14\">So long lives this, and this gives life to <rhyme>thee</rhyme>.</line>\n",
    "</sonnet>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line in our Shakespearean example (<?xml version=\"1.0\"?>) declares which exact version of XML we are using, in our case version 1. As you can see at a glance, XML typically encodes pieces of text using *start tags* (e.g. `<line>, <rhyme>`) and *end tags* (`</line>`, `</rhyme>`). Each start tag must correspond to exactly one end tag, although XML does allow for \"solo\" elements such the `<volta/>` tag after line 8 in this example. Interestingly, XML tag are not allowed to overlap. The following line would therefore not constitue valid XML:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<line><sentence>This is a </line><line>sentence.</sentence></line>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two lines would be valid alternatives for this example, because here the tags don't overlap:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<sentence><line>This is a </line><line>sentence.</line></sentence>\n",
    "<sentence>This is a <linebreak/>sentence.</sentence>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This limitation has to with the fact that XML is a *hierarchical* markup language: it assumes that we can describe a text document as a tree of branching nodes. In this tree, elements cannot have more than one direct parent element (otherwise the hearchy would be ambiguous). The one exception is the so-called root element, which as the highest node in tree does not have a parent element itself. Logically speaking, all this entails that a valid XML document can only have a single *root element*. Note that all non-root elements can have as many siblings as we wish. All the `<line>` elements in our sonnet, for example, are siblings, in the sense that they have in common a direct parent element, i.e. the <sonnet> tag. Finally, note that we can add extra information to our elements using so-called attributes. The `n` attribute, for example, give us the line number for each line in the sonnet, surrounded by double quotation marks. The <sonnet> element illlustrates that we can add as many attributes as we want to a tag. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XML and Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Researchers in the Digital Humanities nowadays often put a lot of time and effort in creating digital data sets for their research, such as scholarly editions with a rich markup encoded in XML. Nevertheless, once this data has been annotated, it can be tricky to get your texts out again, so to speak, and fully exploit the information which you painstakingly encoded. Therefore, it is crucial to be able to parse XML in an efficient manner. Luckily, Python provides all the tools necessary to do this. We will make use of the `lxml` library, which is part of the Anaconda Python distribution: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from lxml import etree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the record, we should mention that there exist many other libraries in Python to parse XML, such as `minidom` or `BeautifulSoup` which is an interesting library, when you intend to scrape data from the web. While these might come with more advanced bells and whistles than `lxml`, they can also be more complex to use, which is why we stick to `lxml` in this course. Let us now import our sonnet in Python, which has been saved in the file `sonnet18.xml`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tree = etree.parse(\"data/TEI/sonnet18.xml\")\n",
    "print(tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has now read and parsed our xml-file via the `etree.parse()` function. We have stored our XML tree structure, which is returned by the `parse()` function, in the `tree` variable, so that we can access it later. If we print `tree` as such, we don't get a lot of useful information. To have a closer look at the XML in a printable text version, we need to call the `tostring()` method on the `tree` before printing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(etree.tostring(tree))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that we actually get a string in a raw format: if we want to display it properly, we have to decode it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(etree.tostring(tree).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have more complex data, it might also be to set the `pretty_print` parameter to `True`, to obtain a more beautifully formatted string, with Python taking care of indendation etc. In our example, it doesn't change much:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(etree.tostring(tree, pretty_print=True).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us start processing the contents of our file. Suppose that we are not really interested in the full hierarchical structure of our file, but just in the rhyme words occuring in it. The high-level function `interfind()` allows us to easily select all `rhyme`-element in our tree, regardless of where exactly they occur. Because this functions returns a list of nodes, we can simply loop over them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for node in tree.iterfind(\"//rhyme\"):\n",
    "    print(node)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the search expression (`\"//rhyme\"`) has two forward slashes before our actual search term. This is in fact XPath syntax, and the two slashes indicate that the search term can occur anywhere (e.g. not necessarily among a node's direct children). Unfortunately, printing the nodes themselves again isn't really insightful: in this way, we only get rather prosaic information of the Python objects holding our `rhyme` nodes. We can use the `.tag` property to print the tag's name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for node in tree.iterfind(\"//rhyme\"):\n",
    "    print(node.tag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract the actual rhyme word contained in the element, we can use the `.text` property of the nodes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for node in tree.iterfind(\"//rhyme\"):\n",
    "    print(node.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks better!\n",
    "\n",
    "Just now, we have been iterating over our `rhyme` elements in simple order of appearance: we haven't been really been exploiting the hierarchy of our XML file yet. Let's see now how we can navigate our xml tree. Let's first select our root node: there's a function for that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root_node = tree.getroot()\n",
    "print(root_node.tag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the value of the attributes of an element via `.attrib`, just like we would access the information in a Python dictionary, that is via key-based indexing. We know that our `sonnet` element, for instance, should have an `author` and `year` attribute. We can inspect the value of these as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(root_node.attrib[\"author\"])\n",
    "print(root_node.attrib[\"year\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wouldn't know which attributes were in fact available for a node, we could also retrieve the attribute names by calling `keys()` on the `attributes` property of a node, just like we would do with a regular dictionary: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for key in root_node.attrib.keys():\n",
    "    print(root_node.attrib[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far so good. Now that we have selected our root element, we can start drilling down our tree's structure. Let us first find out how many child nodes our root element has: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(len(root_node))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our root node turns out to have 15 child nodes, which makes a lot of sense, since we have 14 `line` elements and the `volta`. We can actually loop over these children, just as we would loop over any other list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for node in root_node:\n",
    "    print(node.tag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract the actual text in our lines, we need one additional `for`-loop which will allow us to iteratre over the pieces of text under each line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for node in root_node:\n",
    "    if node.tag != \"volta\":\n",
    "        line_text = \"\"\n",
    "        for text in node.itertext():\n",
    "            line_text = line_text + text\n",
    "        print(line_text)\n",
    "    else:\n",
    "        print(\"=== Volta found! ===\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we get an empty line at the `volta`, since there isn't any actual text associated with this empty tag."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz!\n",
    "Could you now write your own code, which iterates over the lines in our tree and prints out the line number based on the `n` attribute of the `line` element?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for node in root_node:\n",
    "    if node.tag == \"line\":\n",
    "        print(node.attrib[\"n\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating XML in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have parsed XML in Python, we haven't dealt with creating or manipulating XML in Python. Luckily, adapting or creating XML is fairly straightforward in Python. Let's first try and change the author's name in the `author` attribute of the `sonnet`. Because this boils down to manipulating a Python dictionary, the syntax should already be familiar to you: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root_node = tree.getroot()\n",
    "root_node.attrib[\"author\"] = \"J.K. Rowling\"\n",
    "root_node.attrib[\"year\"] = \"2015\"\n",
    "root_node.attrib[\"new_element\"] = \"dummy string!\"\n",
    "root_node.attrib[\"place\"] = \"maynooth\"\n",
    "print(etree.tostring(root_node).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was easy, wasn't it? Did you see we can just add new attributes to an element? Just take care only to put strings as attribute values: since we are working with XML, Python won't accept e.g. numbers and you will get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "root_node.attrib[\"year\"] = \"2015\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding whole elements is fairly easy too. Let's add a single dummy element (`<break/>`) to indicate a line break at the end of each line. Importantly, we have to create this element inside our loop, before we can add it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "break_el = etree.Element(\"break\")\n",
    "break_el.attrib[\"author\"] = \"Mike\"\n",
    "print(etree.tostring(break_el).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that we actually created an empty `<break/>` tag. Now, let's add it add the end of each line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for node in tree.iterfind(\"//line\"):\n",
    "    break_el = etree.Element(\"break\")\n",
    "    node.append(break_el)\n",
    "print(etree.tostring(tree).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding an element with actual content is just as easy by the way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "break_el = etree.Element(\"break\")\n",
    "print(etree.tostring(break_el).decode())\n",
    "break_el.text = \"XXX\"\n",
    "print(etree.tostring(break_el).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "The `<break/>` element is still empty: could you add to it an `n` attribute, to which you assign the line number from the current <line> element?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tree = etree.parse(\"data/TEI/sonnet18.xml\")\n",
    "root_node = tree.getroot()\n",
    "for node in root_node:\n",
    "    if node.tag == \"line\":\n",
    "        v = node.attrib[\"n\"]\n",
    "        break_el = etree.Element(\"break\")\n",
    "        break_el.attrib[\"n\"] = v\n",
    "        node.append(break_el)\n",
    "print(etree.tostring(tree).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python for TEI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Digital Humanities, you hear a lot about the TEI nowadays, or the Text Encoding Initiative ([tei-c.org](http://www.tei-c.org/index.xml)). The TEI refers to an initiative which has developed a highly influential \"dialect\" of XML for encoding texts in the Humanities. The beauty about XML is that tag names aren't predefined and you can invent your own tag and attributes. Our Shakepearean example could just have well have read:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<?xml version=\"1.0\"?>\n",
    "<poem writer=\"William Shakepeare\" date=\"1609\">\n",
    "\t<l nr=\"1\">Shall I compare thee to a summer's <last>day</last>?</l>\n",
    "\t<l nr=\"2\">Thou art more lovely and more <last>temperate</last>:</l>\n",
    "\t<l nr=\"3\">Rough winds do shake the darling buds of <last>May</last>,</l>\n",
    "\t<l nr=\"4\">And summer's lease hath all too short a <last>date</last>:</l>\n",
    "\t<l nr=\"5\">Sometime too hot the eye of heaven <last>shines</last>,</l>\n",
    "\t<l nr=\"6\">And often is his gold complexion <last>dimm'd</last>;</l>\n",
    "\t<l nr=\"7\">And every fair from fair sometime <last>declines</last>,</l>\n",
    "\t<l nr=\"8\">By chance, or nature's changing course, <last>untrimm'd</last>;</l>\n",
    "    <break/>\n",
    "\t<l nr=\"9\">But thy eternal summer shall not <last>fade</last></l>\n",
    "\t<l nr=\"10\">Nor lose possession of that fair thou <last>ow'st</last>;</l>\n",
    "\t<l nr=\"11\">Nor shall Death brag thou wander'st in his <last>shade</last>,</l>\n",
    "\t<l nr=\"12\">When in eternal lines to time thou <last>grow'st</last>;</l>\n",
    "\t<l nr=\"13\">So long as men can breathe or eyes can <last>see</last>,</l>\n",
    "\t<l nr=\"14\">So long lives this, and this gives life to <last>thee</last>.</l>\n",
    "</poem>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, all the tag and attribute names are different in this version, but the essential structure is still the same. You could therefore say that XML is a markup language which provides a *syntax* to talk about texts, but does not come with a default *semantics*. This freedom in choosing name tags etc. can also be a bit daunting: this is why the TEI provides Guidelines as how tag names etc. can be used to mark up specific phenomena in texts. The TEI therefore also refers to a rather bulky set of guidelines as to which tags could be used to properly encode a text. Below, we read in a fairly advanced example of Shakepeare's 17th sonnet encoded in TEI (note the use of the `<TEI>` tag as our root node!). Even the metrical structure has been encoded as you will see, so this can be considered an example \"TEI on steroids\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tree = etree.parse(\"data/TEI/sonnet17.xml\")\n",
    "print(etree.tostring(tree).decode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quiz\n",
    "\n",
    "Processing TEI in Python, is really just processing XML in Python, the dark art which you already learned to master above! Let's try and practice the looping techniques we introduced above. Could you provide code which parses the xml and writes away the lines in this poem to a plain text file, with one verse line on a single line in the new file?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# add your parsing code here... "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A hands-on case study: French plays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, it time to get your hands even more dirty. For textual analyses, there are a number of great datasets out there which have been encoded in rich XML. One excellent resource which we have recently worked with, can be found at [theatre-classique.fr](http://www.theatre-classique.fr/): this website holds an extensive collection of French plays from the time of the Classical and Enlightenment era in France. Some of the plays have been authored by some of France's finest authors such as Molière pr Pierre and Thomas Corneille. What is interesting about this resource, is that it provides a very rich XML markup: apart from extensive metadata on the play or a detailed descriptions of the actors involved, the actually lines have been encoded in such a manner, that we perfectly know which character uttered a particular line, or to which scene or act a line belongs. This allows us to perform much richer textual analyses than if we would only have a raw text version of the plays. We have collected a subset of these plays for you under the `data/TEI`directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "dirname = \"data/TEI/french_plays/\"\n",
    "for filename in os.listdir(dirname):\n",
    "    if filename.endswith(\".xml\"):\n",
    "        print(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK: under this directory, we appear to have a bunch of XML-files, but their titles are just numbers, which doesn't tell us a lot. Let's have a look at what's the title and author tags in these files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for filename in os.listdir(dirname):\n",
    "    if filename.endswith(\".xml\"):\n",
    "        print(\"*****\")\n",
    "        print(\"\\t-\", filename)\n",
    "        tree = etree.parse(dirname+filename)\n",
    "        author_element = tree.find(\"//author\") # find vs iterfind!\n",
    "        print(\"\\t-\", author_element.text)\n",
    "        title_element = tree.find(\"//title\")\n",
    "        print(\"\\t-\", title_element.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we have made you a nice subset selection of this data, containing only texts by the famous pair of brothers: Pierre and Thomas Corneille. We have provided a number of exercises in which you can practice your newly developed XML skills. In each of the fun little tasks below, you should compare the dramas of our two famous brothers:\n",
    "* how many characters does each brother on average stage in a play?\n",
    "* which brother has the highest vocabulary richness?\n",
    "* which brother uses the lengthiest speeches per character on average?\n",
    "* which brother gives most \"speech time\" to women, expressed in number of words (hint: you can derive a character's gender from the `<castList>` in most plays!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "    }\n",
       "    div.cell {\n",
       "        width:800px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    div.cell, .input.hbox {\n",
       "    display:block;\n",
       "}\n",
       "    h1 {\n",
       "        font-family: \"Charis SIL\", Palatino, serif;\n",
       "    }\n",
       "    h4{\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "    div.text_cell_render{\n",
       "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 145%;\n",
       "        font-size: 120%;\n",
       "        width:800px;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
       "    }\n",
       "    .prompt{\n",
       "        display: None;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: #4057A1;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }\n",
       "\n",
       "    blockquote {\n",
       "    border-left: 4px solid #DDDDDD;\n",
       "    color: #777777;\n",
       "        padding: 0 15px;\n",
       "        }\n",
       "\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    styles = open(\"styles/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}