Chapter 11 - Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 11 - Strings\n",
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "A string is a sequence of letters/characters which are compounded to form a whole. In Python a string is a type of variable for which the value is enclosed by single- or double-quotes. A string can contain a large variety of characters, numbers, and symbols and can be a single letter long or contain entire books.\n",
    "\n",
    "The basic usage of a string is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# We can declare a string using single or double quotes, there is no difference.\n",
    "course = \"Data Processing\"\n",
    "university = 'Tilburg University'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if your string contains a quote-symbol it can lead to errors if you enclose it with the wrong quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-025f82182cb9>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-11-025f82182cb9>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    restaurant = 'Wendy's'\u001b[0m\n\u001b[0m                        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Run this cell to see the error generated by the following line.\n",
    "restaurant = 'Wendy's'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above the error indicates that there is something wrong with the letter s, this is because the single-quote closes the string we started, and anything after that is unexpected by python.\n",
    "\n",
    "To solve this we can enclose the string in double-quotes, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "restaurant = \"Wendy's\"\n",
    "# Similarly we can also enclose a string containing double-quotes with single-quotes as such:\n",
    "quotes = 'Using \"double\" quotes enclosed by a single quote.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multi-line strings\n",
    "\n",
    "Strings in python can also span across multiple lines, which can be useful for when you have a very long string, or for when you want to format the output of the string in a certain way. This can be achieved in two ways:\n",
    "\n",
    "1. With single or double quotes, where we manually indicates that the rest of the string continues on the next line with a backslash.\n",
    "2. With three single or double quotes.\n",
    "\n",
    "We will first demonstrate how this would work when you use one double or single quote."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A very long string\n",
      "can be split into multiple\n",
      "sentences by appending a blackslash\n",
      "to the end of the line.\n"
     ]
    }
   ],
   "source": [
    "# This example also works with single-quotes.\n",
    "longString = \"A very long string\\n\\\n",
    "can be split into multiple\\n\\\n",
    "sentences by appending a blackslash\\n\\\n",
    "to the end of the line.\"\n",
    "\n",
    "print(longString)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \\n or **n**ew**l**ine symbol indicates that we want to start the rest of the text on a new line in the string, the following \\ indicates that we want the string to continue on the next line of the code. This difference can be quite hard to understand, but best illustrated with an example where we do not include the \\n symbol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A very long string can be split into multiple sentences by appending a blackslash to the end of the line.\n"
     ]
    }
   ],
   "source": [
    "longString = \"A very long string \\\n",
    "can be split into multiple \\\n",
    "sentences by appending a blackslash \\\n",
    "to the end of the line.\"\n",
    "\n",
    "print(longString)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, python now interprets this example as a single line of text. If we use the recommended way in python to write multiline strings, with triple double or singles quotes, you will see that the \\n or newline symbol is automatically included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A very long string\n",
      "can also be split into multiple \n",
      "sentences by enclosing the string\n",
      "with three double or single quotes.\n",
      "\n",
      "A very long string\n",
      "can also be split into multiple \n",
      "sentences by enclosing the string\n",
      "with three double or single quotes.\n"
     ]
    }
   ],
   "source": [
    "longString = \"\"\"A very long string\n",
    "can also be split into multiple \n",
    "sentences by enclosing the string\n",
    "with three double or single quotes.\"\"\"\n",
    "\n",
    "print(longString)\n",
    "\n",
    "print()\n",
    "\n",
    "anotherLongString = '''A very long string\n",
    "can also be split into multiple \n",
    "sentences by enclosing the string\n",
    "with three double or single quotes.'''\n",
    "\n",
    "print(anotherLongString)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Indices\n",
    "Each symbol in a string has a position, this position can be referred to by the index number of the position. The index numbers start at 0 and then increase to the length of the string. The following table shows the word \"oranges\"in the first row and the indices for each letter in the second row:\n",
    "\n",
    "| O | R | A | N | G | E | S |\n",
    "|---|---|---|---|---|---|---|\n",
    "| 0 | 1 | 2 | 3 | 4 | 5 | 6 |\n",
    "| -7 | -6 | -5 | -4 | -3 | -2 | -1 |\n",
    "\n",
    "We can extract letters from a string by referring to them by their index number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O\n",
      "r\n",
      "s\n",
      "\n",
      "O\n",
      "r\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Oranges\"\n",
    "print(fruit[0]) # O\n",
    "print(fruit[1]) # r\n",
    "# ...\n",
    "print(fruit[6]) # s\n",
    "print()\n",
    "# Besides using positive numbers it is also possible to refer to positions using a negative index number\n",
    "print(fruit[-7]) # O\n",
    "print(fruit[-6]) # r\n",
    "# ...\n",
    "print(fruit[-1]) # s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides using single indices we can also extract a range from a string, a range is indicated using a colon (:), where the left number indicates the starting index and the right one the last index (exclusive). By leaving out the left index the range will start at the beginning of the string, by leaving out the right index the range will include the last character of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oranges\n",
      "Oranges\n",
      "Oranges\n",
      "\n",
      "Orange\n",
      "\n",
      "range\n",
      "\n",
      "a range\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Oranges\"\n",
    "print(fruit[:])\n",
    "print(fruit[0:])\n",
    "print(fruit[:7])\n",
    "print()\n",
    "print(fruit[:6])\n",
    "print()\n",
    "print(fruit[1:-1])\n",
    "print()\n",
    "print(fruit[2], fruit[1:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The length of a string can be found using the len() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Oranges\"\n",
    "print(len(fruit))\n",
    "print(fruit[len(fruit)-1]) # This can be used to find the last letter, but it is easier to just use -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traversing strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because strings are sequence we can traverse them, and visit each symbol. The simplest way of doing this is with a loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A - p - p - l - e - \n",
      "A - p - p - l - e - \n"
     ]
    }
   ],
   "source": [
    "fruit = 'Apple'\n",
    "for char in fruit:\n",
    "    print(char, '- ', end='') # end='' allows us to not print every letter on a new line\n",
    "print()\n",
    "\n",
    "for i in range(len(fruit)):\n",
    "    print(fruit[i], '- ', end='')\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can also iterative over multiple characters at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ora\n",
      "nge\n",
      "\n",
      "Ora\n",
      "ran\n",
      "ang\n",
      "nge\n",
      "\n",
      "Orange X \n",
      "range X O\n",
      "ange X Or\n",
      "nge X Ora\n",
      "ge X Oran\n",
      "e X Orang\n",
      " X Orange\n",
      "\n",
      "Orange X \n",
      "range X O\n",
      "ange X Or\n",
      "nge X Ora\n",
      "ge X Oran\n",
      "e X Orang\n",
      " X Orange\n"
     ]
    }
   ],
   "source": [
    "fruit = 'Orange'\n",
    "for i in range(0,len(fruit),3):\n",
    "    print(fruit[i:i+3])\n",
    "print()\n",
    "\n",
    "for i in range(len(fruit)-2):\n",
    "    print(fruit[i:i+3])\n",
    "print()\n",
    "\n",
    "i = 0\n",
    "while i <= len(fruit):\n",
    "    print( fruit[i:], \"X\", fruit[:i] )\n",
    "    i += 1\n",
    "    \n",
    "print()\n",
    "\n",
    "for i in range(len(fruit)+1):\n",
    "    print( fruit[i:], \"X\", fruit[:i] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extended slices\n",
    "\n",
    "Slices in python can take a third argument, which is the step size or the stride that is taken between indices, this is similar to the third argument for the range() function. The format for slices then becomes: string[begin:end:step], where begin, end and step are numbers we can choose. By default the step size is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Pineapple\"\n",
    "print(fruit[4:9])\n",
    "# is the same as\n",
    "print(fruit[4:9:1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The stride can be increased to only take some letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaa\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Banana\"\n",
    "print(fruit[1:6:2]) # take every other letter in the range 1 to 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, the stride can be used with an unspecified range (or using the entire string), and it is also possible to specify a negative stride."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaa\n",
      "\n",
      "ananaB\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Banana\"\n",
    "print(fruit[::-2]) # We leave the range empty to get the entire string, similar to: fruit[:]\n",
    "print()\n",
    "print(fruit[::-1]) # This is a common way in python to reverse strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reversing a string using [::-1] is conceptually similar to traversing the string from the last character to the beginning of the string in backward steps of -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n",
      "B\n"
     ]
    }
   ],
   "source": [
    "fruit = \"Banana\"\n",
    "for i in range(5, -1, -1):\n",
    "    print(fruit[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python it is possible to use comparison operators (as used in conditional statements) on strings. These operators are: ==, !=, <, <=, >, and >= \n",
    "\n",
    "The order of letters is alphabetical, but uppercase letters come before lowercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('a' == 'a')\n",
    "print('a' != 'b')\n",
    "print('a' == 'A')\n",
    "print('a' > 'A') # 'a' is smaller than 'A'\n",
    "print()\n",
    "print('orange' == 'Orange')\n",
    "print('orange' > 'Orange')\n",
    "print('orange' < 'Orange')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of comparing strings is to check whether a string is part of another string, this can be done using the 'in' operator, as such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print('a' in \"abcdefg\")\n",
    "# Or for longer strings:\n",
    "print('word' in 'A sentence with words.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Immutability\n",
    "\n",
    "The mutability of an object, like a string or a variable refers to how liable the object is to change. Because strings are immutable they cannot be changed, it is possible to create a new string based on the old one, but we cannot modify the string in place. The cell below demonstrates this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "guana island\n",
      "\n",
      "banana\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-9dc476385b58>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mfruit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfruit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'na'\u001b[0m \u001b[0;31m# This works because we are creating a new string and overwriting our old one\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfruit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mfruit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'an'\u001b[0m \u001b[0;31m# This does not work because now we are trying to change an existing string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;31m# If we want to do this then we need to do:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mfruit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfruit\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'an'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "fruit = 'guanabana'\n",
    "island = fruit[:5] # This is fine, because we are creating a new string\n",
    "print(island, 'island')\n",
    "print()\n",
    "fruit = fruit[5:] + 'na' # This works because we are creating a new string and overwriting our old one\n",
    "print(fruit)\n",
    "fruit[4:5] = 'an' # This does not work because now we are trying to change an existing string\n",
    "# If we want to do this then we need to do:\n",
    "fruit = fruit[:4] + 'an'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reasons for why strings are immutable are beyond the scope of this notebook, but just remember that if you want to modify a string you need to overwrite the entire strong, and you cannot modify individual indices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The string module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string module contains a collection of methods that are designed to operate on strings. See the reference for a overview of string methods: https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "\n",
    "All of these methods can be applied to a string to perform some operation. Some examples are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Humpty Dumpty sat on the wall \n",
      "Humpty Dumpty sat on the wall\n",
      "HUMPTY DUMPTY SAT ON THE WALL\n",
      "humpty dumpty sat on the wall\n",
      "14\n",
      "16\n",
      "-1\n",
      "Humpty Dumpty fell off the wall\n",
      "Humpty\n",
      "Dumpty\n",
      "Sat\n",
      "On\n",
      "The\n",
      "Wall\n",
      "Humpty-Dumpty-sat-on-the-wall\n"
     ]
    }
   ],
   "source": [
    "s = ' Humpty Dumpty sat on the wall '\n",
    "print( s )\n",
    "s = s.strip() # This function removes leading and trialing whitespace\n",
    "print( s )\n",
    "\n",
    "print( s.upper() )\n",
    "print( s.lower() )\n",
    "\n",
    "print( s.find( 'sat' ) )\n",
    "print( s.find( 't', 12 ) )\n",
    "print( s.find( 'q', 12 ) )\n",
    "print( s.replace( 'sat on', 'fell off' ) )\n",
    "\n",
    "words = s.split() # This returns a list, which are outside of the scope for this notebook.\n",
    "for word in words: # But you can iterate over each word in this manner\n",
    "    print( word.capitalize() )\n",
    "print( '-'.join( words ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split() allows you to split a string based on a given character, by default it uses a space (\" \"), but you can change it to any character or combination of characters you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "D\n",
      "sat on the wall\n"
     ]
    }
   ],
   "source": [
    "s = 'Humpty Dumpty sat on the wall'\n",
    "splits = s.split('umpty')\n",
    "for word in splits:\n",
    "    print(word.strip()) # We use strip() here because splitting on 'umpty' retains the whitespace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very useful property of splitting is that we can decode some basic file formats, for example a comma separated value (CSV) file is a very simple format, the basic setup of this file is that each line consists of values that are separated by a comma. \n",
    "\n",
    "These values can be split from each other using the split() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015\n",
      "September\n",
      "28\n",
      "Data Processing\n",
      "Tilburg University\n",
      "Tilburg\n"
     ]
    }
   ],
   "source": [
    "csv = \"2015, September, 28, Data Processing, Tilburg University, Tilburg\"\n",
    "values = csv.split(',')\n",
    "for value in values:\n",
    "    print(value.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ASCII\n",
    "\n",
    "A string is a sequence of characters, each character can be encoded as a code using an encoding scheme. A commonly used encoding-scheme is ASCII (more at: https://en.wikipedia.org/wiki/ASCII). In python it is possible to convert back and forth between characters and their encoding using the chr() and ord() functions. chr() the character that correspond to the ASCII code we passed as input, wheras ord() returns the opposite, the ASCII code when given a character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65\n",
      "97\n",
      "\n",
      "A\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "print(ord('A'))\n",
    "print(ord('a'))\n",
    "\n",
    "print()\n",
    "\n",
    "print(chr(65))\n",
    "print(chr(97))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see the character 'A' is converted to the number 65, and the character 'a' is converted to the number 97. This is also the explanation why the comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('a' > 'A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "returns the value 'True', because the ASCII code for the character 'a' is greater than that of the character 'A'. \n",
    "\n",
    "Below you can find an example of the ASCII chart generated using python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 1 2 3 4 5 6 7 8 9 A B C D E F\n",
      "2   ! \" # $ % & ' ( ) * + , - . /\n",
      "3 0 1 2 3 4 5 6 7 8 9 : ; < = > ?\n",
      "4 @ A B C D E F G H I J K L M N O\n",
      "5 P Q R S T U V W X Y Z [ \\ ] ^ _\n",
      "6 ` a b c d e f g h i j k l m n o\n",
      "7 p q r s t u v w x y z { | } ~ \n"
     ]
    }
   ],
   "source": [
    "print( ' ', end='' )\n",
    "for i in range(16):\n",
    "    if i < 10:\n",
    "        print( ' '+chr(ord('0')+i), end='' )\n",
    "    else:\n",
    "        print( ' '+chr(ord('A')+i-10), end='' )\n",
    "print()\n",
    "for i in range(2,8):\n",
    "    print( i, end='' )\n",
    "    for j in range(16):\n",
    "        c = i*16+j\n",
    "        if chr(c) in ' \\t\\n\\r\\f':\n",
    "            print( '  ', end='' )\n",
    "        else:\n",
    "            print( ' '+chr(c), end='' )\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might've noticed in previously notebooks that strings were sometimes followed by the format() function,\n",
    "with the following notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'text to print'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"text to {}\".format(\"print\")\n",
    "\n",
    "\"{} {} {}\".format(\"text\", \"to\", \"print\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While in these cases it is not very useful to use formatted strings, there are times where it can make the code a lot more easy to understand and nicely formatted. When you have some information there are different ways of placing this information in a string, with and without format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "His name is Bruce Banner and his alter ego is The Hulk, a big Green superhero from the USA.\n",
      "His name is Bruce Banner and his alter ego is The Hulk, a big Green superhero from the USA.\n",
      "His name is Bruce Banner and his alter ego is The Hulk, a big Green superhero from the USA.\n"
     ]
    }
   ],
   "source": [
    "name = 'Bruce Banner'\n",
    "alterego = 'The Hulk'\n",
    "colour = 'Green'\n",
    "country = 'USA'\n",
    "\n",
    "# By setting the separator to '' we can concatenate strings without white space in between and print them\n",
    "print(\"His name is \", name, \" and his alter ego is \", alterego, \n",
    "      \", a big \", colour, \" superhero from the \", country, \".\", sep='')\n",
    "# another way is:\n",
    "print(\"His name is \" + name +\" and his alter ego is \" + alterego + \n",
    "      \", a big \" + colour + \" superhero from the \" + country +\".\")\n",
    "# and yet another way, this time using format is:\n",
    "print(\"His name is {} and his alter ego is {}, a big {} superhero from the {}.\".format(name, alterego, colour, country))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "{} is a placeholder that can be used to indicate where in the text we would like to place our formatted text.\n",
    "The placeholder can be modified using the format specification to do more advanced formatting, below we will show some examples. More information about the format specification can be found at: https://docs.python.org/3/library/string.html#formatspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "a b c\n",
      "c b a\n",
      "\n",
      "My name is Bobby Hill and I am 21 years old\n",
      "\n",
      "10 or 10.00 or 10.000000 or 10.000000\n",
      "\n",
      "Potatoes:   100.\n",
      "Potatoes: 10000.\n",
      "Potatoes: 100  .\n",
      "Potatoes: 10000.\n",
      "\n",
      "Potatoes: 10000.\n",
      "Potatoes:  1.\n"
     ]
    }
   ],
   "source": [
    "# Numbered formatting\n",
    "print(\"{}{}{}\".format(\"a\", \"b\", \"c\"))\n",
    "print(\"{0} {1} {2}\".format(\"a\", \"b\", \"c\"))\n",
    "print(\"{2} {1} {0}\".format(\"a\", \"b\", \"c\"))\n",
    "print()\n",
    "# Named formatting\n",
    "print(\"My name is {name} and I am {years} years old\".format(years=21, name=\"Bobby Hill\"))\n",
    "# Adjusting number precision\n",
    "print()\n",
    "print(\"{:d} or {:.2f} or {:.6f} or {:f}\".format(10, 10, 10, 10))\n",
    "# Adjusting the alignment and width\n",
    "print()\n",
    "print(\"Potatoes: {:>5}.\".format(100))\n",
    "print(\"Potatoes: {:>5}.\".format(10000))\n",
    "print(\"Potatoes: {:<5}.\".format(100))\n",
    "print(\"Potatoes: {:<5}.\".format(10000))\n",
    "print()\n",
    "print(\"Potatoes: {:>2}.\".format(10000)) # This works, but defeats the purpose of aligning\n",
    "print(\"Potatoes: {:>2}.\".format(1)) # because it is not lined up with this line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formatting strings can be especially nice when we want to repeatedly print nicely formatted information that is of consistent length to make it more readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step   0 is  0.00% of the total, with 100.00% remaining.\n",
      "Step  75 is  7.50% of the total, with  92.50% remaining.\n",
      "Step 150 is 15.00% of the total, with  85.00% remaining.\n",
      "Step 225 is 22.50% of the total, with  77.50% remaining.\n",
      "Step 300 is 30.00% of the total, with  70.00% remaining.\n",
      "Step 375 is 37.50% of the total, with  62.50% remaining.\n",
      "Step 450 is 45.00% of the total, with  55.00% remaining.\n",
      "Step 525 is 52.50% of the total, with  47.50% remaining.\n",
      "Step 600 is 60.00% of the total, with  40.00% remaining.\n",
      "Step 675 is 67.50% of the total, with  32.50% remaining.\n",
      "Step 750 is 75.00% of the total, with  25.00% remaining.\n",
      "Step 825 is 82.50% of the total, with  17.50% remaining.\n",
      "Step 900 is 90.00% of the total, with  10.00% remaining.\n",
      "Step 975 is 97.50% of the total, with   2.50% remaining.\n"
     ]
    }
   ],
   "source": [
    "maximum = 1000\n",
    "steps = 75\n",
    "for i in range(0, maximum, steps):\n",
    "    print(\"Step {:>3} is {:>6.2%} of the total, with {:>7.2%} remaining.\".format(i, \n",
    "                                                                i/maximum, (maximum-i)/maximum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is more consistent than, and it is easier to compare between lines than when we print the lines like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0 is0.00% of the total, with 100.00% remaining.\n",
      "Step 75 is7.50% of the total, with 92.50% remaining.\n",
      "Step 150 is15.00% of the total, with 85.00% remaining.\n",
      "Step 225 is22.50% of the total, with 77.50% remaining.\n",
      "Step 300 is30.00% of the total, with 70.00% remaining.\n",
      "Step 375 is37.50% of the total, with 62.50% remaining.\n",
      "Step 450 is45.00% of the total, with 55.00% remaining.\n",
      "Step 525 is52.50% of the total, with 47.50% remaining.\n",
      "Step 600 is60.00% of the total, with 40.00% remaining.\n",
      "Step 675 is67.50% of the total, with 32.50% remaining.\n",
      "Step 750 is75.00% of the total, with 25.00% remaining.\n",
      "Step 825 is82.50% of the total, with 17.50% remaining.\n",
      "Step 900 is90.00% of the total, with 10.00% remaining.\n",
      "Step 975 is97.50% of the total, with 2.50% remaining.\n"
     ]
    }
   ],
   "source": [
    "maximum = 1000\n",
    "steps = 75\n",
    "for i in range(0, maximum, steps):\n",
    "    print(\"Step {} is{:.2%} of the total, with {:.2%} remaining.\".format(i, \n",
    "                                                                i/maximum, (maximum-i)/maximum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------\n",
    "#Exercises chapter 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 1: In the following code cell you are given a string that contains the same spelling error (vox instead of fox), replace all occcurances of this spelling error with the correct spelling. Hint use [str.replace()](https://docs.python.org/3/library/stdtypes.html#str.replace)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = \"\"\"The quick, brown vox jumps over a lazy dog. DJs flock by when MTV ax quiz prog. \n",
    "Junk MTV quiz graced by vox whelps. Bawds jog, flick quartz, vex nymphs. \n",
    "Waltz, bad nymph, for quick jigs vex! Vox nymphs grab quick-jived waltz. \n",
    "Brick quiz whangs jumpy veldt vox. \"\"\"\n",
    "\n",
    "# Your code here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 2: In the following cell you are given a string that contains an @, print all the text that occurs before this @. Hint use [str.find()](https://docs.python.org/3/library/stdtypes.html#str.find) and string indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = \"\"\"Tilburg University’s goal is to actively contribute to society. \n",
    "@ We want to serve society and make it a better place for all citizens. \n",
    "Our university has always actively promoted ways to firmly embed our education and research in society.\"\"\"\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 3: Check (using python) if the string given in the following cell contains the word \"Semantics\". Use a if-statement and print \"yes\" if it does and \"no\" if it does not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text = \"\"\"Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean. A small river named Duden flows by their place and supplies it with the necessary regelialia. \"\"\"\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 4: Count how many of each vowel (a,e,i,o,u) there are in the text string in the next cell, and print the count for each vowel with a single formatted string. Remember that vowels can be both lower and uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text = \"\"\"But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system, and expound the actual teachings of the great explorer of the truth, the master-builder of human happiness. No one rejects, dislikes, or avoids pleasure itself, because it is pleasure, but because those who do not know how to pursue pleasure rationally encounter consequences that are extremely painful. Nor again is there anyone who loves or pursues or desires to obtain pain of itself, because it is pain, but because occasionally circumstances occur in which toil and pain can procure him some great pleasure. To take a trivial example, which of us ever undertakes laborious physical exercise, except to obtain some advantage from it? But who has any right to find fault with a man who chooses to enjoy a pleasure that has no annoying consequences, or one who avoids a pain that produces no resultant pleasure? On the other hand, we denounce with righteous indignation and dislike men who are so beguiled and demoralized by the charms of pleasure of the moment, so blinded by desire, that they cannot foresee the pain and trouble that are bound to ensue; and equal blame belongs to those who fail in their duty through weakness of will, which is the same as saying through shrinking from toil and pain.\"\"\"\n",
    "\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ex 5: The text string in the next cell contains several words which are enclosed by square brackets ('[' and ']'). Scan through the string and print out all words which are between square brackets. For example if the text string is \"[a]n example [string]\", you are expected to print out \"a string\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = \"\"\"The quick, brown fox jumps over a lazy dog. DJs flock by when MTV ax quiz prog. Junk MTV quiz graced by fox whelps. [Never gonna ] Bawds jog, flick quartz, vex nymphs. [give you up ] Waltz, bad nymph, for quick jigs vex! Fox nymphs grab quick-jived waltz. Brick quiz whangs jumpy veldt fox. [Never ] Bright vixens jump; [gonna let ] dozy fowl quack. Quick wafting zephyrs vex bold Jim. Quick zephyrs blow, vexing daft Jim. Charged [you down ] fop blew my junk TV quiz. How quickly daft jumping zebras vex. Two driven jocks help fax my big quiz. Quick, Baz, get my woven flax jodhpurs! \"Now fax quiz Jack!\" my brave ghost pled. [Never ] Five quacking zephyrs jolt my wax bed. [gonna ] Flummoxed by job, kvetching W. zaps Iraq. Cozy sphinx waves quart jug of bad milk. [run around ] A very bad quack might jinx zippy fowls. Few quips galvanized the mock jury box. Quick brown dogs jump over the lazy fox. The jay, pig, fox, zebra, and my wolves quack! [and desert you] Blowzy red vixens fight for a quick jump. Joaquin Phoenix was gazed by MTV for luck. A wizard’s job is to vex chumps quickly in fog. Watch \"Jeopardy!\", Alex Trebek's fun TV quiz game.\"\"\"\n",
    "\n",
    "# Your code here"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}