Course_Tutorial_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Notebook created by Mubashshir Ali for the purpose of Climate Risk Assessment lecture*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#What-is-Python?\" data-toc-modified-id=\"What-is-Python?-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>What is Python?</a></span></li><li><span><a href=\"#Why-Python?\" data-toc-modified-id=\"Why-Python?-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Why Python?</a></span><ul class=\"toc-item\"><li><span><a href=\"#Python-in-Science\" data-toc-modified-id=\"Python-in-Science-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Python in Science</a></span></li></ul></li><li><span><a href=\"#Using-Jupyter-Notebook\" data-toc-modified-id=\"Using-Jupyter-Notebook-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Using Jupyter Notebook</a></span><ul class=\"toc-item\"><li><span><a href=\"#Use-as-Shell-Terminal\" data-toc-modified-id=\"Use-as-Shell-Terminal-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Use as Shell Terminal</a></span></li></ul></li><li><span><a href=\"#Variables\" data-toc-modified-id=\"Variables-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Variables</a></span><ul class=\"toc-item\"><li><span><a href=\"#Assigning-values-to-the-variable\" data-toc-modified-id=\"Assigning-values-to-the-variable-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Assigning values to the variable</a></span><ul class=\"toc-item\"><li><span><a href=\"#Multiple-assignments\" data-toc-modified-id=\"Multiple-assignments-4.1.1\"><span class=\"toc-item-num\">4.1.1&nbsp;&nbsp;</span>Multiple assignments</a></span></li></ul></li></ul></li><li><span><a href=\"#Standard-Data-Types\" data-toc-modified-id=\"Standard-Data-Types-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Standard Data Types</a></span><ul class=\"toc-item\"><li><span><a href=\"#Numbers\" data-toc-modified-id=\"Numbers-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Numbers</a></span></li><li><span><a href=\"#Strings\" data-toc-modified-id=\"Strings-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Strings</a></span><ul class=\"toc-item\"><li><span><a href=\"#Indexing-and-slicing\" data-toc-modified-id=\"Indexing-and-slicing-5.2.1\"><span class=\"toc-item-num\">5.2.1&nbsp;&nbsp;</span>Indexing and slicing</a></span></li></ul></li><li><span><a href=\"#Lists\" data-toc-modified-id=\"Lists-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Lists</a></span><ul class=\"toc-item\"><li><span><a href=\"#Indexing-and-Slicing\" data-toc-modified-id=\"Indexing-and-Slicing-5.3.1\"><span class=\"toc-item-num\">5.3.1&nbsp;&nbsp;</span>Indexing and Slicing</a></span></li><li><span><a href=\"#Adding-Strings\" data-toc-modified-id=\"Adding-Strings-5.3.2\"><span class=\"toc-item-num\">5.3.2&nbsp;&nbsp;</span>Adding Strings</a></span></li><li><span><a href=\"#Testing\" data-toc-modified-id=\"Testing-5.3.3\"><span class=\"toc-item-num\">5.3.3&nbsp;&nbsp;</span>Testing</a></span></li></ul></li><li><span><a href=\"#Tuples\" data-toc-modified-id=\"Tuples-5.4\"><span class=\"toc-item-num\">5.4&nbsp;&nbsp;</span>Tuples</a></span></li><li><span><a href=\"#Python-Dictionaries\" data-toc-modified-id=\"Python-Dictionaries-5.5\"><span class=\"toc-item-num\">5.5&nbsp;&nbsp;</span>Python Dictionaries</a></span><ul class=\"toc-item\"><li><span><a href=\"#Accessing-keys-and-values\" data-toc-modified-id=\"Accessing-keys-and-values-5.5.1\"><span class=\"toc-item-num\">5.5.1&nbsp;&nbsp;</span>Accessing keys and values</a></span></li></ul></li></ul></li><li><span><a href=\"#Introduction-to-Numpy\" data-toc-modified-id=\"Introduction-to-Numpy-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Introduction to Numpy</a></span><ul class=\"toc-item\"><li><span><a href=\"#Why-numpy-is-needed?\" data-toc-modified-id=\"Why-numpy-is-needed?-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Why numpy is needed?</a></span></li><li><span><a href=\"#Creating-Numpy-arrays-from-Python-lists\" data-toc-modified-id=\"Creating-Numpy-arrays-from-Python-lists-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Creating Numpy arrays from Python lists</a></span><ul class=\"toc-item\"><li><span><a href=\"#Method-1\" data-toc-modified-id=\"Method-1-6.2.1\"><span class=\"toc-item-num\">6.2.1&nbsp;&nbsp;</span>Method 1</a></span></li><li><span><a href=\"#Method-2\" data-toc-modified-id=\"Method-2-6.2.2\"><span class=\"toc-item-num\">6.2.2&nbsp;&nbsp;</span>Method 2</a></span></li><li><span><a href=\"#Method-3\" data-toc-modified-id=\"Method-3-6.2.3\"><span class=\"toc-item-num\">6.2.3&nbsp;&nbsp;</span>Method 3</a></span></li></ul></li><li><span><a href=\"#Multidimensional-arrays\" data-toc-modified-id=\"Multidimensional-arrays-6.3\"><span class=\"toc-item-num\">6.3&nbsp;&nbsp;</span>Multidimensional arrays</a></span></li></ul></li><li><span><a href=\"#Zen-of-Python-:)\" data-toc-modified-id=\"Zen-of-Python-:)-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Zen of Python :)</a></span></li><li><span><a href=\"#Supplementary-info\" data-toc-modified-id=\"Supplementary-info-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Supplementary info</a></span><ul class=\"toc-item\"><li><span><a href=\"#How-to-install-Jupyter-notebooks-on-your-PC\" data-toc-modified-id=\"How-to-install-Jupyter-notebooks-on-your-PC-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>How to install Jupyter notebooks on your PC</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.690681Z",
     "start_time": "2019-03-25T16:30:59.688184Z"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "import IPython.display\n",
    "from IPython.core.display import HTML "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.704998Z",
     "start_time": "2019-03-25T16:30:59.698118Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"1000\"\n",
       "            height=\"780\"\n",
       "            src=\"https://en.wikipedia.org/wiki/Python_(programming_language)\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f34740b3278>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IPython.display.IFrame(\"https://en.wikipedia.org/wiki/Python_(programming_language)\", width=1000, height=780)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.710320Z",
     "start_time": "2019-03-25T16:30:59.707908Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://cdn-images-1.medium.com/max/1600/1*JMP0SgtuTAO1A2Mj04qtfw.png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url= \"https://cdn-images-1.medium.com/max/1600/1*JMP0SgtuTAO1A2Mj04qtfw.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Source: Stack Overflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.715413Z",
     "start_time": "2019-03-25T16:30:59.712948Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://cdn-images-1.medium.com/max/800/1*hr4AQ8riFqCrUzncv0SaRA.png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url= \"https://cdn-images-1.medium.com/max/800/1*hr4AQ8riFqCrUzncv0SaRA.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Souce: “Ranking Programming Languages by GitHub Users” — Ben Frederickson"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  Python was designed for readability, and has some similarities to the English language with influence from mathematics.\n",
    "\n",
    "\n",
    "* Python uses new lines to complete a command, as opposed to other programming languages which often use semicolons or parentheses.\n",
    "\n",
    "\n",
    "* Python relies on indentation, using whitespace, to define scope; such as the scope of loops, functions and classes. Other programming languages often use curly-brackets for this purpose.\n",
    "\n",
    "\n",
    "* Python is a like a glue bringing lot of interdisciplinary work together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python in Science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Unexpected effectiveness of Python in science** - Jake VanderPlas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.719102Z",
     "start_time": "2019-03-25T16:30:59.716832Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://image.slidesharecdn.com/pythonfordatascience-151126012608-lva1-app6892/95/why-python-is-better-for-data-science-25-638.jpg?cb=1448502501\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url=\"https://image.slidesharecdn.com/pythonfordatascience-151126012608-lva1-app6892/95/why-python-is-better-for-data-science-25-638.jpg?cb=1448502501\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two versions of python exist Python2 and Python3. We work with Python3. Here you will find more details: https://wiki.python.org/moin/Python2orPython3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a cell below this one and type print(\"Hello\") and run the cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.724283Z",
     "start_time": "2019-03-25T16:30:59.722173Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.727738Z",
     "start_time": "2019-03-25T16:30:59.725539Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1440"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## can also be used as a simple calculator\n",
    "60*24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use as Shell Terminal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter notebooks also provide in-built capabilites to display shell commands. Use ! (exclamation mark) in front of a shell command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.837721Z",
     "start_time": "2019-03-25T16:30:59.731051Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/mali/Documents/CRA_tutorials_2019\r\n"
     ]
    }
   ],
   "source": [
    "## Example\n",
    "!pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python variables can start with a to z or underscore. Variables are *case sensitve*. There are some resevered words that are used as Python keywords (see list included below). You can't use these words for declaring variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.841588Z",
     "start_time": "2019-03-25T16:30:59.839149Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://i.imgur.com/ROm3pQd.png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Python Keywords\n",
    "Image(url=\"https://i.imgur.com/ROm3pQd.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assigning values to the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.845196Z",
     "start_time": "2019-03-25T16:30:59.843090Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a = 10         # integer\n",
    "b = 100.0      # float\n",
    "c = 'Climate'  # a string\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the variables you can do simple arithmetics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.848359Z",
     "start_time": "2019-03-25T16:30:59.846505Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110.0\n"
     ]
    }
   ],
   "source": [
    "print(a+b)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Tip: In a jupyter notebook environment you can just type the variable name to print it without using print command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.852906Z",
     "start_time": "2019-03-25T16:30:59.849285Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Climate'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anything included inside ' ' or \" \" or \"\"\" \"\"\" is treated as a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.856382Z",
     "start_time": "2019-03-25T16:30:59.853789Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Multiple assignments\n",
    "a = b = c = 20\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.860957Z",
     "start_time": "2019-03-25T16:30:59.857382Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Climate'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### This works too\n",
    "a, b, d = 10, 20, 'Climate'\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "**Task:** Calculate the sum of a,b,c and print the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.863917Z",
     "start_time": "2019-03-25T16:30:59.862033Z"
    },
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "print(a+b+c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.866630Z",
     "start_time": "2019-03-25T16:30:59.864968Z"
    }
   },
   "outputs": [],
   "source": [
    "## Your solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Standard Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has 5 standard data-types:\n",
    "\n",
    "* Numbers\n",
    "\n",
    "* Strings\n",
    "\n",
    "* List\n",
    "\n",
    "* Tuple\n",
    "\n",
    "* Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports three different numerical types:\n",
    "\n",
    "* int (signed integers)\n",
    "* float (floating point real values)\n",
    "* complex numbers\n",
    "\n",
    "We won't need further details for the scope of this course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are represented as set of characters inside quotation marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.870061Z",
     "start_time": "2019-03-25T16:30:59.867656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Climate Risk Assessment'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 'Climate Risk Assessment'\n",
    "var # prints complete string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can print subset of strings using slice operator given by the syntax var [start_index : end_index: step].**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: end_index is not included*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.876429Z",
     "start_time": "2019-03-25T16:30:59.873669Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[0] # prints first character\n",
    "       # Note: index starts from zero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: Indexing in Python starts with 0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.881957Z",
     "start_time": "2019-03-25T16:30:59.879109Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Climate'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[0:7] # prints first character till 6th character\n",
    "         # Not necessary to specify step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.886399Z",
     "start_time": "2019-03-25T16:30:59.883374Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Risk Assessment'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var [8:] # prints 9th character till the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "**Task**: Calculate length of the string var? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "*Hint*: Use the function len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.890906Z",
     "start_time": "2019-03-25T16:30:59.887913Z"
    },
    "scrolled": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**Task**: Print the last character of var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.894215Z",
     "start_time": "2019-03-25T16:30:59.891977Z"
    },
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are group of items separated by commas and enclosed with square brackets [ ]. Lists are the most frequent data type in python. The items inside the list can be anything from a number to a string. A list can also be accessed in the same way as we saw above with strings using the slice operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.897007Z",
     "start_time": "2019-03-25T16:30:59.895152Z"
    }
   },
   "outputs": [],
   "source": [
    "clothes = ['shirt', 'top', 'jeans', 'trousers', 'coat']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same syntax as used for strings before "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.900310Z",
     "start_time": "2019-03-25T16:30:59.897988Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'top'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clothes[1] # index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.903531Z",
     "start_time": "2019-03-25T16:30:59.901200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['shirt', 'top', 'jeans']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Slicing as we saw for strings before\n",
    "clothes[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.906615Z",
     "start_time": "2019-03-25T16:30:59.904612Z"
    }
   },
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5,6,7,8,9,10,11,12]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**Task: Can you print only the odd numbers from the above list?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.909803Z",
     "start_time": "2019-03-25T16:30:59.907562Z"
    },
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "print(numbers[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.912807Z",
     "start_time": "2019-03-25T16:30:59.910864Z"
    }
   },
   "outputs": [],
   "source": [
    "climate = [2.5, 'seaice', 'glaciers', 1.5] # you can include numbers and strings together\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add two lists by using `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.916229Z",
     "start_time": "2019-03-25T16:30:59.913765Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.5, 'seaice', 'glaciers', 1.5, 'shirt', 'top', 'jeans', 'trousers', 'coat']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "climate + clothes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Syntax to test if an element belongs to a certain list is similar to writing it in English"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.919355Z",
     "start_time": "2019-03-25T16:30:59.917107Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'shirt' in clothes # just don't put the question mark at the end (;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are similar to lists in the sense that it's also a group of items but it's enclosed in small brackets ( ) compared to a list. Another important difference with lists is that *tuples are immutable*. That means we can't change the values inside a tuple. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.922675Z",
     "start_time": "2019-03-25T16:30:59.920267Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.5, 'seaice', 'glaciers', 1.5)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mini_tuple = (2.5, 'seaice', 'glaciers', 1.5)\n",
    "mini_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexing works the same way as in lists**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.925791Z",
     "start_time": "2019-03-25T16:30:59.923560Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'glaciers'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mini_tuple[2] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.929125Z",
     "start_time": "2019-03-25T16:30:59.926679Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.5, 'seaice', 'glaciers', 'melting']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "climate[3] = 'melting' # list items are mutable\n",
    "climate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples are not mutable!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:30:59.958480Z",
     "start_time": "2019-03-25T16:30:59.930045Z"
    }
   },
   "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-34-4f4779ff9606>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmini_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'melting'\u001b[0m \u001b[0;31m# tuples are not mutable\u001b[0m\u001b[0;34m\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": [
    "mini_tuple[3] = 'melting' # tuples are not mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aha! our first error in Python "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python dictionaries consist of key-value pairs, like a dictionary book. You can also visualise it kind of like a table. Dictionary are declared with curly brackets { }.\n",
    "\n",
    "`Syntax`: dict = {key1:value1, key2:value2}\n",
    "\n",
    "* Key can be any number or string\n",
    "* Value can be anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:24.952161Z",
     "start_time": "2019-03-25T16:31:24.948903Z"
    }
   },
   "outputs": [],
   "source": [
    "cl = {'climate': 'change', 'zip': 3012}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:24.960857Z",
     "start_time": "2019-03-25T16:31:24.955968Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'climate': 'change', 'zip': 3012}\n"
     ]
    }
   ],
   "source": [
    "print (cl) # prints dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values can be assigned or accessed using square brackets [ ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:24.966602Z",
     "start_time": "2019-03-25T16:31:24.964065Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'change'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl['climate']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing keys and values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:24.971970Z",
     "start_time": "2019-03-25T16:31:24.969880Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['climate', 'zip'])\n"
     ]
    }
   ],
   "source": [
    "print (cl.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:24.977021Z",
     "start_time": "2019-03-25T16:31:24.974717Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['change', 3012])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.values()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We also made our first internal-function call above by calling keys() and values(). Python is an objected-oriented programing language. For simplicity that means we can call internal functions using a dot operator, example .keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.034379Z",
     "start_time": "2019-03-25T16:31:24.992038Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why numpy is needed?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Numpy` is a library created to ease mathematical calculation in Python and offers fast and high performance computation. It's the most fundamental library for scientific computing/data analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.044065Z",
     "start_time": "2019-03-25T16:31:25.036431Z"
    }
   },
   "outputs": [],
   "source": [
    "# run this cell\n",
    "np?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.050076Z",
     "start_time": "2019-03-25T16:31:25.046546Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"https://fgnt.github.io/python_crashkurs_doc/_images/numpy_array_t.png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(url= \"https://fgnt.github.io/python_crashkurs_doc/_images/numpy_array_t.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Numpy arrays from Python lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.054962Z",
     "start_time": "2019-03-25T16:31:25.052354Z"
    }
   },
   "outputs": [],
   "source": [
    "a = [1,2,3,4,5,6] # normal list or a normal array\n",
    "# array is commonly referred to as a list of numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.062639Z",
     "start_time": "2019-03-25T16:31:25.056931Z"
    }
   },
   "outputs": [],
   "source": [
    "## to create a numpy array of the above list a just call np.array(a)\n",
    "b = np.array(a)\n",
    "## or directly give the list into numpy array function\n",
    "c = np.array([1,2,3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.068029Z",
     "start_time": "2019-03-25T16:31:25.064686Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1 2 3 4 5 6]\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print (a)\n",
    "print (b)\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: it's hard to tell any difference using the print command. The missing commas is not really a difference and is not important"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.073922Z",
     "start_time": "2019-03-25T16:31:25.069588Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.079018Z",
     "start_time": "2019-03-25T16:31:25.075581Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# There are many ways to create arrays\n",
    "## one of the most often used method is this..\n",
    "np.arange(0,10,2) # use shift-tab to see the syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful way to create an array is when we want a given amount of number between a given range\n",
    "\n",
    "Example: if we need 50 numbers between 0-10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.084425Z",
     "start_time": "2019-03-25T16:31:25.080661Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,\n",
       "        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,\n",
       "        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,\n",
       "        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,\n",
       "        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,\n",
       "        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,\n",
       "        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,\n",
       "        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,\n",
       "        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,\n",
       "        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,10,50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task: Lets say we're asked to calculate sum of only odd numbers lying between in 0-100.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.087823Z",
     "start_time": "2019-03-25T16:31:25.085355Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,\n",
       "       35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,\n",
       "       69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## lets create array of odd numbers between 0-100 using above function\n",
    "c = np.arange(1, 100, 2)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.091632Z",
     "start_time": "2019-03-25T16:31:25.089431Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2500"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calculation of sum is as simple as this\n",
    "c.sum() # another usuage way is np.sum(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.095216Z",
     "start_time": "2019-03-25T16:31:25.092724Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can also calculate mean for example\n",
    "c.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:25.098422Z",
     "start_time": "2019-03-25T16:31:25.096262Z"
    }
   },
   "outputs": [],
   "source": [
    "c. # press tab to see the numerous functions available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike Python lists, numpy arrays can be multidimensional like a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:55.627243Z",
     "start_time": "2019-03-25T16:31:55.622362Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=(3,4)) # creates a 3x4 matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows as to do Linear Algebra calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Numpy` offers huge amount of features which is not possible to cover in this class. But, if I was successful in convincing you to give `Python` a try then I would definetly recommend you to look up some free `Numpy` tutorial online and give it a try. It is very well documented."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Numpy tutorial from Scipy, the official tool for scientific programming in Python](https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zen of Python :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A collection of software principles that influence the design of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-25T16:31:55.636423Z",
     "start_time": "2019-03-25T16:31:55.632781Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    ">>> import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Supplementary info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to install Jupyter notebooks on your PC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 1: [Install conda](https://www.anaconda.com/distribution/). Download the file and run it. It will automatically install Python along with most commonly used packages. \n",
    "\n",
    "You might have to install some of the more specific packages on your own. Most likely, packages like xarray and cartopy need to be install separately.\n",
    "\n",
    "Step 2: For installing separate packages run the command below after opening an anaconda shell. You can also run the command in a windows/linux/apple shell.\n",
    "\n",
    "conda install xarray cartopy netCDF4 \n",
    "\n",
    "These packages should be sufficient to run the code used in this tutorial on your own PC\n",
    "\n",
    "Step3: After this you can use jupyter notebooks by just typing \"jupyter notebook\" on your PC. Alternatively, if you prefer graphical user interface then open Anaconda navigator which will open a graphical UI through which you can open Jupyter Notebooks, download and manage your packages, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: We won't be able to provide individual support for personal installation but Google is at your service.**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "276.4px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}