vclTutorial_PartOne.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter Notebooks \n",
    "\n",
    "This is a short tutorial that will go over some python basics in Jupyter. If you are familar with python or have previous programming experience check out this incredible [interactive book](https://jakevdp.github.io/PythonDataScienceHandbook/) that goes into a lot more detail. This tutorial will cover the following: \n",
    "\n",
    "* Launching and running code in Jupyter\n",
    "* Variables \n",
    "* Control flow\n",
    "* Functions \n",
    "* Introduction to the following packages: \n",
    " + Numpy\n",
    " \n",
    " \n",
    " \n",
    " ## Launching Jupyter\n",
    " \n",
    " There are several easy ways to [get jupyter notebook/labs](https://jupyter.readthedocs.io/en/latest/install.html). The easiest and recommended way is by downloading the Anaconda installation which has Python, Jupyter notebooks and other important and useful packages bundled into one. \n",
    "\n",
    "Once you have the Anaconda installation, simply open Anaconda and click on jupyter notebook. A quicker way, which doesn’t involve opening Anaconda, is to simply open your terminal (on Mac) or cmd (on windows) and typing: ```jupyter notebook``` \n",
    "\n",
    " ## The Basic Anatomy of a Jupyter Notebook\n",
    " \n",
    " In a Jupyter notebook, a **cell** is a box where you can place either code or text. A code cell is where you can put code to be run by the notebook's kernel and a text cell is where you can format text using markdown to be displayed when the cell is run. The **kernel** is what executes the code that is written in the code cells and is applied to the entire notebook, this means that you can do things like import packages and define functions in one cell and you can use them in another. The kernel for this notebook is for Python but there are lots of other kernels for other languages such as Java and R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Just ran some code\n"
     ]
    }
   ],
   "source": [
    "#This is a code cell, which is able to execute any python code \n",
    "#To run this code cell simply press Shift + Enter\n",
    "print(\"Just ran some code\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is a Markdown cell\n",
    "## this is a smaller header\n",
    "### this is an even smaller header\n",
    "\n",
    "Markdown is a simple markup language that is easily converted to HTML\n",
    "\n",
    "<font face=\"webdings\" color=\"blue\"> I can format text here so that it is presented the way that I want </font>\n",
    "\n",
    "\n",
    "\n",
    "press Shift + Enter to output the formatted text\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "\"A variable is a symbol that can be asigned any value of the types below, that may change during the execution of a porgram.\" \n",
    "\n",
    "Python comes with 5 standard variable types: \n",
    "* [Numbers](https://docs.python.org/2.4/lib/typesnumeric.html)\n",
    "* [Strings](https://en.wikipedia.org/wiki/String_(computer_science)) \n",
    "* [List](https://en.wikipedia.org/wiki/List_(abstract_data_type)) \n",
    "* [Tuple](https://computersciencewiki.org/index.php/Tuple) \n",
    "* [Dictionary](https://en.wikipedia.org/wiki/Associative_array)\n",
    "* [Booleans](https://www.pythonforbeginners.com/basics/boolean)\n",
    "\n",
    "The textbook linked goes into greater detail about data types in python and what happens \"under the hood\". We are going to only look at the first three data types mentioned in this tutorial with the others being covered in later workshops. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-1ea1afd17ccd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#running th above code should create an error. A variable, such as x has to be defined and assigned a value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "#running th above code should create an error. A variable, such as x has to be defined and assigned a value\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#x is the variable and it can take on any value from the allowed datatypes. Below x is a number\n",
    "x = 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#below is a string\n",
    "y = 'hello'\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#below is a list, a list can be empty when it is declared \n",
    "z = []\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "Lists normally can only be of one data type, however with python you can create a list with multiple datatypes. Note that the inbuilt python lists, due to this ability to have multiple types, are very slow to work with and in any real application its a far better idea to use a numpy array (more on this later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hello']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = [x,y]\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Control Flow and Conditionals\n",
    "\n",
    "Control Flow is the order in which the code executes. In Python the code will normally execute in a top-down order, however this can be manipulated using conditionals and loops. Conditionals such as **if/then** ,**if/else** and **elif** statements evaluate the true or falsity of given statements and then execute pieces of code based on this evaluation.\n",
    "\n",
    "\n",
    "### If/then statements\n",
    "\n",
    "The if/then statement is a type of conditional that looks at a condition and evaluates **if** it is true or false and **then** determines what the code should do based on that information. A real world example of an if/then statement would be something like: **if** it is raining **then** I will bring an umbrella. In code this would look something like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will bring an umbrella\n"
     ]
    }
   ],
   "source": [
    "raining = True\n",
    "\n",
    "if raining:\n",
    "    print('I will bring an umbrella')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If/Else statements\n",
    "\n",
    "What if you want the code to do something else when the if statement evaluates to false? What if you want to wear a nice hat if it is not raining outside? An If/Else statement allows you to tell the code to do something **else** when a condition evaluates to false. To keep with the previous example, this would look something like if it is raining then I will bring an umbrella, if it is not raining I will wear my nice hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will wear my fancy hat\n"
     ]
    }
   ],
   "source": [
    "raining = False\n",
    "\n",
    "if raining:\n",
    "    print('I will bring an umbrella')\n",
    "else:\n",
    "    print('I will wear my nice hat')\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What do you think the following cell will output if we run the previous cell first? What if we run it after running the cell before that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will wear my fancy hat\n"
     ]
    }
   ],
   "source": [
    "if raining:\n",
    "    print('I will bring an umbrella')\n",
    "else:\n",
    "    print('I will wear my nice hat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elif Statements\n",
    "\n",
    "Python does not have a 'switch' statement like some other commonly used languages, instead Python uses **elif** statements (think of it like 'else if'). An elif statement allows you to evaluate multiple conditions and execute a piece of code based on this evaluation. An elif statement typically ends in an else statement to cover any other possible cases. For example, i could write a statement that says **if** it is raining **then** i will bring an umbrella, **elif** it is sunny out **then** i will wear my sunglasses, if the weather is anything **else** I will wear my nice hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will wear my sunglasses\n"
     ]
    }
   ],
   "source": [
    "raining = False\n",
    "sunny = True\n",
    "\n",
    "if raining:\n",
    "    print('I will bring an umbrella')\n",
    "elif sunny:\n",
    "    print('I will wear my sunglasses')\n",
    "else:\n",
    "    print('I will wear my nice hat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Logic\n",
    "\n",
    "In python there are three logic operators: and, or, and not. \n",
    "\n",
    "A statement using the **and** operator evaluates true if both values around it are true and is written like: x and y\n",
    "\n",
    "A statement using the **or** operator evaluates true if both values around it are true or if only one value is true and is written like: x or y\n",
    "\n",
    "A statement using the **not** operator evaluates true if the statement it is used in front of is false it are true and is written like:    \n",
    "not x\n",
    "\n",
    "## What do you think the following expressions will evaluate to?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "print(x and y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x or y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Based on what we now know about conditionals and boolean logic, what will the following expression output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "z = False\n",
    "\n",
    "if not x:\n",
    "    print('A')\n",
    "elif x and y:\n",
    "    print('B')\n",
    "elif y or z:\n",
    "    print('C')\n",
    "elif z or x:\n",
    "    print('D')\n",
    "else:\n",
    "    print('E')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Functions\n",
    "\n",
    "One of the most important things you will need to do at some point is make a function. A function is something that can take in a value and apply some transformations to it and return it. Note that functions don’t always have to do this. There is a lot more depth to python with the ability to create different types of functions which you can read about in the textbook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#below is a function. Runnning it wont call the function. You must explicitly call on the function \n",
    "def someFunction(x):\n",
    "    return x*2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#What do you expect the value of y to be?\n",
    "x=4\n",
    "y = someFunction(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some practise\n",
    "- Build a function that returns your name\n",
    "- Build a function that given two sides of a triangle returns the length of the third side\n",
    "- Build a function that returns your age in dog years\n",
    "\n",
    "\n",
    "## Packages\n",
    "All of the above was a simple introduction to python syntax, using base python. It should be noted that python out of the box is a dynamically typed language, meaning you don’t need to declare the type of each variable. The complier can figure a lot out for you. This is great as it makes code easier to read, but it means everything runs very slowly. To get over this hurdle there have been a number of packages developed that offer workarounds, increasing the speed of your code. The most commonly used of these for scientific computing is called [numpy](http://www.numpy.org/). Numpy and another package pandas should really be the foundation of any analysis work that you conduct. \n",
    "\n",
    "In python packages have to be installed and then loaded. If you are using the Anaconda installation numpy comes pre-installed. If you are not using anaconda, install numpy now. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Base python:\n",
      "[0.04982157599988568, 0.03820652100012012, 0.035852075000093464, 0.035830556000291836]\n",
      "Numpy array:\n",
      "[0.0016413469998042274, 0.0017548589999023534, 0.0008335620000252675, 0.0003993720001744805]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from timeit import Timer\n",
    "\n",
    "size_of_vec = 1000\n",
    "X_list = range(size_of_vec)\n",
    "Y_list = range(size_of_vec)\n",
    "X = np.arange(size_of_vec)\n",
    "Y = np.arange(size_of_vec)\n",
    "\n",
    "def pure_python_version():\n",
    "    Z = [X_list[i] + Y_list[i] for i in range(len(X_list)) ]\n",
    "\n",
    "def numpy_version():\n",
    "    Z = X + Y\n",
    "\n",
    "timer_obj1 = Timer(\"pure_python_version()\", \n",
    "                   \"from __main__ import pure_python_version\")\n",
    "timer_obj2 = Timer(\"numpy_version()\", \n",
    "                   \"from __main__ import numpy_version\")\n",
    "\n",
    "print('Base python:');print(timer_obj1.repeat(repeat=4, number=100))\n",
    "print('Numpy array:');print(timer_obj2.repeat(repeat=4, number=100)) # repeat to prove it!\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays in numpy\n",
    "\n",
    "An array in numpy is declared before hand, i.e. it is static unlike a python array. This allows for much faster operations. Numpy also comes with a lot of inbuilt functions that have been optimised. Numpy also allows for [vectorisaton](https://en.wikipedia.org/wiki/Array_programming)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  8, 10, 12])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Declaring an arrary\n",
    "array = np.array([1,2,4,5,6])\n",
    "#multiply array by 2\n",
    "array*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a lot to cover about numpy but [here](http://www.labri.fr/perso/nrougier/teaching/numpy.100/) is a great place to start that covers a lot of the basics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NEXT TIME\n",
    "\n",
    "* DATAFRAMES \n",
    "* PANDAS\n",
    "* PLOTTING WITH MATPLOTLIB\n",
    "\n",
    "Please familiarise yourelf with what we went over today and some basics about dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}