Lesson 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This week, we'll look at plotting a graph! This is going to use a lot of the skills we have covered up until now.\n",
    "\n",
    "We'll need to create a list. Can you create a list below filled with numbers ranging from 0 to 200."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a for loop, can you print out each element of the list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, can you multiply each element of the list by 3 and put the result into a new list \n",
    "\n",
    "HINT: use a for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're going to plot your new list in a graph, before we do that though, we need to know about modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules are other bits of code that have been put together in a convenient package for us to use. For example, we could use the 'random' module to get some random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.randint(0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, \"import random\" will tell Python that we want to use the package called \"random\".\n",
    "\n",
    "\"random.randint(0, 10)\" tells Python we would like to use the function \"randint\" within \"random\", this will return a random number between 0 and 10.\n",
    "\n",
    "There are thousands and thousands of modules available to use, for data analysis the commone ones are:\n",
    "\n",
    "- Pandas\n",
    "- Numpy\n",
    "- Scipy\n",
    "- Matplotlib\n",
    "- Seaborn\n",
    "\n",
    "The first 3 deal with manipulating data and the last 2 plot the data. There are lots of other modules that you may want to use - knowledge of these comes from googling \"How to....\" and reading the answers, most common modules are already included within your installation of Anaconda, however, if you need to install new modules there are several (some convenient, some more tricky) ways to install them - but this is out of thescope of this tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting a Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The easiest way to get started plotting graphs is to use matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code tells Python we want to use the collection of code that comes in matplotlib in pyplot, and we don't want to type that in every time, so we want to alias it as plt. Now we can call all the functions within matplotlib.pyplot by using plt.\n",
    "\n",
    "The code below creates an array with 100 elements, each as a random number between 0 and 10, then plots it in a line graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array = []\n",
    "for i in range(100):\n",
    "    my_array.append(random.randint(0, 10))\n",
    "\n",
    "plt.plot(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, plotting a graph couldn't be easier! We can plot lots of different types of plot too! \n",
    "\n",
    "If we only give plt.plot a single array, it plots the array on the y axis, the x axis is, by default, a sequential list of numbers.\n",
    "\n",
    "i.e. we can get the same plot as above by using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(range(len(my_array)), my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to annotate the above code explaining what range(len(my_array)) does."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could plot a scatter plot using the above code by chainging one word:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(range(len(my_array)), my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: When using scatter, the x-axis argument is required."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you plot the array you created at the start of this lesson?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now can you add axis labels to this graph? You will need to look up how to do this yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "no_samples = [10**i for i in range(5)]\n",
    "timings = np.random.rand(5)\n",
    "timings = [timings[i]+(no_samples[i]/(i+1)) for i in range(len(timings))]\n",
    "data = []\n",
    "\n",
    "for i,j in zip(no_samples, timings):\n",
    "    data.append(i)\n",
    "    data.append(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I expect you're probably getting bored of seeing this problem!\n",
    "\n",
    "I'd like you to solve it again (description below) and plot a line graph (with axis labels) showing the number of samples on the x axis and the timing on the y axis.\n",
    "\n",
    "Description:\n",
    "\n",
    "I receieved some benchmarking data in a file (benchmarking is testing how fast a code runs). I was given a file where the first line (and every other line after that) contained the size of the system, and the second (and every other line after that) contained the time it took to calculate the required property."
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}