MESS 2014 - Python Exercises.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {
      "slideshow": {
       "slide_type": "-"
      }
     },
     "source": [
      "# 4th Munich Earth Skience School \n",
      "\n",
      "### February 23-28, 2014\n",
      "\n",
      "![Home](http://www.geophysik.uni-muenchen.de/MESS/2011/haus_wald1.jpg)\n",
      "\n",
      "\n",
      "\n",
      "## Timetable\n",
      "\n",
      "|               | Morning 8:00-11:00   | Afternoon 15:00-18:00 |\n",
      "| ------------- |:--------------------| ----------------|\n",
      "| Monday        | Python Introduction        | Introduction to ObsPy (Waveforms/Metadata) |\n",
      "| Tuesday       | Introduction to ObsPy (Metadata/Webservice Clients)    |   Advanced Python |\n",
      "| Wednesday     | Introduction to Array Analysis            |     |    \n",
      "| Thursay       | Array Analysis - Practical             |    Array Analysis - Practical |\n",
      "| Friday        |  Array Analysis - Further Applications             |   |  \n",
      "\n",
      "\n",
      "![Python](http://www.python.org/static/community_logos/python-logo-generic.svg)\n",
      "![ObsPy](https://raw.github.com/obspy/website/master/logo/obspy_logo_full_524x179px.png)\n",
      "\n",
      "\n",
      "\n",
      "## Useful Links\n",
      "\n",
      "If you have any question regarding some specific Python functionality you can consult the official [Python documenation](http://docs.python.org/2/).\n",
      "\n",
      "Furthermore a large number of Python tutorials, introduction, and books are available online. These are some examples for those interested in learning more.\n",
      "\n",
      "* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)\n",
      "* [Dive Into Python](http://www.diveintopython.net/)\n",
      "* [The Official Python Tutorial](http://docs.python.org/2/tutorial/index.html)\n",
      "* [Think Python Book](http://www.greenteapress.com/thinkpython/thinkpython.html)\n",
      "\n",
      "Some people might be used to Matlab - this helps:\n",
      "\n",
      "* [NumPy for Matlab Users Introdution](http://wiki.scipy.org/NumPy_for_Matlab_Users)\n",
      "* [NumPy for Matlab Users Cheatsheet](http://mathesaurus.sourceforge.net/matlab-numpy.html)\n",
      "\n",
      "\n",
      "Additionally there is an abundance of resources introducing and teaching parts of the scientific Python ecosystem.\n",
      "\n",
      "* [NumPy Tutorial](http://wiki.scipy.org/Tentative_NumPy_Tutorial)\n",
      "* [Probabilistic Programming and Bayesian Methods for Hackers](http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/): Great ebook introducing Bayesian methods from an understanding-first point of view with the examples done in Python.\n",
      "* [Python Scientific Lecture Notes](http://scipy-lectures.github.io/): Introduces the basics of scientific Python with lots of examples.\n",
      "* [Notebook introducing SymPy](http://nbviewer.ipython.org/github/ipython/ipython/blob/master/examples/notebooks/SymPy%20Examples.ipynb): Notebook showing off the symbolic mathematics packages SymPy.\n",
      "* [Python for Signal Processing](http://python-for-signal-processing.blogspot.de/): Free blog which is the basis of a proper book written on the subject.\n",
      "* [Another NumPy Tutorial](http://www.loria.fr/~rougier/teaching/numpy/numpy.html), [Matplotlib Tutorial](http://www.loria.fr/~rougier/teaching/matplotlib/matplotlib.html)\n",
      "\n",
      "In the course of this week you might have a need to create some custom plots. The quickest way to success is usually to start from some example that is somewhat similar to what you want to achieve. These websites are good starting points:\n",
      "\n",
      "* [Matplotlib Gallery](http://matplotlib.org/gallery.html)\n",
      "* [ObsPy Gallery](http://docs.obspy.org/gallery.html)\n",
      "* [Basemap Gallery](http://matplotlib.org/basemap/users/examples.html)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Some Motivation\n",
      "\n",
      "To get a live picture of the skiing area, just execute this box! Reexecute to update."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import Image\n",
      "import time\n",
      "Image(url=\"http://www.sudelfeld.de/bayrischzell/images/webcams/webcam/waldkopf.jpg?ts=%f\" % time.time())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<img src=\"http://www.sudelfeld.de/bayrischzell/images/webcams/webcam/waldkopf.jpg?ts=1393233268.477742\"/>"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 54,
       "text": [
        "<IPython.core.display.Image at 0xa86f16c>"
       ]
      }
     ],
     "prompt_number": 54
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# A Short Introduction to Python\n",
      "\n",
      "\n",
      "## Exercise 0: Getting to know the Environment\n",
      "\n",
      "For this tutorial we are going to work in the IPython notebook but there are other ways of using Python as well.\n",
      "\n",
      "\n",
      "On the terminal, launch the python shell:\n",
      "\n",
      "```bash\n",
      "$ python\n",
      "```\n",
      "\n",
      "And the IPython shell:\n",
      "\n",
      "```bash\n",
      "$ ipython\n",
      "```\n",
      "\n",
      "One can execute a Python script like this:\n",
      "\n",
      "```bash\n",
      "$ python filename.py\n",
      "```\n",
      "\n",
      "If you ever need to launch the IPython notebook:\n",
      "\n",
      "```bash\n",
      "$ ipython notebook --pylab=inline\n",
      "```\n",
      "\n",
      "### The IPython Notebook\n",
      "\n",
      "What you see here is the IPython HTML notebook. It enables one to mix code, results, and descriptions to create interactive notebooks. It works with the notion of cells, each cell being either code, result, or a description. The descriptions are written in [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet), a light-weight markup language.\n",
      "\n",
      "The toolbar on the top has buttons to move between the cells, execute them, create new ones, and to change the type of a cell.\n",
      "\n",
      "\n",
      "* Execute cell: `Strg` + \u21b5\n",
      "* Execute cell and move to next cell: `Shift` + \u21b5\n",
      "* Access the documentation of an object: type `object?` and execute\n",
      "\n",
      "\n",
      "\n",
      "1. Create a new cell below this one.\n",
      "2. Type `print \"Hello World\"` in it and execute it.\n",
      "3. Create another cell below it.\n",
      "4. Change its type to markdown and enter some formula.\n",
      "5. Create a last cell.\n",
      "6. Query the documentation for the built-in `int` object."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print \"Hello world !\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello world !\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## New Heading\n",
      "\n",
      "Some text **bold**\n",
      "\n",
      "$\\int_0^6$"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 1: Numbers\n",
      "\n",
      "In Python it is not necessary to define variables. Once a value is assigned to a variable the variable will have the type of that value. That behaviour is known as **dynamic typing**. A variable can also change its type at any point of the program execution. That has its advantages but there are also some pitfalls.\n",
      "\n",
      "1. Define three variables with three different data types (*integer*, *float* and *complex*).\n",
      "2. Print the type of each. (using *print type(...)*).\n",
      "3. Use some arithmetics between the three variables and see what happens.\n",
      "\n",
      "Documentation: [Numbers](http://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 2\n",
      "b = 3.1\n",
      "c = 1 + 2j\n",
      "\n",
      "print type(a)\n",
      "print type(b)\n",
      "print type(c)\n",
      "\n",
      "print type(a * b)\n",
      "print type(a * c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'int'>\n",
        "<type 'float'>\n",
        "<type 'complex'>\n",
        "<type 'float'>\n",
        "<type 'complex'>\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 2: Strings\n",
      "\n",
      "String are denoted either with single or with double quotes. There is distinction between text and strings but that does not need to concern you right now. Strings have a number of methods attached to them which can be used to manipulate them. A string object can never be changed, they are said to be immutable. Thus every manipulation of a string object will always create a new object.\n",
      "\n",
      "\n",
      "1. Assign your name and your family name to two variables.\n",
      "2. Create your full name by adding two variables and assign it to a new variable.\n",
      "3. Print the uppercase version of your name by using one of the string methods.\n",
      "4. Print the first letters of your name and family name together, e.g. if your name is *Hans Musterman*, the output should be *HM*.\n",
      "\n",
      "Documentation: [Strings](http://docs.python.org/2/library/string.html)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "name = \"Lion\"\n",
      "family_name = \"Krischer\"\n",
      "full_name = name + \" \" + family_name\n",
      "print full_name\n",
      "print full_name.upper()\n",
      "print name[0] + family_name[0]\n",
      "full_name.split(\" \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Lion Krischer\n",
        "LION KRISCHER\n",
        "LK\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 21,
       "text": [
        "['Lion', 'Krischer']"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 3: Imports and Function Calling\n",
      "\n",
      "Extended functionality is organized in different modules which have to be imported before they can be used.\n",
      "\n",
      "```python\n",
      "# Import the whole math module.\n",
      "import math\n",
      "print math.pi\n",
      "\n",
      "# Import only a certain piece of it.\n",
      "from math import e\n",
      "print e\n",
      "\n",
      "# One can also give the imported functionality a different name.\n",
      "from math import cos as cosine\n",
      "\n",
      "# Function call.\n",
      "print cosine(0)\n",
      "```\n",
      "\n",
      "**Exercise:** What is x?\n",
      "\n",
      "\n",
      "![](http://www.mathwarehouse.com/trigonometry/images/sohcohtoa/find-missing-side-length/problem16.png)\n",
      "\n",
      "Hint: [math module](http://docs.python.org/2/library/math.html)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from math import tan, radians\n",
      "\n",
      "print tan(radians(67)) * 14"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "32.9819331215\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 4: Lists\n",
      "\n",
      "Lists are ordered sequences of arbitrary Python objects. They can be modified at any time and are, together with dictionaries, the most used data structures in the Python standard library.\n",
      "\n",
      "```python\n",
      "some_list = [1, 2]\n",
      "some_list.append(3)\n",
      "print some_list[0]\n",
      "```\n",
      "\n",
      "1. Define an arbitrary list (try different data types) and assign it to a variable.\n",
      "2. Print the first element of the list.\n",
      "3. Print the last two elements of the list.\n",
      "4. Append a new item to your list and print the result.\n",
      "5. Remove the first element of your list and print the result.\n",
      "6. Check if an object is in the list.\n",
      "7. Print the length of the list.\n",
      "\n",
      "Documentation: [del](http://docs.python.org/2/tutorial/datastructures.html#the-del-statement) and [lists](http://docs.python.org/2//library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_list = [1, 2, \"Name\", 1 + 1j]\n",
      "print some_list[-2:]\n",
      "some_list.append(2)\n",
      "print some_list\n",
      "del some_list[0]\n",
      "print some_list\n",
      "\n",
      "print 3 in some_list\n",
      "print 2 in some_list\n",
      "\n",
      "print len(some_list)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Name', (1+1j)]\n",
        "[1, 2, 'Name', (1+1j), 2]\n",
        "[2, 'Name', (1+1j), 2]\n",
        "False\n",
        "True\n",
        "4\n"
       ]
      }
     ],
     "prompt_number": 47
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 5: Dictionaries\n",
      "\n",
      "Dictionaries are collections of objects where each object is identified by a key. In other languages they are known as associative arrays, maps, or symbol tables. Due to Python's nature any immutable object is a valid key. Effiecient use of Python requires an understanding of the usage of dictionaries.\n",
      "\n",
      "```python\n",
      "some_dict = {\"number\": 1, \"word\": \"hello\"}\n",
      "print some_dict[\"number\"]\n",
      "some_dict[\"complex number\"] = 1 + 2j\n",
      "```\n",
      "\n",
      "1. Define a dictionary that contains your name and your age (with meaningful keys).\n",
      "2. Add your family name to the dictionary.\n",
      "3. Print the dictionary.\n",
      "4. Print the dictionary's keys.\n",
      "5. Print the dictionary's values.\n",
      "6. Delete your first name from the dictionary.\n",
      "\n",
      "Documentation: [Dictionaries](http://docs.python.org/2/library/stdtypes.html#mapping-types-dict)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_dict = {\"name\": \"Lion\", \"age\": 27}\n",
      "some_dict[\"family_name\"] = \"Krischer\"\n",
      "print some_dict\n",
      "\n",
      "print some_dict.keys()\n",
      "print some_dict.values()\n",
      "print some_dict.items()\n",
      "\n",
      "del some_dict[\"name\"]\n",
      "print some_dict"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'family_name': 'Krischer', 'age': 27, 'name': 'Lion'}\n",
        "['family_name', 'age', 'name']\n",
        "['Krischer', 27, 'Lion']\n",
        "[('family_name', 'Krischer'), ('age', 27), ('name', 'Lion')]\n",
        "{'family_name': 'Krischer', 'age': 27}\n"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 6: Conditionals\n",
      "\n",
      "In contrast to many other languages: **Whitespace matters** in Python! What this means is that blocks in the program are identified by having the same indentation. This is easiest illustrated with the help of an example.\n",
      "\n",
      "```python\n",
      "a = True\n",
      "\n",
      "# This is a comment!\n",
      "if a == True:\n",
      "    print \"a is true!\"\n",
      "else:\n",
      "    print \"a is not true!\"\n",
      "    do_something_else()\n",
      "```\n",
      "\n",
      "\n",
      "1. Define an arbitrary list named `new_list`.\n",
      "2. Write an *if-statement* that checks the following conditions and prints a meaningful message for each:\n",
      "    - `new_list` is emtpy\n",
      "    - `new_list` contains only a single item\n",
      "    - `new_list` contains more than one element\n",
      "    - **[advanced]** `new_list` is not a list\n",
      "    - **[expert]** `new_list` is not a list but another iterable object (must work for strings, dicts, ... - bonus points if no try/except is used)\n",
      "\n",
      "Documentation: [if-statement](http://docs.python.org/2/tutorial/controlflow.html#if-statements)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import collections\n",
      "\n",
      "some_list = [1, 2, 3]\n",
      "\n",
      "if not isinstance(new_list, collections.Iterable):\n",
      "    print \"Not an iterable\"\n",
      "elif not isinstance(new_list, list):\n",
      "    print \"An iterable but not a list\"\n",
      "elif not len(new_list):\n",
      "    print \"List is empty\"\n",
      "elif len(new_list) == 1:\n",
      "    print \"List contains one element\"\n",
      "else:\n",
      "    print \"List contains more than one element\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Not an iterable\n"
       ]
      }
     ],
     "prompt_number": 59
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 7: *while* Loops\n",
      "\n",
      "While loops will keep going as long as their condition is True. One has to be careful to avoid infinite loops. This type of loop is **rarely necessary** in Python and should be avoided when possible. We include it for the sake of completeness and because it does have valid uses. A common use is to use `while True` and then `break` once some condition has been met.\n",
      "\n",
      "```python\n",
      "\n",
      "i = 0\n",
      "while i < 10:\n",
      "    print \"I will eventually stop\"\n",
      "    i += 1\n",
      "    \n",
      "while True:\n",
      "    a = 1\n",
      "    if a == 1:\n",
      "        break\n",
      "   \n",
      "while True:\n",
      "    print \"I will never stop!\"\n",
      "```\n",
      "\n",
      "\n",
      "In this exercise we are going to simulate a dice and roll it as often as it takes to get a 6. The first step is import a function from the random module. This is explained in more detail later on.\n",
      "\n",
      "```python\n",
      "from random import randint\n",
      "\n",
      "# The randint(a, b) function returns any integer\n",
      "# in the range [a, b]\n",
      "dice_throw = randint(1, 6)\n",
      "print dice_throw\n",
      "```\n",
      "\n",
      "1. Write a short program that throws the dice until a 6 has been thrown and count how many tries it took.\n",
      "2. **[advanced]** Throw until two successive (not parallel!) throws yield 6. Count the amount of throws it took.\n",
      "3. **[expert]** Count the amount of tries it takes when two dice are thrown in parallel to throw each possible combination [(1, 1), (1, 2), ..] at least once.\n",
      "4. **[expert]** Throw until *N* successive (not parallel!) throws yield 6. Count the amount of throws it took.\n",
      "\n",
      "**There is a STOP button in the toolbar in case you accidentially created an infinite loop!**\n",
      "\n",
      "\n",
      "Documentation: [while-statement](http://docs.python.org/2/tutorial/introduction.html#first-steps-towards-programming)\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from random import randint\n",
      "\n",
      "tries = 0\n",
      "while True:\n",
      "    tries += 1\n",
      "    dice_throw = randint(1, 6)\n",
      "    if dice_throw == 6:\n",
      "        break\n",
      "print \"It took %i tries\" % tries\n",
      "\n",
      "\n",
      "combinations = set()\n",
      "tries = 0\n",
      "while True:\n",
      "    tries += 1\n",
      "    combinations.add((randint(1, 6), randint(1, 6)))\n",
      "    if len(combinations) >= 36:\n",
      "        break\n",
      "print \"It took %i tries\" % tries\n",
      "\n",
      "import collections\n",
      "\n",
      "N = 4\n",
      "tries = 0\n",
      "last_throws = collections.deque([0] * N, maxlen=N)\n",
      "while True:\n",
      "    tries += 1\n",
      "    last_throws.append(randint(1, 6))\n",
      "    if set(last_throws) == {6}:\n",
      "        break\n",
      "print \"It took %i tries\" % tries"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "It took 13 tries\n",
        "It took 94 tries\n",
        "It took 2553 tries\n"
       ]
      }
     ],
     "prompt_number": 72
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 8: *for* Loops\n",
      "\n",
      "*for* loops are the preferred loops in the Python language. They work as one might expect by looping over elements in some collection.\n",
      "\n",
      "```python\n",
      "for i in [1, 2, 3]:\n",
      "    print i\n",
      "```\n",
      "\n",
      "### Exercise 8.1:\n",
      "1. Define a list that contains elements with different data types.\n",
      "2. Write a for loop over the list and print each element and its type.\n",
      "3. Write another for loop that prints each element and its index. (enumerate())\n",
      "4. **[advanced]** Write a for loop to derive all prime numbers up to 100.\n",
      "\n",
      "Documentation: [for-statement](http://docs.python.org/2/tutorial/controlflow.html#for-statements)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_list = [1, 2.0, 1 + 2j, \"a\"]\n",
      "\n",
      "for i in some_list:\n",
      "    print i, type(i)\n",
      "    \n",
      "for i, item in enumerate(some_list):\n",
      "    print i, item\n",
      "    \n",
      "    \n",
      "primes = []\n",
      "for i in range(2, 101):\n",
      "    for j in primes:\n",
      "        if not i % j:\n",
      "            break\n",
      "    else:\n",
      "        primes.append(i)\n",
      "        \n",
      "print [1] + primes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 <type 'int'>\n",
        "2.0 <type 'float'>\n",
        "(1+2j) <type 'complex'>\n",
        "a <type 'str'>\n",
        "0 1\n",
        "1 2.0\n",
        "2 (1+2j)\n",
        "3 a\n",
        "[1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
       ]
      }
     ],
     "prompt_number": 77
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercise 8.2:\n",
      "Write a for loop and find all the odd numbers less that 30 except 27. At the end, you should have:\n",
      "1 3 5 7 9 11 13 15 17 19 21 23 25 29\n",
      "\n",
      "Documentation: [range](http://docs.python.org/2/tutorial/controlflow.html#the-range-function) and [continue-break](http://docs.python.org/2/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(1, 30, 2):\n",
      "    if i == 27:\n",
      "        continue\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 3 5 7 9 11 13 15 17 19 21 23 25 29\n"
       ]
      }
     ],
     "prompt_number": 80
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 9: File-handling\n",
      "\n",
      "At one point it will be necessary to read from and write to files.\n",
      "\n",
      "```python\n",
      "# 'rt' means open in read mode with text input.\n",
      "fh = open(\"filename\", \"rt\")\n",
      "\n",
      "# Read the next 10 bytes.\n",
      "contents = fh.read(10)\n",
      "\n",
      "# Read the whole remaining file at once.\n",
      "contents = fh.read()\n",
      "\n",
      "# Remember to close the file again.\n",
      "fh.close()\n",
      "```\n",
      "\n",
      "Alternatively one can use the `with` statement to create a context. The file will be closed as soon as the code leaves the context. This example also demonstrates how to loop over the lines contained in a text file.\n",
      "\n",
      "```python\n",
      "with open(\"filename\", \"rt\") as fh:\n",
      "    for line in fh:\n",
      "        print line\n",
      "```\n",
      "\n",
      "For this example we will use a textual representation of all IRIS events since the beginning of 2013 which is stored in the file\n",
      "\n",
      "**/home/mess/Desktop/data/00_python/iris_all_events_since_2013_01_01.txt**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!head -n 5 /home/mess/Desktop/data/00_python/iris_all_events_since_2013_01_01.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "#EventID|Time|Latitude|Longitude|Depth/km|Author|Catalog|Contributor|ContributorID|MagType|Magnitude|MagAuthor|EventLocationName\r\n",
        "4374593|2014-02-22T19:30:34|36.8131|3.6603|13.6|NEIC|NEIC PDE|NEIC ALERT|c000mwn1|M|4.6|NEIC|NORTHERN ALGERIA\r\n",
        "4374591|2014-02-22T18:11:47|47.781|152.4335|118.4|NEIC|NEIC PDE|NEIC ALERT|c000mwk3|M|4.3|NEIC|KURIL ISLANDS\r\n",
        "4374587|2014-02-22T17:29:53|1.2378|97.3032|39.7|NEIC|NEIC PDE|NEIC ALERT|c000mwin|M|5.4|NEIC|NORTHERN SUMATERA, INDONESIA\r\n",
        "4374589|2014-02-22T17:29:08|27.988|56.8033|11.4|NEIC|NEIC PDE|NEIC ALERT|c000mwiq|M|4.3|NEIC|SOUTHERN IRAN\r\n"
       ]
      }
     ],
     "prompt_number": 81
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1. Read the file line-by-line and print all events whose magnitude is bigger then *7.5*.\n",
      "2. Create a new file and write all events happening in 2014 in it.\n",
      "\n",
      "Documentation: [reading/writing files](http://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "with open(\"/home/mess/Desktop/data/00_python/iris_all_events_since_2013_01_01.txt\", \"rt\") as fh:\n",
      "    fh.readline()\n",
      "    for line in fh:\n",
      "        split_line = line.split(\"|\")\n",
      "        mag = float(split_line[10])\n",
      "        if mag >= 7.5:\n",
      "            print line\n",
      "            \n",
      "\n",
      "fh_1 = open(\"/home/mess/Desktop/data/00_python/iris_all_events_since_2013_01_01.txt\", \"rt\")\n",
      "fh_2 = open(\"/home/mess/Desktop/blub.txt\", \"wt\")\n",
      "            \n",
      "fh_1.readline()\n",
      "for line in fh_1:\n",
      "    split_line = line.split(\"|\")\n",
      "    event_time = split_line[1]\n",
      "    if event_time.startswith(\"2014\"):\n",
      "        fh_2.write(line)\n",
      "\n",
      "fh_1.close()\n",
      "fh_2.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "4368729|2013-11-17T09:04:55|-60.2959|-46.362|10.0|NEIC|NEIC PDE|NEIC ALERT|b000l0gq|MI|7.8|NEIC|SCOTIA SEA\n",
        "\n",
        "4309987|2013-09-24T11:29:47|26.971|65.52|15.0|NEIC|NEIC PDE|NEIC PDE-Q||MW|7.7|WCMT|PAKISTAN\n",
        "\n",
        "4218658|2013-05-24T05:44:48|54.892|153.221|598.1|NEIC|NEIC PDE|NEIC PDE-M||MW|8.4|UCMT|SEA OF OKHOTSK\n",
        "\n",
        "4215452|2013-04-16T10:44:20|28.033|61.996|80.0|NEIC|NEIC PDE|NEIC PDE-M||MW|7.7|WCMT|SOUTHERN IRAN\n",
        "\n",
        "4099810|2013-02-06T01:12:25|-10.799|165.114|24.0|NEIC|NEIC PDE|NEIC PDE-M||MW|7.9|UCMT|SANTA CRUZ ISLANDS\n",
        "\n",
        "3800250|2013-01-05T08:58:19|55.393|-134.652|10.0|NEIC|NEIC PDE|NEIC PDE-M||MW|7.5|UCMT|SOUTHEASTERN ALASKA\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 86
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!wc -l /home/mess/Desktop/blub.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2210 /home/mess/Desktop/blub.txt\r\n"
       ]
      }
     ],
     "prompt_number": 88
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 10: Creating New Functions\n",
      "\n",
      "Functions are essential to create reusable pieces of code.\n",
      "\n",
      "```python\n",
      "def some_function(a, b=10):\n",
      "    print a, b\n",
      "    \n",
      "# Will print \"1 10\"\n",
      "some_function(1)\n",
      "\n",
      "# Will print \"1 2\"\n",
      "some_function(1, 2)\n",
      "```\n",
      "\n",
      "### Exercise 10.1:\n",
      "1. Write a function *greeter* that:\n",
      "    * has *name* and *family* as arguments.\n",
      "    * returns \"Hello *name* *family*\".\n",
      "\n",
      "2. Test your function with your name and family name.\n",
      "3. Assign a default value to one of the arguments.\n",
      "4. Test your function.\n",
      "\n",
      "Documentation: [functions](http://docs.python.org/2/tutorial/controlflow.html#defining-functions)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def greeter(name, family=\"Mueller\"):\n",
      "    print name + \" \" + family\n",
      "    \n",
      "greeter(\"Hans\", \"Dampf\")\n",
      "greeter(\"Hans\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hans Dampf\n",
        "Hans Mueller\n"
       ]
      }
     ],
     "prompt_number": 93
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercise 10.2:\n",
      "1. Write a function that takes an integer and decides whether it is even or odd.\n",
      "2. Include some logic if a non-integer argument is passed to the function.\n",
      "2. Test your program with different numbers and print the results."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def even_or_odd(i):\n",
      "    if not isinstance(i, int):\n",
      "        print \"Not an integer\"\n",
      "        return\n",
      "    if i % 2:\n",
      "        print \"odd\"\n",
      "    else:\n",
      "        print \"even\"\n",
      "\n",
      "even_or_odd(1)\n",
      "even_or_odd(2)\n",
      "even_or_odd(3)\n",
      "\n",
      "even_or_odd(123.23)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "odd\n",
        "even\n",
        "odd\n",
        "Not an integer\n"
       ]
      }
     ],
     "prompt_number": 97
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercises 10.3\n",
      "\n",
      "* **[advanced]** Write a resursive function returning the first n Fibonacci numbers.\n",
      "* **[expert]** The version above breaks down for large `n` due to Python's recursion limit. Write a version utilizing a generator that does not have this behaviour."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 11: NumPy\n",
      "\n",
      "*NumPy* is a module that extends Python with powerful array objects. To use it one has to first import it.\n",
      "\n",
      "```python\n",
      ">>> import numpy as np\n",
      "```\n",
      "\n",
      "A numpy array has a dtype and a shape.\n",
      "\n",
      "```python\n",
      ">>> a = np.linspace(1, 5, 5)\n",
      ">>> print a\n",
      "[ 1.  2.  3.  4.  5.]\n",
      ">>> print a.dtype\n",
      "float64\n",
      ">>> print a.shape\n",
      "(5,)\n",
      "```\n",
      "\n",
      "Most operations are applied in-place.\n",
      "\n",
      "```python\n",
      ">>> b = np.ones(5)\n",
      ">>> print b\n",
      "[ 1.  1.  1.  1.  1.]\n",
      ">>> print 2 * b\n",
      "[ 2.  2.  2.  2.  2.]\n",
      ">>> print a + b\n",
      "[ 2.  3.  4.  5.  6.]\n",
      ">>> print np.sin(a + 3 * b)\n",
      "[ -0.7568025  -0.95892427 -0.2794155   0.6569866   0.98935825]\n",
      "```\n",
      "\n",
      "There are lots of different ways to create an array.\n",
      "\n",
      "```python\n",
      ">>> np.linspace(0, 5, 6)\n",
      "[ 0.  1.  2.  3.  4.  5.]\n",
      ">>> np.arange(5)\n",
      "[0 1 2 3 4]\n",
      ">>> np.ones(3)\n",
      "[ 1.  1.  1.]\n",
      ">>> np.array([4, 5, 6])\n",
      "[4 5 6]\n",
      "```\n",
      "\n",
      "### Exercises\n",
      "\n",
      "Everything here just serves to get you up to speed. You will get more hand on times with numpy arrays in the ObsPy practicals!\n",
      "\n",
      "\n",
      "1. Create an array with values ranging from 25 to 45.\n",
      "2. Print the first 10 items of this array.\n",
      "3. **[advanced]**: Print every second element of this array.\n",
      "2. Create an array with 50 random entries and find the index of the smallest entry. ([numpy.random](http://docs.scipy.org/doc/numpy/reference/routines.random.html))\n",
      "3. Set the smallest value in this array to 100.\n",
      "4. Create an array with 100.000 random elements and find the mean and standard deviation."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy.random\n",
      "\n",
      "a = np.arange(25, 46, 1)\n",
      "print a[:10]\n",
      "print a[::2]\n",
      "print a[11:1:-1]\n",
      "\n",
      "b = numpy.random.rand(50)\n",
      "b[b.argmin()] = 100\n",
      "\n",
      "c = numpy.random.rand(10000000)\n",
      "print c.mean()\n",
      "print c.std()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[25 26 27 28 29 30 31 32 33 34]\n",
        "[25 27 29 31 33 35 37 39 41 43 45]\n",
        "[36 35 34 33 32 31 30 29 28 27]\n",
        "0.500059795855"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "0.288678843449"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 117
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "***\n",
      "***\n",
      "***\n",
      "***\n",
      "# NOW THE OBSPY PART!\n",
      "![ObsPy](https://raw.github.com/obspy/website/master/logo/obspy_logo_full_524x179px.png)\n",
      "***\n",
      "***\n",
      "***\n",
      "***"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 12: Basemap\n",
      "\n",
      "Basemap is an extension of matplotlib for plotting maps."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Write a function *mymap* that:\n",
      "\n",
      "* Arguments: latitude and longitude\n",
      "* Plots a red circle on that location.\n",
      "* Use the *moll* projection, it just requires *lon\\_0* (central longitude of projection) as an additional argument.\n",
      "\n",
      "Documentation: [Mollweide](http://matplotlib.org/basemap/users/moll.html)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Read the textual event file from Exercise 9 once again and create a plot with all events as dots on a map.\n",
      "* **[advanced]** Color code the depth.\n",
      "* **[expert]** Use a colormap to colorcode the depth."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Advanced Plotting Exercise.\n",
      "\n",
      "The file \n",
      "\n",
      "**/home/mess/Desktop/data/00_python/example_event.xml**\n",
      "\n",
      "contains a single event with a moment tensor defintion.\n",
      "\n",
      "* Plot the beachball on a map. (Remember the previously mentioned ObsPy Gallery?)\n",
      "\n",
      "The file\n",
      "\n",
      "**/home/mess/Desktop/data/00_python/stations.xml**\n",
      "\n",
      "contains a StationXML file at the station level containing coordinates for each station that recorded the event.\n",
      "\n",
      "* Plot all stations as triangles.\n",
      "* Draw some (or all) raypaths from the event to the stations."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise 13: Pandas\n",
      "\n",
      "[Pandas](http://pandas.pydata.org/) is an extremely powerful data analysis toolbox built on top of NumPy. One thing it offers are so called data frames which can be though of as numpy backed Excel tables with lots of attached functionality.\n",
      "\n",
      "This exercise only gives a small taste of the power of pandas. There are a lot of examples online if you care to learn more, e.g [this one](https://bitbucket.org/hrojas/learn-pandas) is pretty good.\n",
      "\n",
      "It has I/O support for many commonly used data formats. The following sample reads an event CSV file similar to the one before but with one additional year of data."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from pandas.io.parsers import read_csv\n",
      "import obspy\n",
      "\n",
      "events = read_csv(\"/home/mess/Desktop/data/00_python/iris_all_events_since_2012_01_01.txt\",\n",
      "                  sep=\"|\")\n",
      "\n",
      "# Convert times to UTCDateTime objects.\n",
      "events[\"Time\"] = events[\"Time\"].apply(obspy.UTCDateTime)\n",
      "\n",
      "events[:5]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercises\n",
      "\n",
      "* How many events are in the data frame?\n",
      "* How many events larger then 6 are in the data frame?\n",
      "* How many events with a magnitude smaller then 3 a depth of less then 1 km are in the data frame?\n",
      "* How many events happened between last christmas and last new years."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Plot histograms for the magnitude and the depth.\n",
      "\n",
      "```python\n",
      "data_series.hist()\n",
      "data_series.hist(bins=10)\n",
      "data_series.plot(kind=\"kde\")\n",
      "```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To discover relations between columns use `matplotlib.pyplot.scatter()` to plot values against each other. You can also use the values to recreate the map plot above with more data (basemap does not like pandas data series objects - convert to lists first!)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Instead of plotting each histogram and scatter plot seperately, pandas also has a very convenient scatter matrix plot method.\n",
      "\n",
      "\n",
      "```python\n",
      "from pandas.tools.plotting import scatter_matrix\n",
      "\n",
      "scatter_matrix(events[[\"Latitude\", \"Longitude\", \"Depth\", \"Magnitude\"]],\n",
      "               alpha=0.01, figsize=(12, 12), diagonal='kde')\n",
      "\n",
      "plt.show()\n",
      "```\n",
      "\n",
      "Try executing/modifying it. What can we learn about the given event catalog?\n",
      "\n",
      "**This might take a while!**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type solution here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}