notebooks/Introduction_to_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img class=\"logo\" src=\"images/python-logo.png\" height=100 align='right'/>\n",
    "\n",
    "# Python\n",
    "\n",
    "* High-level\n",
    "* General purpose\n",
    "* Multiple programming paradigms\n",
    "* Interpreted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "var1 = 1              # interger\n",
    "var2 = 2.34           # floating point numbers\n",
    "var3 = 5.6 + 7.8j     # complex numbers \n",
    "var4 = \"Hello World\"  # strings\n",
    "var5 = True           # booleans\n",
    "var6 = None           # special value to indicate the absence of a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 value: 1 type: <class 'int'>\n",
      "var2 value: 2.34 type: <class 'float'>\n",
      "var3 value: (5.6+7.8j) type: <class 'complex'>\n",
      "var4 value: Hello World type: <class 'str'>\n",
      "var5 value: True type: <class 'bool'>\n",
      "var6 value: None type: <class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(\"var1 value:\", var1, \"type:\", type(var1))\n",
    "print(\"var2 value:\", var2, \"type:\", type(var2))\n",
    "print(\"var3 value:\", var3, \"type:\", type(var3))\n",
    "print(\"var4 value:\", var4, \"type:\", type(var4))\n",
    "print(\"var5 value:\", var5, \"type:\", type(var5))\n",
    "print(\"var6 value:\", var6, \"type:\", type(var6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Containers\n",
    "\n",
    "Data types for holding many variables\n",
    "\n",
    "## Lists\n",
    "\n",
    "One-dimensional, ordered container whose contents and length can change (mutable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rain', 'snow', 'hail']\n",
      "length: 3\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']  # create a list holding three elements\n",
    "print(hydrometeors)\n",
    "print('length:', len(hydrometeors))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements of a list do not need to be of the same type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rain', 4.5, 99, None]\n"
     ]
    }
   ],
   "source": [
    "mixed_type_list = ['rain', 4.5, 99, None]\n",
    "print(mixed_type_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elements can be added or removed from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rain', 'snow', 'hail', 'drizzle']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "hydrometeors.append('drizzle')  # add 'drizzle' to the end of the list\n",
    "print(hydrometeors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rain', 'graupel', 'snow', 'hail']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "hydrometeors.insert(1, 'graupel')  # insert graupel before position 1\n",
    "print(hydrometeors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['snow', 'hail']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "del hydrometeors[0]  # remove the first element from the list\n",
    "print(hydrometeors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observation: hail\n",
      "hydrometeors: ['rain', 'snow']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "observation = hydrometeors.pop()  # remove the last item from the list and store it in hydrometeor\n",
    "print(\"observation:\", observation)\n",
    "print(\"hydrometeors:\", hydrometeors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elements of a list can be changed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before change: ['rain', 'snow', 'hail']\n",
      "After change: ['virga', 'snow', 'hail']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "print(\"Before change:\", hydrometeors)\n",
    "hydrometeors[0] = 'virga'\n",
    "print(\"After change:\", hydrometeors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists Indexing\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0: rain\n",
      "index 1: snow\n",
      "index 2: hail\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "print('index 0:', hydrometeors[0])   # indexing begins at 0\n",
    "print('index 1:', hydrometeors[1])\n",
    "print('index 2:', hydrometeors[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-7706668d582b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhydrometeors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m  \u001b[0;31m# Trying to access elements which do not exist raises a IndexError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "hydrometeors[3]  # Trying to access elements which do not exist raises a IndexError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index -1: hail\n",
      "index -2: snow\n",
      "index -3: rain\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "print('index -1:', hydrometeors[-1])\n",
    "print('index -2:', hydrometeors[-2])\n",
    "print('index -3:', hydrometeors[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List slicing\n",
    "\n",
    "Syntax: list_variable[start:end:step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hail', 'drizzle']\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail', 'drizzle', 'graupel', 'virga']\n",
    "print(hydrometeors[2:4])  # select elements from index 2 to index 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rain', 'snow', 'hail']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hydrometeors[:3]  # start from beginning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['drizzle', 'graupel', 'virga']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hydrometeors[3:]  # until the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['drizzle', 'graupel']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hydrometeors[3:-1]  # negative indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['snow', 'drizzle', 'virga']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hydrometeors[1::2]  # every 2nd element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "One-dimensional, ordered container whose contents and length **CANNOT** change (immutable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('rain', 'snow', 'hail')\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "t = ('rain', 'snow', 'hail')\n",
    "print(t)\n",
    "print(len(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-19-d4fc2c3241e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'virga'\u001b[0m  \u001b[0;31m# tuples cannot be changed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 'virga'  # tuples cannot be changed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be 'unpacked' to assign variable.  Often used with functions which return multiple items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observations: ('rain', 'snow', 'hail')\n",
      "obs1: rain\n",
      "obs2: snow\n",
      "obs3: hail\n"
     ]
    }
   ],
   "source": [
    "observations = ('rain', 'snow', 'hail')  # tuple with three elements\n",
    "obs1, obs2, obs3 = observations    # unpack tuple into obs1, obs2, obs3 variables\n",
    "print(\"observations:\", observations)\n",
    "print(\"obs1:\", obs1)\n",
    "print(\"obs2:\", obs2)\n",
    "print(\"obs3:\", obs3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Unordered collection of key/value pairs whose size and content can change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {'site': 'KLOT', 'amount': 20, 'wind': 'east'} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['wind', 'site', 'amount'])\n"
     ]
    }
   ],
   "source": [
    "print(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['east', 'KLOT', 20])\n"
     ]
    }
   ],
   "source": [
    "print(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "site: east\n",
      "amount: 20\n",
      "wind: east\n"
     ]
    }
   ],
   "source": [
    "print('site:', d['wind'])\n",
    "print('amount:', d['amount'])\n",
    "print('wind:', d['wind'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wind before change: east\n",
      "wind after change: west\n"
     ]
    }
   ],
   "source": [
    "print(\"wind before change:\", d['wind'])\n",
    "d['wind'] = 'west'\n",
    "print(\"wind after change:\", d['wind'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entries can be added or remove from dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'wind': 'east', 'site': 'KLOT', 'amount': 20}\n"
     ]
    }
   ],
   "source": [
    "d = {'site': 'KLOT', 'amount': 20, 'wind': 'east'} \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'site': 'KLOT', 'amount': 20}\n"
     ]
    }
   ],
   "source": [
    "del d['wind']\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'wind_speed': 'east', 'wind_direction': '10 m/s', 'site': 'KLOT', 'amount': 20}\n"
     ]
    }
   ],
   "source": [
    "d['wind_speed']  = 'east'\n",
    "d['wind_direction'] = '10 m/s'\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Dictionaries do **not** preserve the order in which entries are added.  If you need ordering use a [OrderedDict](https://docs.python.org/3.5/library/collections.html#collections.OrderedDict) from the **collections** module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flow control\n",
    "\n",
    "## If statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You saw rain\n"
     ]
    }
   ],
   "source": [
    "hydrometeor = 'rain'\n",
    "if hydrometeor == 'rain':\n",
    "    print(\"You saw rain\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You did NOT see rain\n"
     ]
    }
   ],
   "source": [
    "hydrometeor = 'hail'\n",
    "if hydrometeor == 'rain':\n",
    "    print(\"You saw rain\")\n",
    "else:\n",
    "    print(\"You did NOT see rain\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You saw snow\n"
     ]
    }
   ],
   "source": [
    "hydrometeor = 'snow'\n",
    "if hydrometeor == 'rain':\n",
    "    print(\"You saw rain\")\n",
    "elif hydrometeor == 'snow':\n",
    "    print(\"You saw snow\")\n",
    "else:\n",
    "    print(\"I do not know what you saw\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for loops\n",
    "\n",
    "Syntax: <br/>\n",
    "**for** variable **in** iterable:<br/>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;code block\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rain\n",
      "snow\n",
      "hail\n"
     ]
    }
   ],
   "source": [
    "hydrometeors = ['rain', 'snow', 'hail']\n",
    "for hydrometeor in hydrometeors:  # loop over elements in a list\n",
    "    print(hydrometeor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):  # loop over the number 0 to 4\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wind : east\n",
      "site : KLOT\n",
      "amount : 20\n"
     ]
    }
   ],
   "source": [
    "d = {'site': 'KLOT', 'amount': 20, 'wind': 'east'} \n",
    "for key, value in d.items():\n",
    "    print(key, ':', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# simple\n",
    "def func(arg1):\n",
    "    print(arg1)\n",
    "    return 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "ret_value: 42\n"
     ]
    }
   ],
   "source": [
    "# call a function\n",
    "return_value = func(\"Hello World\")\n",
    "print(\"ret_value:\", return_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can have multiple, no and even default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add_numbers(number1, number2):\n",
    "    return number1 + number2\n",
    "\n",
    "def say_hello():\n",
    "    print(\"Hello AMS\")\n",
    "    \n",
    "def favorite_hydrometeor(name, hydrometeor='snow'):\n",
    "    print(\"Hello\", name)\n",
    "    print(\"Your favorite hydrometeor is\", hydrometeor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(add_numbers(1, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello AMS\n"
     ]
    }
   ],
   "source": [
    "say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jonathan\n",
      "Your favorite hydrometeor is snow\n"
     ]
    }
   ],
   "source": [
    "favorite_hydrometeor(\"Jonathan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jonathan\n",
      "Your favorite hydrometeor is hail\n"
     ]
    }
   ],
   "source": [
    "favorite_hydrometeor(\"Jonathan\", hydrometeor=\"hail\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can return multiple values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum 5\n",
      "product 6\n"
     ]
    }
   ],
   "source": [
    "def sum_and_product(a, b):\n",
    "    return a+b, a*b\n",
    "sum_ab, product_ab = sum_and_product(2, 3)\n",
    "print(\"sum\", sum_ab)\n",
    "print(\"product\", product_ab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\" A class to store the coordinate in a plane\"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x   # an attribute\n",
    "        self.y = y   # an attribute\n",
    "        \n",
    "    def sum_of_coordinates(self):  # a class method\n",
    "        return self.x + self.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "home = Point(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(home.x)\n",
    "print(home.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "home.sum_of_coordinates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries \n",
    "\n",
    "* Python has a large number of libraries which extend the basic functionality.\n",
    "* The standard library is included with Python and contains a number of helpful features.\n",
    "* Third-party libraries can add even more powerful functionality!\n",
    "* Libraries must be imported to be used.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math  # import the entire math module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import randrange   # import just the randrange function from the random module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "8\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(randrange(1, 10))"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}