intro_to_python_full.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "intro_to_python_full.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMF89yRtKx3jF3lqYX8naId",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MKupperman/Intro-to-Python/blob/master/intro_to_python_full.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QcmpNUOAv3d7",
        "colab_type": "text"
      },
      "source": [
        "This is a notebook editor. You can enter code and compile it in chunks called cells. Cells can be either code or text. Text is compiled in markdown language and has limited $\\LaTeX$ support.\n",
        "\n",
        "Press ctrl+enter to evaluate a cell.\n",
        "\n",
        "Let's make a hello world statement:\n",
        "\n",
        "To add a comment to a line, use a # "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZBxpUv3KukH4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d5ecb691-b3a5-4552-c45e-d24fa61935c5"
      },
      "source": [
        "print('hello world')  # Prints 'hello world' w/o the '' marks"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Z8KJzTOvpOl",
        "colab_type": "text"
      },
      "source": [
        "Let's go over some basic ways to store numbers:\n",
        "* Python is weakly typed, so we don't have to tell python what type of data is going to be stored in each variable, it'll work that out for itself."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zZSnqKhKuuDU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_var = 1\n",
        "fish = 'my fish is purple'\n",
        "purple = 0.1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f2-ZEeBMWv1T",
        "colab_type": "text"
      },
      "source": [
        "We can try division, python defines 2 types of division:\n",
        "* Floor division // returns the integer part\n",
        "* Precise division / returns a decimal (float)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GIFKg3QBW7_9",
        "colab_type": "code",
        "outputId": "27f8d5f0-6859-4a3e-ede1-e63d9fbee6b6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "print(5 // 3)\n",
        "print(5 / 3)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1.6666666666666667\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "591XOOQyXJNZ",
        "colab_type": "text"
      },
      "source": [
        "Addition, substraction, multiplication, and powers work the 'usual' way"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JWpgAuQ_XavQ",
        "colab_type": "code",
        "outputId": "27e0efdf-6dc5-4850-b412-c22cd8c7c9c9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "x = 3\n",
        "y = 2.5\n",
        "print(x + y)  # Addition\n",
        "print(x - y)  # Subtraction\n",
        "print(x * y)  # product\n",
        "print(x ** y) # powers"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5.5\n",
            "0.5\n",
            "7.5\n",
            "15.588457268119896\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBhmUfw1cvFf",
        "colab_type": "text"
      },
      "source": [
        "# For loops! \n",
        "\n",
        "To build a for loop in Python3, you need a type of object called an iterable.\n",
        "\n",
        "An interable is an object that has what's called an iter method. We'll look at a simple example of an iter object: range\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ho38swicdr-S",
        "colab_type": "code",
        "outputId": "fc0b3b89-a688-408a-ee04-b37f84cbe9b1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        }
      },
      "source": [
        "for x in range(12):\n",
        "  print(x)\n",
        "  "
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOy-MR7HeBxO",
        "colab_type": "text"
      },
      "source": [
        "Iterables are like containers (if you're coming from C/C++/matlab/...), but not necessarily. These are objects with an 'iter method'."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2cxB4tdaYlU5",
        "colab_type": "text"
      },
      "source": [
        "Now let's look at ways to mainipulate data with a data structure. We'll look at lists and dictionaries. Lists are lists of data.\n",
        "\n",
        "Both lists and dictionaries support heterogeneous data types, so you can put anything in it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SicWENo9u2c3",
        "colab_type": "code",
        "outputId": "8a0bfed2-c669-4813-a86d-2b97da353fb3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "x = []  # Declare a list with no elements\n",
        "x.append(3)  # Add the value 3 to the list\n",
        "print(x)  # Print the list\n",
        "x.append('tomato')\n",
        "print(x)\n",
        "# Let's get something from the list\n",
        "# Python (like almost every programming language is 0 based)\n",
        "print(x[0] + 1) # We can put math inside the print statement\n",
        "# Print the entire list:\n",
        "print(x[:])\n",
        "# Get the last term in a list:\n",
        "print(x[-1])"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3]\n",
            "[3, 'tomato']\n",
            "4\n",
            "[3, 'tomato']\n",
            "tomato\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABdgDrHbZl-M",
        "colab_type": "text"
      },
      "source": [
        "You can even nest lists recursively\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rk9mOTvGZpKn",
        "colab_type": "code",
        "outputId": "108ec970-f2b9-4d06-fcfe-71a7dd56d548",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "mid_list = list()  # another way to declare a list\n",
        "mid_list.append(33)\n",
        "mid_list.append('potato')\n",
        "print(mid_list)\n",
        "x.append(mid_list)\n",
        "print(x)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[33, 'potato']\n",
            "[3, 'tomato', [33, 'potato']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "apQEuT4UfHQa",
        "colab_type": "text"
      },
      "source": [
        "Let's make a list of values 2 ways"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bhnBjiXZvQ4d",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d1544684-d12a-454e-a5bb-4c0d958fb162"
      },
      "source": [
        "x = []\n",
        "for y in range(12):\n",
        "  x.append(y)\n",
        "print(x)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OTxM668BcO16",
        "colab_type": "code",
        "outputId": "14d97637-d592-413c-b0d1-af21a9bc7c46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# To generate a list of numbers we can use list comprehension\n",
        "# which still uses a for loop\n",
        "num_list = [value for value in range(12)] \n",
        "print(num_list)\n",
        "# We can use logic in the list as well:\n",
        "num_list = [value for value in range(12) if value % 2 == 0] \n",
        "print(num_list)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
            "[0, 2, 4, 6, 8, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IifaWA_xXAhq",
        "colab_type": "code",
        "outputId": "c760ed3f-c494-4e78-e3a3-12531b43186e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "# Scoping:\n",
        "value = 1\n",
        "# To generate a list of numbers we can use list comprehension\n",
        "# which still uses a for loop\n",
        "num_list = [value for value in range(12)] \n",
        "print(num_list)\n",
        "# We can use logic in the list as well:\n",
        "num_list = [value for value in range(12) if value % 2 == 0] \n",
        "print(num_list)\n",
        "print(value)\n",
        "\n",
        "for value in range(12):\n",
        "  pass\n",
        "print(value)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
            "[0, 2, 4, 6, 8, 10]\n",
            "1\n",
            "11\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YmQ4vVYGaQNe",
        "colab_type": "text"
      },
      "source": [
        "# Dictionaries\n",
        "\n",
        "The math here is called a hash table. Dictionaries can store large amounts of data and do fast lookups, unlike with lists. Dictionaries don't store order, which you may or may not need, like storing a list of observations when parsing through a much bigger list. Dictionaries use a `key:value` pair to store data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0RtHVTROaOff",
        "colab_type": "code",
        "outputId": "2a26049d-2be2-41fe-e0b4-2f1b67401da5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = {}  # Declare an empty dictionary\n",
        "x = {'key': 'value'}  # Example of basic structure of a dict pair\n",
        "x['hashable key'] = 23\n",
        "x[12] = 'new string'  # The only requirement for a dictionary key is that it is 'hashable'\n",
        "# All numbers and strings are hashable\n",
        "print(x)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'key': 'value', 'hashable key': 23, 12: 'new string'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1FRRnDBg3j3R",
        "colab_type": "text"
      },
      "source": [
        "## Dictionary comprehension\n",
        "\n",
        "Like lists, we can build dictionaries through comprehension. Comprehension is one of the most powerful aspects of the Python language because you can do a loop, logic, call functions, and store the results all in one line. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AjA2Lbt93_rW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e369e95c-614b-4422-c913-ff45bea64324"
      },
      "source": [
        "# We'll store the result of a calculation \n",
        "demo_dict = {i:10 // (i+1) for i in range(10)} \n",
        "print(demo_dict)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{0: 10, 1: 5, 2: 3, 3: 2, 4: 2, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lyk5hQU2fYuU",
        "colab_type": "text"
      },
      "source": [
        "# Control statements\n",
        "\n",
        "Python uses True, False, is, and not for logical statements.\n",
        "\n",
        "Python has 3 basic control statements:\n",
        "* if \n",
        "* elif (elif is a combined if-else statement)\n",
        "* else\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UYCykaeMfXy2",
        "colab_type": "code",
        "outputId": "0588e794-609c-4d09-a973-f3f9d939ddc8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 1\n",
        "y = 'my_string'\n",
        "\n",
        "if x is 1: # if cond is true, then:\n",
        "  print('x is one')\n",
        "elif x is not y:  #else if Test for equality\n",
        "  print('x is y')\n",
        "elif False:\n",
        "  print('lol')\n",
        "else:\n",
        "  print('x is not 1 and x is y')\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x is one\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vWCLi38c2pX_",
        "colab_type": "text"
      },
      "source": [
        "## List comprehension revisited\n",
        "If we need to add an else to a list generated with list comprehension, the syntax needs to change slightly. We move the control statement (if-elif else) to the front, before the **for-in** statement.   "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yOrF5_Ce25qc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "935313a3-4955-4921-94f3-e34efd7abd35"
      },
      "source": [
        "# squares of odd numbers\n",
        "x = [val **2  for val in range(7) if val % 2 is not 0] \n",
        "print(x)\n",
        "# square if it's odd, otherwise store a 0\n",
        "x = [val **2 if val % 2 is not 0 else 0 for val in range(7)] \n",
        "print(x)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 9, 25]\n",
            "[0, 1, 0, 9, 0, 25, 0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gr6p_ftr3a54",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XxiqNKg7gsrT",
        "colab_type": "text"
      },
      "source": [
        "# Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S1OW-4D6guWY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def add2(x, y):\n",
        "  \"\"\"\n",
        "  This is called a docstring, it provides all documentation for your function.\n",
        "\n",
        "  Thus function adds together it's 2 arguments and returns one value.\n",
        "  \n",
        "  >>> add2(2,3)\n",
        "  5\n",
        "  \"\"\"\n",
        "  return x + y\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lxM7LCvbg3wz",
        "colab_type": "code",
        "outputId": "03ff4ecc-793d-4bd8-cbac-e750cf28be3b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        }
      },
      "source": [
        "print(add2.__doc__)\n",
        "# Some function have more complicated docstrings\n",
        "print(range.__doc__)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "  This is called a docstring, it provides all documentation for your function.\n",
            "\n",
            "  Thus function adds together it's 2 arguments and returns one value.\n",
            "  \n",
            "  >>> add2(2,3)\n",
            "  5\n",
            "  \n",
            "range(stop) -> range object\n",
            "range(start, stop[, step]) -> range object\n",
            "\n",
            "Return an object that produces a sequence of integers from start (inclusive)\n",
            "to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
            "start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
            "These are exactly the valid indices for a list of 4 elements.\n",
            "When step is given, it specifies the increment (or decrement).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vg8xk7CTg7iS",
        "colab_type": "code",
        "outputId": "e9884a43-49e7-4b7b-f9f5-8c6ece92038c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "add2(2,5)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SoMVYu3EhJhZ",
        "colab_type": "code",
        "outputId": "3691ba5e-9669-4e72-f222-2667e91ac0a6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "print(add2(x=2, y=5))\n",
        "print(add2(y=5, x=2))"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfdbxFWchNQP",
        "colab_type": "code",
        "outputId": "b82a698a-3a3d-4727-a921-9b6a15767c1a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 2\n",
        "y = 5\n",
        "add2(x=x, y=y)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KKu-oB_gj7ut",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RlHRghVCkDdC",
        "colab_type": "text"
      },
      "source": [
        "# Example\n",
        "\n",
        "Let's look at a real example: Newton's method rootfinding (MTH 351)\n",
        "\n",
        "Newton's method implements the following iteration scheme:\n",
        "\n",
        "$x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$\n",
        "\n",
        "Let's let $f(x) = sin(x)$, then $f'(x) = cos(x)$\n",
        "\n",
        "We'll use the numerical python library numpy, num(erical)py(thon)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qtc3UzFAlO2W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vIFZLYrMmban",
        "colab_type": "text"
      },
      "source": [
        "We'll access functions from the library through dot indexing: \n",
        "\n",
        "package.function_name()"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XkREEmkIkVvB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def newton_method_step(x0):\n",
        "  \"\"\"\n",
        "  Returns the next step in newton's method.\n",
        "  \"\"\"\n",
        "  f_xn = numpy.sin(x0)  # f(x_n)\n",
        "  fprime = numpy.cos(x0)  # f'(x_n) \n",
        "  x_new = x0 - f_xn / fprime\n",
        "  return x_new"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pAHO3rCsmlP5",
        "colab_type": "code",
        "outputId": "69f810ce-85e5-488e-a703-801ed60d515b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# Let's test it\n",
        "print(newton_method_step(0))  # Should return 0\n",
        "print(newton_method_step(0.5))  # Should not return 0"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.0\n",
            "-0.046302489843790484\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WpyG3HWCmyaj",
        "colab_type": "code",
        "outputId": "ab2b7ffc-33ec-4384-f03b-f10618308933",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Now let's run out our algorithm:\n",
        "x0 = 0.9\n",
        "approximations = [x0]  # Make a list with 1 value\n",
        "for _ in range(20):  # how many steps do you want to run?\n",
        "  approximations.append(newton_method_step(approximations[-1]))\n",
        "  # get the last approximation\n",
        "  # Compute the next step\n",
        "  # Append to list\n",
        "print(approximations)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.9, -0.3601582175503394, 0.016425278522749276, -1.4772834857866568e-06, 1.0748848100657071e-18, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BhSdHcafoa8D",
        "colab_type": "code",
        "outputId": "b58a0f07-1d4f-4fc0-a580-70d097b71ec6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "# Let's visualize our results\n",
        "import matplotlib.pyplot as plt  # Matlab style plotting package standard in\n",
        "# scientific computing\n",
        "\n",
        "plt.scatter(x=approximations, y=numpy.sin(approximations))\n",
        "# plt.show() # Let's see what we got\n",
        "x_vals = numpy.linspace(-numpy.pi, numpy.pi, 314)\n",
        "y_vals = numpy.sin(x_vals)\n",
        "plt.plot(x_vals, y_vals)  # Let's add the 'true' curve\n",
        "plt.xlabel('my x label')\n",
        "plt.ylabel('my cool y label')\n",
        "plt.title('Math Club made a plot!')\n",
        "plt.show()  # show the figure below\n",
        "# plt.savefig('my_fig.png') uncomment to save the figure locally"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OFDoYWDUt7w4",
        "colab_type": "text"
      },
      "source": [
        "#Exercises\n",
        "Some begining programming exercises with python:\n",
        "\n",
        "1. Sequences.\n",
        "  * Lookup the documentation for the range function. Make a list of the numbers 2,3,4,5,6 with a for loop.\n",
        "  * Create the same sequnce with the numpy linspace command. Don't use a for loop\n",
        "2. Use list comprehension to generate a new list of squares of the numbers you created in 1 (try with both methods). The power function in numpy may be helpful.\n",
        "\n",
        "3. Append 0 and -1 to the list. Then use the sort method to order them. Try this with `reverse=True`.\n",
        "\n",
        "4. Scatter plot the data using the initial list as `x` and the new list as `y`. \n",
        "\n",
        "5. Plot the square function `(x ** 2)`  on the same graph from 0 to 7.\n",
        "\n",
        "6. Save the resulting image to a png file. \n",
        "\n",
        "\n"
      ]
    }
  ]
}