lab_00_part_I_python_crash_course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A  Python Crash Course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Variables and Basic Built-In  Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python include a number of simple and more complex built-in data types\n",
    "such as\n",
    "* various numeric types\n",
    "    * integers (`int`)\n",
    "    * floats (`float`)\n",
    "    * even complex numbers (`complex`)\n",
    "* strings (`str`), a text sequence type\n",
    "* various sequence types\n",
    "    * `list`\n",
    "    * `tuple` \n",
    "    * `range`\n",
    "* dictionaries (`dict`), a mapping type\n",
    "* and many more, see the [Built-in Types section](https://docs.python.org/3/library/stdtypes.html) from\n",
    "the [Python Library Reference](https://docs.python.org/3/library/index.html)\n",
    "\n",
    "Python is a (strong) dynamically typed language. The type\n",
    "is *not* associated with a specific variable name (as in `C/C++/Java`) but rather with the value of this variable. You can check the type of a given variable name using the inbuilt `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 10 # Integer type\n",
    "print(type(a))\n",
    "f = 3.1415 # float type\n",
    "print(type(f))\n",
    "s1 = 'a string' # string type\n",
    "print(type(s1))\n",
    "s2 = \"a string\" # can be written also with double quotes\n",
    "print(type(s2))\n",
    "s3 = '''This is a very long string which stretches\n",
    "over several lines ''' # Use Triple single (or double) quotes\n",
    "print(type(s3))\n",
    "a = \"I am a string now\"\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even complex numbers are built in using `j` and **not** `i` for the imaginary part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = 2 + 3j\n",
    "print(c)\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python as a Calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the interactive mode of the Python interpreter or a Jupyter (Python) notebook as a simple calculator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "10 + 1j # Test what happens if you write j instead of 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "10/2.0*3-7 # Divison and multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "11 % 3 # Modulo operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2**4 # Computing powers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "2**0.5 # and roots :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced built-in data types and Variables\n",
    "\n",
    "See [https://docs.python.org/3/tutorial/datastructures.html](https://docs.python.org/3/tutorial/datastructures.html)\n",
    "for more ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "`List` is a (mutable) sequence type. While you can store heterogenous\n",
    "data in a list, it is most often used to store _homogeneous_ data\n",
    "(all items have the same data type)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "int_list_1 = [1,3,5,7]\n",
    "print(int_list_1)\n",
    "\n",
    "word_list_1 = ['Alice:', 'Python', 'is', 'my', 'favorite', 'programming', 'Language!']\n",
    "print(word_list_1)\n",
    "\n",
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print(list_of_lists)\n",
    "\n",
    "# You can even list things of different types\n",
    "blob_list = [\"hello\", 1, 2+3j, [1,2,3]]\n",
    "print(blob_list)\n",
    "# But usually list consist a sequence of variables of the same data\n",
    "# to be useful in common "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be concatenated using the `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "int_list_2 = [0, 2, 4, 6, 8]\n",
    "int_list_3 = int_list_1 + int_list_2\n",
    "print(int_list_3)\n",
    "\n",
    "word_list_2 = [\"Bob:\", \"Surely\", \"not\", \"mine!\"]\n",
    "word_list_3 = word_list_1 + word_list_2\n",
    "print(word_list_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you guess what the result of the following operation does?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = int_list_1*3\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List items can be accessed/indexed and sliced via the `[]` operator.\n",
    "**Note that opposed to Matlab, the start index is** 0 ** not **1** !**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[0] # Get the first item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[-1] # Get the last item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[:4] # Get a slice from index 0 to 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[-3:] # Get a slice from third last item to the last item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[2:6] # You can probably guess now what this means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[1:6:4] #But what does this mean? Run the code and guess!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[1::4] #An what does this mean? Run the code and guess!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Miniexercise**: Try these list operations on strings!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples (`tuple`) are, roughly speaking, a kind of frozen list,\n",
    "a list which cannot be changed, since tuples are _immutable_. \n",
    "They are often used to bundle _hetergenous_ data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (\"Hello\", 2, [1,2,3])\n",
    "print(t)\n",
    "t[0] = \"HELLO\"\n",
    "t[1] += 2\n",
    "t[2].append(4)\n",
    "print(t)\n",
    "t[2][0] = 10\n",
    "print(t)\n",
    "# t[2] = t[2] + [5,6,7]\n",
    "\n",
    "# Special syntax to construct tuple with only a single item\n",
    "short_tuple = (2,)\n",
    "print(short_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can be used to perform multiple assignments in one line.\n",
    "Later we will see that they can also be used to return multiple\n",
    "values/objects from within a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(a,b) = (2,3)\n",
    "print(a)\n",
    "print(b)\n",
    "# Short-hand notation is the following, which demonstrates\n",
    "# Pythons \"unpacking\" feature.\n",
    "a,b = 10, 20\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "# For later\n",
    "def func():\n",
    "    return 1,2\n",
    "\n",
    "f = func()\n",
    "print(f)\n",
    "f1, f2 = func()\n",
    "print(f1)\n",
    "print(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries a (non-sequential) containers, where the data is *not* indexed by its position but rather by a given key. We won't say much about dicts, only how to create and access them, and iterate over them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {\"Bill Gates\" : 90*10e9, \"Warren Buffett\": 74.310e9}\n",
    "print(d)\n",
    "\n",
    "salary = d[\"Bill Gates\"]\n",
    "print(salary)\n",
    "\n",
    "# Iterate over keys and their dict values\n",
    "for key, value in d.items():\n",
    "    print((key, value))\n",
    "\n",
    "# Iterate over keys\n",
    "for key in d:\n",
    "    print(key + \" earned \")\n",
    "    print(d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You can read upon available built-in data types in the offical [Python tutorial](https://docs.python.org/3/tutorial/index.html), in particular in\n",
    "\n",
    "* [Section 3: An Informal Introduction to Python](https://docs.python.org/3/tutorial/introduction.html)\n",
    "* [Section 5: Data Structures](https://docs.python.org/3/tutorial/datastructures.html)\n",
    "\n",
    "For a detailed overview, have a look at the [Python Library Reference](https://docs.python.org/3/library/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Variable assignment works differently compared to `C/C++/Java`!\n",
    "In a nut shell, most of the time, everything works like using \n",
    "References (to use `C++` jargon), but it is best explained with a few\n",
    "examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2 # Creates an integer object in memory and assign the name 'a' to it.\n",
    "print(a)\n",
    "\n",
    "b = a # Assign name b to the same data in memory\n",
    "print(b)\n",
    "# You can check this by checking the id of a and b\n",
    "# id  corresponds to memory address \n",
    "print(\"The id of a is %d\" % id(a))\n",
    "print(\"The id of b is %d\" % id(b))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a new integer object in memory and use the name a for it\n",
    "a = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `a` has new id since it is the variable name for a _new_ object.\n",
    "This is *not* as in C/C++ where the value 3 is assigned to the variable\n",
    "a which would still occupy the same memory/had the same memory address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"The id of a is %d\" % id(a))\n",
    "print(\"The id of b is %d\" % id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Side note:** If we now use b also as a name for a newly create object,\n",
    "the integer object 2 stored in the original location is not\n",
    "accessible from within the program any more. The built-in Python garbage\n",
    "collector will then automatically reclaim its memory at some (unknow)\n",
    "point in time. So opposed to `C/C++`, you (usually) don't have to worry about memory management."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now repeat a similar experiment with lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l1 = [1,2,3] # Create a list in memory and assign the name l1 to it\n",
    "print(l1)\n",
    "print(\"The id of l1 is %d\" % id(l1))\n",
    "\n",
    "l2 = l1  # Again, assign name l2 to the same name!\n",
    "print(l2)\n",
    "print(\"The id of l2 is %d\" % id(l2))\n",
    "\n",
    "# Changing l1\n",
    "l1[1] = 20\n",
    "l1.append(4)\n",
    "print(l1)\n",
    "print(\"The id of l1 is %d\" % id(l1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you guess what happens with `l2`? Is it changed or unchanged?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can make a (shallow) copy of l2 using the colon `[:]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l2 = l1[:]\n",
    "print(l2)\n",
    "print(\"The id of l2 is %d\" % id(l2))\n",
    "\n",
    "#Changing l1  again\n",
    "l1.insert(0, -10)\n",
    "print(l1)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control flow structures and white space in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word = \"Hello\"\n",
    "if len(word) > 4:\n",
    "    print(word[0:4])\n",
    "    print(\"Word contains more than 4 letters\")\n",
    "elif len(word) == 4:\n",
    "    print(word)\n",
    "    print(\"Word contains exactly 4 letters\")\n",
    "else:\n",
    "    print(word)\n",
    "    print(\"Word contains less than 4 letters\")\n",
    "print(\"This string does not belong to the else code block\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the code statements/block belonging to each `if/else/elif` branch are **indented**! This shows a peculiar feature of Python, which has been and will be the reason for a millions technical and not so technical bike-shed discussions. The main reason is that Python wants\n",
    "to *force* you to write cleaner code with less syntactical sugar.  \n",
    "Let's just accept it and move on :)\n",
    "\n",
    "The amount of indentation is up to you (4 spaces per indent level are usually recommended) but it has to be consistent within each code block.\n",
    "\n",
    "The basic rule of thumb is that whenever there is a Python code statement\n",
    "with ends with a `:` the code block belonging to that statement needs to be indented! This applies in particular to\n",
    "* `if/elif/else` \n",
    "* `for` and `while` loops\n",
    "*  definitions of functions (later) and classes (not treated here)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### True values and boolean operations\n",
    "\n",
    "Not surprisingly, there is a boolean type you can assign either `True` or `False` (mind the capitalization!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "alice_loves_python = True\n",
    "bob_loves_python = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform the usual boolean operations on boolean (or for that matter any other Python) object, that is a logical `and`, `or`, `not`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if alice_loves_python and bob_loves_python : # Highly likely\n",
    "    print(\"Alice and Bob love Python programming\") \n",
    "elif alice_loves_python and not bob_loves_python: # Very unlikely\n",
    "    print(\"Alice loves Python programming, but Bob does not :(\")\n",
    "elif bob_loves_python and not alice_loves_python: # Very unlikely\n",
    "    print(\"Bob loves Python programming, but Alice does not :(\")\n",
    "else: # Impossible!\n",
    "    print(\"Neither Alice nor Bob do love Python progamming :'(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Miniexercise:** Test the following constructs for the truth value.\n",
    "What did you expect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Lists\n",
    "l1 = []\n",
    "l2 = [1,2]\n",
    "\n",
    "# Tuples\n",
    "t1 = () # empty tuple\n",
    "t2 = (1,) # tuple with one element\n",
    "\n",
    "# Strings\n",
    "s1 = \"\" # Empty string\n",
    "s2 = \" \" # String containing only a space\n",
    "s3 = \"a\" # Non-empyt string\n",
    "\n",
    "# Dicts\n",
    "d1 = {} # Empyt dict\n",
    "d2 = {\"A\": [1,2]} \n",
    "d3 = {(): \"\"} # Non-empty dict which maps an empty tuple to an empty string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### For loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Iterate of integers from 0 to 4\n",
    "for i in range(5):\n",
    "    print(\"The square of %i  is %i\" % (i, i**2))\n",
    "    \n",
    "# Iterate of integers from 3 to 7\n",
    "for i in range(3,8):\n",
    "    print(\"The square of %i  is %i\" % (i, i**2))\n",
    "\n",
    "# Iterate of integers from 1 to (at most) 99 with a step of 10    \n",
    "for i in range(1, 100, 10):\n",
    "    print(\"The square of %i  is %i\" % (i, i**2))\n",
    "\n",
    "# Looping over words\n",
    "words = [\"hello\", \"python\", \"world\"]\n",
    "for word in words:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "N = 0\n",
    "N_max = 101\n",
    "total_sum = 0 \n",
    "max_total_sum = 1000\n",
    "\n",
    "# What does this while loop compute?\n",
    "\n",
    "while N < N_max:\n",
    "    N += 1\n",
    "    if N % 3 == 0 or N % 5 == 0 or N % 7 == 0:\n",
    "        total_sum += N\n",
    "    else:\n",
    "        print(\"Current number %d not divisible by either 3, 5 or 7!\" % N)\n",
    "        continue\n",
    "    if total_sum > max_total_sum:\n",
    "        print(\"Max total sum is exceeded!\")\n",
    "        break;\n",
    "        \n",
    "print(\"Final sum = %d\" % total_sum)\n",
    "print(\"Final N = %d\" % N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules and the Python standard library\n",
    "\n",
    "Modules allows to encapsulate and structure Python code by storing\n",
    "it into separate Python files (ending with `.py`). Classes, objects,\n",
    "functions, variables etc defined in a module can be made available\n",
    "in your Python code by `importing` it.\n",
    "\n",
    "Python includes a extensive Standard Library consisting of many, many modules, see [Python Standard Library](https://docs.python.org/3/library/index.html)\n",
    "but there exists a zillion of 3rd party modules providing functions for\n",
    "almost everything from an email server to a deep learning platform!\n",
    "And of course there are a plethora of scientific computing related modules.\n",
    "\n",
    "Here, we import the `math` library and make all (public) variables, functions, classses etc. of `math` available via the `math.member`\n",
    "notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "f1 = math.sin(math.pi/2)\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple possibility to lookup function/names available in `math` module\n",
    "is via the built-in `dir` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To lookup more detailed documentation on the `math` module you can use the `help` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "help(math) # Works only *after* importing the math module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# You can also use it on individual members as well\n",
    "help(math.ceil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can use the `?` operator (only in Jupyter or ipython, not in the standard Python interpreter)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "?math.ceil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without any argument, `dir()` gives you the variables defined in the global namespace (global with respect to this notebook). Note that the `math` modules appears in this list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also import individual module members."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from cmath import exp\n",
    "f2 = exp(math.pi/2*1j)\n",
    "print(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Miniexercise**: Check now variables in the global space via the `dir()` function. Can you find the `exp` function in it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you can also import *everything* from a module. This is usually discouraged as you pollute your global name space with a lot of variable names and thus there might be name collisions. \n",
    "\n",
    "For instance, both the `math`, `cmath` and the `numpy` module have a `log` function. If you import everything from these 3 modules, the actual `log` function you get will be dependent on the order in which the modules were imported. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from cmath import *\n",
    "f3 = sin(pi/2*1j) + cos(pi/2*1j)\n",
    "print(f3)\n",
    "print(\"f3 = \" + str(f3))\n",
    "# Look how you polluted the global name space now!!\n",
    "dir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions and local modules in Python\n",
    "\n",
    "The simplest way to define functions is via the\n",
    "```Python\n",
    "\n",
    "def my_total_awesome_function(arg1, arg2, arg3):\n",
    "    <code statement 1>\n",
    "    <code statement 2>\n",
    "    ...\n",
    "    # optional return\n",
    "    return result\n",
    "```\n",
    "\n",
    "A function can have an arbitrary number of arguments and there is\n",
    "a lot of function related feature regarding the way how\n",
    "arguments are dealed with regard to defaults arguments, keyword arguments,\n",
    "arbitrary argument lists etc. Have a look at [4.6. Defining Functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)\n",
    "in the official Python tutorial.\n",
    "\n",
    "Here is a supersimple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_words = [\"function\", \"Python\", \"first\", \"my\"]\n",
    "\n",
    "def reverse_and_capitalize(words):\n",
    "    words.reverse() # Reverse actual given list, not a copy of it!\n",
    "    words[0] = words[0].capitalize()\n",
    "    return words\n",
    "\n",
    "# Make a sentence string\n",
    "print((\" \").join(my_words))\n",
    "rev_words = reverse_and_capitalize(my_words)\n",
    "print((\" \").join(rev_words))\n",
    "\n",
    "# Note what happen to the original words\n",
    "print((\" \").join(my_words))\n",
    "# Python does only \"pass by reference\" to use C/C++ jargon  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the original `list` was also changed! This is typical for Python,\n",
    "as the objects/variables passed through the function is similiar\n",
    "to `C++` pass by reference way. This is a direct consequence of how Python\n",
    "treats variables and assignment discuseed above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Next try\n",
    "my_words = [\"function\", \"Python\", \"first\", \"my\"]\n",
    "def reverse_and_capitalize_v2(words):\n",
    "    _words = words[:] # Copy word list\n",
    "    _words.reverse()\n",
    "    _words[0] = _words[0].capitalize()\n",
    "    return _words\n",
    "\n",
    "print((\" \").join(my_words))\n",
    "rev_words = reverse_and_capitalize_v2(my_words)\n",
    "print((\" \").join(rev_words))\n",
    "\n",
    "# Note what happen to the original words\n",
    "print((\" \").join(my_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to built-in modules you can write your own modules.\n",
    "Modules use as any other Python file the `.py` file extension. \n",
    "If you store `my_module` defining your `my_fancy_function` in the same directory where the notebook, main script or other python modules are stored, you opython file you can simply use it in your Python code by simply importing\n",
    "it before use.\n",
    "\n",
    "```Python\n",
    "import my_module\n",
    "\n",
    "a = my_module.my_fancy_function()\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Minixercise**\n",
    "\n",
    "Write a function, which takes an integer argument `n` and\n",
    "computes and returns the sum of the first `n` squares. After you have successfully implemented your function, export it into a separate module and use this module function in your notebook instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stylesheet for the Jupyter notebooks\n",
    "\n",
    "If you store the stylesheet file `custom.css` from `labs/styles/` Cambro folder in the local `../styles` folder (relative to this notebook location) and execute the next code cell, you get a much nicer look of your notebook.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!--<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>-->\n",
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<!-- <link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>* -->\n",
       "<link href=\"https://fonts.googleapis.com/css?family=Source+Code+Pro\" rel=\"stylesheet\"> \n",
       "<link href=\"https://fonts.googleapis.com/css?family=News+Cycle\" rel=\"stylesheet\"> \n",
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "        font-family: 'News Cycle', sans-serif;\n",
       "    }\n",
       "\n",
       "    div.cell{\n",
       "        /*max-width:600px;*/\n",
       "        /*margin-left:16% !important;*/\n",
       "        /*margin-right:auto;*/\n",
       "    }\n",
       "    div.text_cell {\n",
       "        max-width: 105ex /* instead of 100%, */\n",
       "        }\n",
       "    h1 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "    }\n",
       "    h2 {\n",
       "        /*font-family: 'Fenix', serif;*/\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "        color: #5889C5;\n",
       "        /*color: #5889C5;*/\n",
       "    }\n",
       "    h3{\n",
       "\t\t/*font-family: 'Fenix', serif;*/\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "        color: #5889C5;\n",
       "        /*color: #5889C5;*/\n",
       "        /*margin-top:12px;*/\n",
       "        /*margin-bottom: 3px;*/\n",
       "       }\n",
       "\th4{\n",
       "\t\t/*font-family: 'Fenix', serif;*/\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "        color: #5889C5;\n",
       "       }\n",
       "    h5 {\n",
       "        font-family: 'Alegreya Sans', sans-serif;\n",
       "        color: #5889C5;\n",
       "    }\t   \n",
       "    div.text_cell_render{\n",
       "        /*font-family: News Cycle, Geneva,Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;*/\n",
       "        font-family: 'Alegreya Sans','News Cycle',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 135%;\n",
       "        font-size: 120%;\n",
       "        /*width:600px;*/\n",
       "        /*margin-left:auto;*/\n",
       "        /*margin-right:auto;*/\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: 'Source Code Pro', monospace;\n",
       "            /*font-style: italic;*/\n",
       "            /*font-weight: bold;*/\n",
       "            /*font-size: 120%;*/\n",
       "    }\n",
       "    /*.prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "    .text_cell_render h1 {\n",
       "        font-weight: 200;\n",
       "        font-size: 50pt;\n",
       "\t\tline-height: 100%;\n",
       "        color: #5889C5;\n",
       "        margin-bottom: 0.5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\t\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 16pt;\n",
       "        color: #5889C5;\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",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\",\"begingroup.js\"],\n",
       "                           Macros: {\n",
       "                               RR: \"{\\\\mathbb{R}\",\n",
       "                               mcO: \"\\\\mathcal{O}\"\n",
       "                           }\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>\n"
      ],
      "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",
    "\n",
    "# Comment out next line and execute this cell to restore the default notebook style \n",
    "css_styling()"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}